Upstream version 10.39.225.0

[platform/framework/web/crosswalk.git] / src / net / spdy / buffered_spdy_framer_unittest.cc

diff --git a/src/net/spdy/buffered_spdy_framer_unittest.cc b/src/net/spdy/buffered_spdy_framer_unittest.cc
index 78f94e9..3e106f9 100644 (file)
--- a/src/net/spdy/buffered_spdy_framer_unittest.cc
+++ b/src/net/spdy/buffered_spdy_framer_unittest.cc
@@ -20,7 +20,9 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
         syn_frame_count_(0),
         syn_reply_frame_count_(0),
         headers_frame_count_(0),
-        header_stream_id_(-1) {
+        push_promise_frame_count_(0),
+        header_stream_id_(static_cast<SpdyStreamId>(-1)),
+        promised_stream_id_(static_cast<SpdyStreamId>(-1)) {
   }
 
   virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {
@@ -87,7 +89,7 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
     setting_count_++;
   }
 
-  virtual void OnPing(SpdyPingId unique_id) OVERRIDE {}
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {}
 
   virtual void OnRstStream(SpdyStreamId stream_id,
                            SpdyRstStreamStatus status) OVERRIDE {
@@ -111,8 +113,22 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
   void OnPing(const SpdyFrame& frame) {}
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
                               uint32 delta_window_size) OVERRIDE {}
+
   virtual void OnPushPromise(SpdyStreamId stream_id,
-                             SpdyStreamId promised_stream_id) OVERRIDE {}
+                             SpdyStreamId promised_stream_id,
+                             const SpdyHeaderBlock& headers) OVERRIDE {
+    header_stream_id_ = stream_id;
+    EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
+    push_promise_frame_count_++;
+    promised_stream_id_ = promised_stream_id;
+    EXPECT_NE(promised_stream_id_, SpdyFramer::kInvalidStream);
+    headers_ = headers;
+  }
+
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE {
+    return true;
+  }
+
   void OnCredential(const SpdyFrame& frame) {}
 
   // Convenience function which runs a framer simulation with particular input.
@@ -143,11 +159,14 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
   int syn_frame_count_;
   int syn_reply_frame_count_;
   int headers_frame_count_;
+  int push_promise_frame_count_;
 
   // Header block streaming state:
   SpdyStreamId header_stream_id_;
+  SpdyStreamId promised_stream_id_;
 
-  // Headers from OnSyn, OnSynReply and OnHeaders for verification.
+  // Headers from OnSyn, OnSynReply, OnHeaders and OnPushPromise for
+  // verification.
   SpdyHeaderBlock headers_;
 };
 
@@ -193,14 +212,13 @@ INSTANTIATE_TEST_CASE_P(
     NextProto,
     BufferedSpdyFramerTest,
     testing::Values(kProtoDeprecatedSPDY2,
-                    kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2,
-                    kProtoHTTP2Draft04));
+                    kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
 
 TEST_P(BufferedSpdyFramerTest, OnSetting) {
   SpdyFramer framer(spdy_version());
   SpdySettingsIR settings_ir;
-  settings_ir.AddSetting(SETTINGS_UPLOAD_BANDWIDTH, false, false, 0x00000002);
-  settings_ir.AddSetting(SETTINGS_DOWNLOAD_BANDWIDTH, false, false, 0x00000003);
+  settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, false, false, 2);
+  settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, false, false, 3);
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
   TestBufferedSpdyVisitor visitor(spdy_version());
 
@@ -212,6 +230,10 @@ TEST_P(BufferedSpdyFramerTest, OnSetting) {
 }
 
 TEST_P(BufferedSpdyFramerTest, ReadSynStreamHeaderBlock) {
+  if (spdy_version() > SPDY3) {
+    // SYN_STREAM not supported in SPDY>3.
+    return;
+  }
   SpdyHeaderBlock headers;
   headers["aa"] = "vv";
   headers["bb"] = "ww";
@@ -232,10 +254,15 @@ TEST_P(BufferedSpdyFramerTest, ReadSynStreamHeaderBlock) {
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
+  EXPECT_EQ(0, visitor.push_promise_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(BufferedSpdyFramerTest, ReadSynReplyHeaderBlock) {
+  if (spdy_version() > SPDY3) {
+    // SYN_REPLY not supported in SPDY>3.
+    return;
+  }
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
@@ -252,7 +279,8 @@ TEST_P(BufferedSpdyFramerTest, ReadSynReplyHeaderBlock) {
       control_frame.get()->size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.syn_frame_count_);
-  if(spdy_version() < SPDY4) {
+  EXPECT_EQ(0, visitor.push_promise_frame_count_);
+  if (spdy_version() < SPDY4) {
     EXPECT_EQ(1, visitor.syn_reply_frame_count_);
     EXPECT_EQ(0, visitor.headers_frame_count_);
   } else {
@@ -281,7 +309,33 @@ TEST_P(BufferedSpdyFramerTest, ReadHeadersHeaderBlock) {
   EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
+  EXPECT_EQ(0, visitor.push_promise_frame_count_);
+  EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
+}
+
+TEST_P(BufferedSpdyFramerTest, ReadPushPromiseHeaderBlock) {
+  if (spdy_version() < SPDY4)
+    return;
+  SpdyHeaderBlock headers;
+  headers["alpha"] = "beta";
+  headers["gamma"] = "delta";
+  BufferedSpdyFramer framer(spdy_version(), true);
+  scoped_ptr<SpdyFrame> control_frame(
+      framer.CreatePushPromise(1, 2, &headers));
+  EXPECT_TRUE(control_frame.get() != NULL);
+
+  TestBufferedSpdyVisitor visitor(spdy_version());
+  visitor.SimulateInFramer(
+      reinterpret_cast<unsigned char*>(control_frame.get()->data()),
+      control_frame.get()->size());
+  EXPECT_EQ(0, visitor.error_count_);
+  EXPECT_EQ(0, visitor.syn_frame_count_);
+  EXPECT_EQ(0, visitor.syn_reply_frame_count_);
+  EXPECT_EQ(0, visitor.headers_frame_count_);
+  EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
+  EXPECT_EQ(1u, visitor.header_stream_id_);
+  EXPECT_EQ(2u, visitor.promised_stream_id_);
 }
 
 }  // namespace net