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 31a649d..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 {
@@ -39,7 +41,6 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
-                           uint8 credential_slot,
                            bool fin,
                            bool unidirectional,
                            const SpdyHeaderBlock& headers) OVERRIDE {
@@ -67,6 +68,12 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
     headers_ = headers;
   }
 
+  virtual void OnDataFrameHeader(SpdyStreamId stream_id,
+                                 size_t length,
+                                 bool fin) OVERRIDE {
+    ADD_FAILURE() << "Unexpected OnDataFrameHeader call.";
+  }
+
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
@@ -82,7 +89,7 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
     setting_count_++;
   }
 
-  virtual void OnPing(uint32 unique_id) OVERRIDE {}
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {}
 
   virtual void OnRstStream(SpdyStreamId stream_id,
                            SpdyRstStreamStatus status) OVERRIDE {
@@ -106,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.
@@ -138,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_;
 };
 
@@ -188,18 +212,14 @@ INSTANTIATE_TEST_CASE_P(
     NextProto,
     BufferedSpdyFramerTest,
     testing::Values(kProtoDeprecatedSPDY2,
-                    kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2,
-                    kProtoHTTP2Draft04));
+                    kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
 
 TEST_P(BufferedSpdyFramerTest, OnSetting) {
   SpdyFramer framer(spdy_version());
-  SettingsMap settings;
-  settings[SETTINGS_UPLOAD_BANDWIDTH] =
-      SettingsFlagsAndValue(SETTINGS_FLAG_NONE, 0x00000002);
-  settings[SETTINGS_DOWNLOAD_BANDWIDTH] =
-      SettingsFlagsAndValue(SETTINGS_FLAG_NONE, 0x00000003);
-
-  scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
+  SpdySettingsIR settings_ir;
+  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());
 
   visitor.SimulateInFramer(
@@ -210,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";
@@ -218,9 +242,7 @@ TEST_P(BufferedSpdyFramerTest, ReadSynStreamHeaderBlock) {
       framer.CreateSynStream(1,                        // stream_id
                              0,                        // associated_stream_id
                              1,                        // priority
-                             0,                        // credential_slot
                              CONTROL_FLAG_NONE,
-                             true,                     // compress
                              &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
 
@@ -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";
@@ -243,7 +270,6 @@ TEST_P(BufferedSpdyFramerTest, ReadSynReplyHeaderBlock) {
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateSynReply(1,                        // stream_id
                             CONTROL_FLAG_NONE,
-                            true,                     // compress
                             &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
 
@@ -253,8 +279,14 @@ TEST_P(BufferedSpdyFramerTest, ReadSynReplyHeaderBlock) {
       control_frame.get()->size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.syn_frame_count_);
-  EXPECT_EQ(1, visitor.syn_reply_frame_count_);
-  EXPECT_EQ(0, visitor.headers_frame_count_);
+  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 {
+    EXPECT_EQ(0, visitor.syn_reply_frame_count_);
+    EXPECT_EQ(1, visitor.headers_frame_count_);
+  }
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
@@ -266,7 +298,6 @@ TEST_P(BufferedSpdyFramerTest, ReadHeadersHeaderBlock) {
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateHeaders(1,                        // stream_id
                            CONTROL_FLAG_NONE,
-                           true,                    // compress
                            &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
 
@@ -278,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