HTTP2 draft 14 support

net/spdy/spdy_framer_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 180 matching lines @@
       LOG(FATAL);
     }
 
     virtual void OnPriority(SpdyStreamId stream_id,
                             SpdyStreamId parent_stream_id,
                             uint8 weight,
                             bool exclusive) OVERRIDE {
       // Do nothing.
     }
 
+    virtual bool OnUnknownFrame(SpdyStreamId stream_id,
+                                int frame_type) override {
+      LOG(FATAL);
+      return false;
+    }
+
     char* ReleaseBuffer() {
       CHECK(finished_);
       return buffer_.release();
     }
 
     virtual void OnWindowUpdate(SpdyStreamId stream_id,
                                 uint32 delta_window_size) OVERRIDE {
       LOG(FATAL);
     }
 
@@ skipping 31 matching lines @@
         headers_frame_count_(0),
         push_promise_frame_count_(0),
         goaway_count_(0),
         setting_count_(0),
         settings_ack_sent_(0),
         settings_ack_received_(0),
         continuation_count_(0),
         altsvc_count_(0),
         priority_count_(0),
         test_altsvc_ir_(0),
+        on_unknown_frame_result_(false),
         last_window_update_stream_(0),
         last_window_update_delta_(0),
         last_push_promise_stream_(0),
         last_push_promise_promised_stream_(0),
         data_bytes_(0),
         fin_frame_count_(0),
         fin_opaque_data_(),
         fin_flag_count_(0),
         zero_length_data_frame_count_(0),
         control_frame_header_data_count_(0),
@@ skipping 169 matching lines @@
     test_altsvc_ir_.set_max_age(max_age);
     test_altsvc_ir_.set_port(port);
     test_altsvc_ir_.set_protocol_id(protocol_id.as_string());
     test_altsvc_ir_.set_host(host.as_string());
     if (origin.length() > 0) {
       test_altsvc_ir_.set_origin(origin.as_string());
     }
     ++altsvc_count_;
   }
 
+  virtual void OnPriority(SpdyStreamId stream_id,
+                          SpdyStreamId parent_stream_id,
+                          uint8 weight,
+                          bool exclusive) OVERRIDE {
+    ++priority_count_;
+  }
+
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
+    DLOG(INFO) << "Unknown frame type " << frame_type;
+    return on_unknown_frame_result_;
+  }
+
   virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
                                      SpdyFrameType type,
                                      size_t payload_len,
                                      size_t frame_len) OVERRIDE {
     last_payload_len_ = payload_len;
     last_frame_len_ = frame_len;
   }
 
-  virtual void OnPriority(SpdyStreamId stream_id,
-                          SpdyStreamId parent_stream_id,
-                          uint8 weight,
-                          bool exclusive) OVERRIDE {
-    ++priority_count_;
-  }
-
   virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                         SpdyFrameType type,
                                         size_t frame_len) OVERRIDE {
     last_frame_len_ = frame_len;
   }
 
   // Convenience function which runs a framer simulation with particular input.
   void SimulateInFramer(const unsigned char* input, size_t size) {
     framer_.set_enable_compression(use_compression_);
     framer_.set_visitor(this);
@@ skipping 50 matching lines @@
   int headers_frame_count_;
   int push_promise_frame_count_;
   int goaway_count_;
   int setting_count_;
   int settings_ack_sent_;
   int settings_ack_received_;
   int continuation_count_;
   int altsvc_count_;
   int priority_count_;
   SpdyAltSvcIR test_altsvc_ir_;
+  bool on_unknown_frame_result_;
   SpdyStreamId last_window_update_stream_;
   uint32 last_window_update_delta_;
   SpdyStreamId last_push_promise_stream_;
   SpdyStreamId last_push_promise_promised_stream_;
   int data_bytes_;
   int fin_frame_count_;  // The count of RST_STREAM type frames received.
   std::string fin_opaque_data_;
   int fin_flag_count_;  // The count of frames with the FIN flag set.
   int zero_length_data_frame_count_;  // The count of zero-length data frames.
   int control_frame_header_data_count_;  // The count of chunks received.
@@ skipping 10 matching lines @@
   SpdyStreamId header_stream_id_;
   SpdyFrameType header_control_type_;
   bool header_buffer_valid_;
   SpdyHeaderBlock headers_;
 };
 
 // Retrieves serialized headers from a HEADERS or SYN_STREAM frame.
 base::StringPiece GetSerializedHeaders(const SpdyFrame* frame,
                                        const SpdyFramer& framer) {
   SpdyFrameReader reader(frame->data(), frame->size());
-  reader.Seek(2);  // Seek past the frame length.
+  if (framer.protocol_version() > SPDY3) {
+    reader.Seek(3);  // Seek past the frame length.
+  } else {
+    reader.Seek(2);  // Seek past the frame length.
+  }
   SpdyFrameType frame_type;
   if (framer.protocol_version() > SPDY3) {
     uint8 serialized_type;
     reader.ReadUInt8(&serialized_type);
     frame_type = SpdyConstants::ParseFrameType(framer.protocol_version(),
                                                serialized_type);
     DCHECK_EQ(HEADERS, frame_type);
     uint8 flags;
     reader.ReadUInt8(&flags);
     if (flags & HEADERS_FLAG_PRIORITY) {
@@ skipping 582 matching lines @@
 
     0x80, spdy_version_ch_, 0x00, 0x03,  // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x05,           // RST_STREAM_CANCEL
   };
 
   // SYN_STREAM doesn't exist in SPDY4, so instead we send
   // HEADERS frames with PRIORITY and END_HEADERS set.
   const unsigned char kV4Input[] = {
-    0x00, 0x05, 0x01, 0x24,           // HEADERS: PRIORITY | END_HEADERS
-    0x00, 0x00, 0x00, 0x01,           // Stream 1
-    0x00, 0x00, 0x00, 0x00,           // Priority 0
-    0x82,                             // :method: GET
+    0x00, 0x00, 0x05, 0x01,           // HEADERS: PRIORITY | END_HEADERS
+    0x24, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,           // Stream 1, Priority 0
+    0x00, 0x82,                       // :method: GET
 
-    0x00, 0x01, 0x01, 0x04,           // HEADERS: END_HEADERS
-    0x00, 0x00, 0x00, 0x01,           // Stream 1
-    0x8c,                             // :status: 200
+    0x00, 0x00, 0x01, 0x01,           // HEADERS: END_HEADERS
+    0x04, 0x00, 0x00, 0x00,           // Stream 1
+    0x01, 0x8c,                       // :status: 200
 
-    0x00, 0x0c, 0x00, 0x00,           // DATA on Stream #1
-    0x00, 0x00, 0x00, 0x01,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
+    0x00, 0x00, 0x0c, 0x00,           // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x00,
+    0x01, 0xde, 0xad, 0xbe,
+    0xef, 0xde, 0xad, 0xbe,
+    0xef, 0xde, 0xad, 0xbe,
+    0xef,
 
-    0x00, 0x05, 0x01, 0x24,           // HEADERS: PRIORITY | END_HEADERS
-    0x00, 0x00, 0x00, 0x03,           // Stream 3
-    0x00, 0x00, 0x00, 0x00,           // Priority 0
-    0x82,                             // :method: GET
+    0x00, 0x00, 0x05, 0x01,           // HEADERS: PRIORITY | END_HEADERS
+    0x24, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00,           // Stream 3, Priority 0
+    0x00, 0x82,                       // :method: GET
 
-    0x00, 0x08, 0x00, 0x00,           // DATA on Stream #3
-    0x00, 0x00, 0x00, 0x03,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
+    0x00, 0x00, 0x08, 0x00,           // DATA on Stream #3
+    0x00, 0x00, 0x00, 0x00,
+    0x03, 0xde, 0xad, 0xbe,
+    0xef, 0xde, 0xad, 0xbe,
+    0xef,
 
-    0x00, 0x04, 0x00, 0x00,           // DATA on Stream #1
-    0x00, 0x00, 0x00, 0x01,
-    0xde, 0xad, 0xbe, 0xef,
+    0x00, 0x00, 0x04, 0x00,           // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x00,
+    0x01, 0xde, 0xad, 0xbe,
+    0xef,
 
-    0x00, 0x04, 0x03, 0x00,           // RST_STREAM on Stream #1
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x08,           // RST_STREAM_CANCEL
+    0x00, 0x00, 0x04, 0x03,           // RST_STREAM on Stream #1
+    0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,
+    0x08,                             // RST_STREAM_CANCEL
 
     0x00, 0x00, 0x00, 0x00,           // DATA on Stream #3
-    0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00,
+    0x03,
 
-    0x00, 0x0f, 0x03, 0x00,           // RST_STREAM on Stream #3
-    0x00, 0x00, 0x00, 0x03,
-    0x00, 0x00, 0x00, 0x08,           // RST_STREAM_CANCEL
-    0x52, 0x45, 0x53, 0x45,           // opaque data
-    0x54, 0x53, 0x54, 0x52,
-    0x45, 0x41, 0x4d,
+    0x00, 0x00, 0x0f, 0x03,           // RST_STREAM on Stream #3
+    0x00, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00,           // RST_STREAM_CANCEL
+    0x08, 0x52, 0x45, 0x53,           // opaque data
+    0x45, 0x54, 0x53, 0x54,
+    0x52, 0x45, 0x41, 0x4d,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   } else {
     visitor.SimulateInFramer(kV4Input, sizeof(kV4Input));
   }
@@ skipping 73 matching lines @@
     0xde, 0xad, 0xbe, 0xef,
 
     0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1, with EOF
     0x01, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
   };
 
   // SYN_STREAM and SYN_REPLY don't exist in SPDY4, so instead we send
   // HEADERS frames with PRIORITY(SYN_STREAM only) and END_HEADERS set.
   const unsigned char kV4Input[] = {
-    0x00, 0x05, 0x01, 0x24,           // HEADERS: PRIORITY | END_HEADERS
-    0x00, 0x00, 0x00, 0x01,           // Stream 1
-    0x00, 0x00, 0x00, 0x00,           // Priority 0
-    0x82,                             // :method: GET
+    0x00, 0x00, 0x05, 0x01,           // HEADERS: PRIORITY | END_HEADERS
+    0x24, 0x00, 0x00, 0x00,           // Stream 1
+    0x01, 0x00, 0x00, 0x00,           // Priority 0
+    0x00, 0x82,                       // :method: GET
 
-    0x00, 0x01, 0x01, 0x04,           // HEADERS: END_HEADERS
-    0x00, 0x00, 0x00, 0x01,           // Stream 1
-    0x8c,                             // :status: 200
+    0x00, 0x00, 0x01, 0x01,           // HEADERS: END_HEADERS
+    0x04, 0x00, 0x00, 0x00,           // Stream 1
+    0x01, 0x8c,                       // :status: 200
 
-    0x00, 0x0c, 0x00, 0x00,           // DATA on Stream #1
-    0x00, 0x00, 0x00, 0x01,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
+    0x00, 0x00, 0x0c, 0x00,           // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x00,
+    0x01, 0xde, 0xad, 0xbe,
+    0xef, 0xde, 0xad, 0xbe,
+    0xef, 0xde, 0xad, 0xbe,
+    0xef,
 
-    0x00, 0x04, 0x00, 0x01,           // DATA on Stream #1, with FIN
-    0x00, 0x00, 0x00, 0x01,
-    0xde, 0xad, 0xbe, 0xef,
+    0x00, 0x00, 0x04, 0x00,           // DATA on Stream #1, with FIN
+    0x01, 0x00, 0x00, 0x00,
+    0x01, 0xde, 0xad, 0xbe,
+    0xef,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   } else {
     visitor.SimulateInFramer(kV4Input, sizeof(kV4Input));
   }
@@ skipping 10 matching lines @@
   EXPECT_EQ(16, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(2, visitor.data_frame_count_);
 }
 
 // Test that the FIN flag on a SYN reply frame signifies EOF.
 TEST_P(SpdyFramerTest, FinOnSynReplyFrame) {
   const unsigned char kV2Input[] = {
-    0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #1
-    0x00, 0x00, 0x00, 0x14,
-    0x00, 0x00, 0x00, 0x01,
+    0x80, spdy_version_ch_, 0x00,  // SYN Stream #1
+    0x01, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x02, 'h', 'h',
-    0x00, 0x02, 'v', 'v',
+    0x01, 0x00, 0x02, 'h',
+    'h',  0x00, 0x02, 'v',
+    'v',
 
-    0x80, spdy_version_ch_, 0x00, 0x02,  // SYN REPLY Stream #1
-    0x01, 0x00, 0x00, 0x10,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x02, 'a', 'a',
-    0x00, 0x02, 'b', 'b',
+    0x80, spdy_version_ch_, 0x00,  // SYN REPLY Stream #1
+    0x02, 0x01, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x02, 'a',
+    'a',  0x00, 0x02, 'b',
+    'b',
   };
   const unsigned char kV3Input[] = {
-    0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #1
-    0x00, 0x00, 0x00, 0x1a,
-    0x00, 0x00, 0x00, 0x01,
+    0x80, spdy_version_ch_, 0x00,  // SYN Stream #1
+    0x01, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x01, 0x00, 0x00,
-    0x00, 0x02, 'h', 'h',
-    0x00, 0x00, 0x00, 0x02,
-    'v', 'v',
+    0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x02, 'h',
+    'h',  0x00, 0x00, 0x00,
+    0x02, 'v', 'v',
 
-    0x80, spdy_version_ch_, 0x00, 0x02,  // SYN REPLY Stream #1
-    0x01, 0x00, 0x00, 0x14,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x02,
-    'a', 'a',   0x00, 0x00,
-    0x00, 0x02, 'b', 'b',
+    0x80, spdy_version_ch_, 0x00,  // SYN REPLY Stream #1
+    0x02, 0x01, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,
+    0x02, 'a',  'a',  0x00,
+    0x00, 0x00, 0x02, 'b',
+    'b',
   };
 
   // SYN_STREAM and SYN_REPLY don't exist in SPDY4, so instead we send
   // HEADERS frames with PRIORITY(SYN_STREAM only) and END_HEADERS set.
   const unsigned char kV4Input[] = {
-    0x00, 0x05, 0x01, 0x24,           // HEADERS: PRIORITY | END_HEADERS
-    0x00, 0x00, 0x00, 0x01,           // Stream 1
-    0x00, 0x00, 0x00, 0x00,           // Priority 0
-    0x82,                             // :method: GET
+    0x00, 0x00, 0x05, 0x01,           // HEADERS: PRIORITY | END_HEADERS
+    0x24, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,           // Stream 1, Priority 0
+    0x00, 0x82,                       // :method: GET
 
-    0x00, 0x01, 0x01, 0x05,           // HEADERS: FIN | END_HEADERS
-    0x00, 0x00, 0x00, 0x01,           // Stream 1
-    0x8c,                             // :status: 200
+    0x00, 0x00, 0x01, 0x01,           // HEADERS: FIN | END_HEADERS
+    0x05, 0x00, 0x00, 0x00,
+    0x01, 0x8c,                       // Stream 1, :status: 200
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   } else {
     visitor.SimulateInFramer(kV4Input, sizeof(kV4Input));
   }
@@ skipping 137 matching lines @@
       SpdyWindowUpdateIR(1, 0x12345678)));
 
   const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678";
   const unsigned char kV3FrameData[] = {  // Also applies for V2.
     0x80, spdy_version_ch_, 0x00, 0x09,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x12, 0x34, 0x56, 0x78
   };
   const unsigned char kV4FrameData[] = {
-    0x00, 0x04, 0x08, 0x00,
-    0x00, 0x00, 0x00, 0x01,
-    0x12, 0x34, 0x56, 0x78
+    0x00, 0x00, 0x04, 0x08,
+    0x00, 0x00, 0x00, 0x00,
+    0x01, 0x12, 0x34, 0x56,
+    0x78
   };
 
   if (IsSpdy4()) {
     CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
   } else {
     CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateDataFrame) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "'hello' data frame, no FIN";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x05, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x01,
-      'h',  'e',  'l',  'l',
-      'o'
+      0x00, 0x00, 0x05, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x01, 'h',  'e',  'l',
+      'l',  'o'
     };
     const char bytes[] = "hello";
 
     SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
@@ skipping 15 matching lines @@
   {
     const char kDescription[] = "'hello' data frame with more padding, no FIN";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
 
     const unsigned char kV4FrameData[] = {
-      0x00, 0xfd, 0x00, 0x08,      // Length = 253.  PADDED set.
-      0x00, 0x00, 0x00, 0x01,
-      0xf7,                        // Pad length field.
+      0x00, 0x00, 0xfd, 0x00,      // Length = 253.  PADDED set.
+      0x08, 0x00, 0x00, 0x00,
+      0x01, 0xf7,                  // Pad length field.
       'h',  'e',  'l',  'l',       // Data
       'o',
       // Padding of 247 zeros.
       '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
       '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
       '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
       '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
       '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
       '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
       '0',  '0',  '0',  '0',  '0',  '0',  '0',  '0', '0',  '0',  '0',  '0', '0',
@@ skipping 37 matching lines @@
   {
     const char kDescription[] = "'hello' data frame with few padding, no FIN";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
 
     const unsigned char kV4FrameData[] = {
-      0x00, 0x0d, 0x00, 0x08,      // Length = 13.  PADDED set.
-      0x00, 0x00, 0x00, 0x01,
-      0x07,                        // Pad length field.
+      0x00, 0x00, 0x0d, 0x00,      // Length = 13.  PADDED set.
+      0x08, 0x00, 0x00, 0x00,
+      0x01, 0x07,                  // Pad length field.
       'h',  'e',  'l',  'l',       // Data
       'o',
       '0',  '0',  '0',  '0',       // Padding
       '0',  '0',  '0'
     };
     const char bytes[] = "hello";
 
     SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
     // 7 zeros and the pad length field make the overall padding to be 8 bytes.
     data_ir.set_padding_len(8);
@@ skipping 11 matching lines @@
     const char kDescription[] =
         "'hello' data frame with 1 byte padding, no FIN";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
 
     const unsigned char kV4FrameData[] = {
-      0x00, 0x06, 0x00, 0x08,      // Length = 6.  PADDED set.
-      0x00, 0x00, 0x00, 0x01,
-      0x00,                        // Pad length field.
+      0x00, 0x00, 0x06, 0x00,      // Length = 6.  PADDED set.
+      0x08, 0x00, 0x00, 0x00,
+      0x01, 0x00,                  // Pad length field.
       'h',  'e',  'l',  'l',       // Data
       'o',
     };
     const char bytes[] = "hello";
 
     SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
     // The pad length field itself is used for the 1-byte padding and no padding
     // payload is needed.
     data_ir.set_padding_len(1);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
@@ skipping 15 matching lines @@
   }
 
   {
     const char kDescription[] = "Data frame with negative data byte, no FIN";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
       0xff
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x01, 0x00, 0x00,
+      0x00, 0x00, 0x01, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0xff
     };
     SpdyDataIR data_ir(1, StringPiece("\xff", 1));
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "'hello' data frame, with FIN";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x05,
       'h', 'e', 'l', 'l',
       'o'
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x05, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x01,
-      'h',  'e',  'l',  'l',
-      'o'
+      0x00, 0x00, 0x05, 0x00,
+      0x01, 0x00, 0x00, 0x00,
+      0x01, 'h',  'e',  'l',
+      'l',  'o'
     };
     SpdyDataIR data_ir(1, StringPiece("hello", 5));
     data_ir.set_fin(true);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "Empty data frame";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x00, 0x00, 0x00,
-      0x00, 0x00, 0x00, 0x01,
+      0x00, 0x00, 0x00, 0x00,
+      0x01,
     };
     SpdyDataIR data_ir(1, StringPiece());
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
 
     frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
     CompareCharArraysWithHexError(
         kDescription,
         reinterpret_cast<const unsigned char*>(frame->data()),
         framer.GetDataFrameMinimumSize(),
         IsSpdy4() ? kV4FrameData : kV3FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "Data frame with max stream ID";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x7f, 0xff, 0xff, 0xff,
       0x01, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x05, 0x00, 0x01,
-      0x7f, 0xff, 0xff, 0xff,
-      'h',  'e',  'l',  'l',
-      'o'
+      0x00, 0x00, 0x05, 0x00,
+      0x01, 0x7f, 0xff, 0xff,
+      0xff, 'h',  'e',  'l',
+      'l',  'o'
     };
     SpdyDataIR data_ir(0x7fffffff, "hello");
     data_ir.set_fin(true);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsSpdy4()) {
        CompareFrame(
            kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
@@ skipping 442 matching lines @@
 
   {
     const char kDescription[] = "RST_STREAM frame";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x07, 0x03, 0x00,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x01,
-      0x52, 0x53, 0x54
+      0x00, 0x00, 0x07, 0x03,
+      0x00, 0x00, 0x00, 0x00,
+      0x01, 0x00, 0x00, 0x00,
+      0x01, 0x52, 0x53, 0x54
     };
     SpdyRstStreamIR rst_stream(1, RST_STREAM_PROTOCOL_ERROR, "RST");
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max stream ID";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x04, 0x03, 0x00,
-      0x7f, 0xff, 0xff, 0xff,
-      0x00, 0x00, 0x00, 0x01,
+      0x00, 0x00, 0x04, 0x03,
+      0x00, 0x7f, 0xff, 0xff,
+      0xff, 0x00, 0x00, 0x00,
+      0x01,
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF,
                                RST_STREAM_PROTOCOL_ERROR,
                                "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max status code";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x06,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x04, 0x03, 0x00,
-      0x7f, 0xff, 0xff, 0xff,
-      0x00, 0x00, 0x00, 0x06,
+      0x00, 0x00, 0x04, 0x03,
+      0x00, 0x7f, 0xff, 0xff,
+      0xff, 0x00, 0x00, 0x00,
+      0x06,
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF,
                                RST_STREAM_INTERNAL_ERROR,
                                "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
@@ skipping 14 matching lines @@
       0x0a, 0x0b, 0x0c, 0x0d,
     };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x0c,
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x07,
       0x0a, 0x0b, 0x0c, 0x0d,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x06, 0x04, 0x00,
+      0x00, 0x00, 0x06, 0x04,
       0x00, 0x00, 0x00, 0x00,
-      0x00, 0x04, 0x0a, 0x0b,
-      0x0c, 0x0d,
+      0x00, 0x00, 0x04, 0x0a,
+      0x0b, 0x0c, 0x0d,
     };
 
     uint32 kValue = 0x0a0b0c0d;
     SpdySettingsIR settings_ir;
 
     SpdySettingsFlags kFlags = static_cast<SpdySettingsFlags>(0x01);
     SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE;
     SettingsMap settings;
     settings[kId] = SettingsFlagsAndValue(kFlags, kValue);
     EXPECT_EQ(kFlags, settings[kId].first);
@@ skipping 39 matching lines @@
       0x00, 0x00, 0x00, 0x06,
       0x00, 0x00, 0x00, 0x03,  // 3rd Setting
       0x00, 0x00, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x04,  // 4th Setting
       0x00, 0x00, 0x00, 0x08,
     };
     // These end up seemingly out of order because of the way that our internal
     // ordering for settings_ir works. HTTP2 has no requirement on ordering on
     // the wire.
     const unsigned char kV4FrameData[] = {
-      0x00, 0x18, 0x04, 0x00,
+      0x00, 0x00, 0x18, 0x04,
       0x00, 0x00, 0x00, 0x00,
-      0x00, 0x03,              // 3rd Setting
+      0x00, 0x00, 0x03,        // 3rd Setting
       0x00, 0x00, 0x00, 0x07,
       0x00, 0x04,              // 4th Setting
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x01,              // 1st Setting
       0x00, 0x00, 0x00, 0x05,
       0x00, 0x02,              // 2nd Setting
       0x00, 0x00, 0x00, 0x06,
     };
 
     SpdySettingsIR settings_ir;
@@ skipping 26 matching lines @@
 
   {
     const char kDescription[] = "Empty SETTINGS frame";
 
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x00, 0x04, 0x00,
+      0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
+      0x00,
     };
     SpdySettingsIR settings_ir;
     scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreatePingFrame) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "PING frame";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x06,
       0x00, 0x00, 0x00, 0x04,
       0x12, 0x34, 0x56, 0x78,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x08, 0x06, 0x00,
+      0x00, 0x00, 0x08, 0x06,
       0x00, 0x00, 0x00, 0x00,
-      0x12, 0x34, 0x56, 0x78,
-      0x9a, 0xbc, 0xde, 0xff,
+      0x00, 0x12, 0x34, 0x56,
+      0x78, 0x9a, 0xbc, 0xde,
+      0xff,
     };
     const unsigned char kV4FrameDataWithAck[] = {
-      0x00, 0x08, 0x06, 0x01,
-      0x00, 0x00, 0x00, 0x00,
-      0x12, 0x34, 0x56, 0x78,
-      0x9a, 0xbc, 0xde, 0xff,
+      0x00, 0x00, 0x08, 0x06,
+      0x01, 0x00, 0x00, 0x00,
+      0x00, 0x12, 0x34, 0x56,
+      0x78, 0x9a, 0xbc, 0xde,
+      0xff,
     };
     scoped_ptr<SpdyFrame> frame;
     if (IsSpdy4()) {
       const SpdyPingId kPingId = 0x123456789abcdeffULL;
       SpdyPingIR ping_ir(kPingId);
       // Tests SpdyPingIR when the ping is not an ack.
       ASSERT_FALSE(ping_ir.is_ack());
       frame.reset(framer.SerializePing(ping_ir));
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
 
@@ skipping 20 matching lines @@
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,  // Stream Id
     };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x00,  // Stream Id
       0x00, 0x00, 0x00, 0x00,  // Status
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x0a, 0x07, 0x00,
+      0x00, 0x00, 0x0a, 0x07,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00,  // Stream id
       0x00, 0x00, 0x00, 0x00,  // Status
-      0x47, 0x41,              // Opaque Description
+      0x00, 0x47, 0x41,        // Opaque Description
     };
     SpdyGoAwayIR goaway_ir(0, GOAWAY_OK, "GA");
     scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 
   {
     const char kDescription[] = "GOAWAY frame with max stream ID, status";
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x04,
       0x7f, 0xff, 0xff, 0xff,  // Stream Id
     };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,  // Stream Id
       0x00, 0x00, 0x00, 0x01,  // Status: PROTOCOL_ERROR.
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x0a, 0x07, 0x00,
+      0x00, 0x00, 0x0a, 0x07,
       0x00, 0x00, 0x00, 0x00,
-      0x7f, 0xff, 0xff, 0xff,  // Stream Id
-      0x00, 0x00, 0x00, 0x02,  // Status: INTERNAL_ERROR.
-      0x47, 0x41,              // Opaque Description
+      0x00, 0x7f, 0xff, 0xff,  // Stream Id
+      0xff, 0x00, 0x00, 0x00,  // Status: INTERNAL_ERROR.
+      0x02, 0x47, 0x41,        // Opaque Description
     };
     SpdyGoAwayIR goaway_ir(0x7FFFFFFF, GOAWAY_INTERNAL_ERROR, "GA");
     scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
@@ skipping 25 matching lines @@
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x03, 'b',  'a',  'r'
     };
     const unsigned char kV4FrameData[] = {
-       0x00, 0x12, 0x01, 0x04,  // Headers: END_HEADERS
-       0x00, 0x00, 0x00, 0x01,  // Stream 1
-       0x00, 0x03, 0x62, 0x61,  // @.ba
-       0x72, 0x03, 0x66, 0x6f,  // r.fo
-       0x6f, 0x00, 0x03, 0x66,  // o@.f
-       0x6f, 0x6f, 0x03, 0x62,  // oo.b
-       0x61, 0x72,              // ar
+       0x00, 0x00, 0x12, 0x01,  // Headers: END_HEADERS
+       0x04, 0x00, 0x00, 0x00,  // Stream 1
+       0x01, 0x00, 0x03, 0x62,  // @.ba
+       0x61, 0x72, 0x03, 0x66,  // r.fo
+       0x6f, 0x6f, 0x00, 0x03,  // o@.f
+       0x66, 0x6f, 0x6f, 0x03,  // oo.b
+       0x62, 0x61, 0x72,        // ar
     };
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
@@ skipping 23 matching lines @@
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r'
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x0f, 0x01, 0x05,  // HEADER: FIN | END_HEADERS
-      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
-      0x00, 0x00, 0x03, 0x66,  // @..f
-      0x6f, 0x6f, 0x00, 0x03,  // oo@.
-      0x66, 0x6f, 0x6f, 0x03,  // foo.
-      0x62, 0x61, 0x72,        // bar
+      0x00, 0x00, 0x0f, 0x01,  // Headers: FIN | END_HEADERS
+      0x05, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
+      0xff, 0x00, 0x00, 0x03,  // @..
+      0x66, 0x6f, 0x6f, 0x00,  // foo@
+      0x03, 0x66, 0x6f, 0x6f,  // .foo
+      0x03, 0x62, 0x61, 0x72,  // .bar
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.SetHeader("", "foo");
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
@@ skipping 24 matching lines @@
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x00
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x0f, 0x01, 0x05,  // HEADER: FIN | END_HEADERS
-      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
-      0x00, 0x03, 0x62, 0x61,  // @.ba
-      0x72, 0x03, 0x66, 0x6f,  // r.fo
-      0x6f, 0x00, 0x03, 0x66,  // o@.f
-      0x6f, 0x6f, 0x00,        // oo.
+      0x00, 0x00, 0x0f, 0x01,  // Headers: FIN | END_HEADERS
+      0x05, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
+      0xff, 0x00, 0x03, 0x62,  // @.b
+      0x61, 0x72, 0x03, 0x66,  // ar.f
+      0x6f, 0x6f, 0x00, 0x03,  // oo@.
+      0x66, 0x6f, 0x6f, 0x00,  // foo.
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
      headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID, pri";
 
     const unsigned char kV4FrameData[] = {
-      0x00, 0x14, 0x01, 0x25,  // Headers: FIN | END_HEADERS | PRIORITY
-      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
-      0x00, 0x00, 0x00, 0x00,  // parent stream
-      0xdb,                    // weight
+      0x00, 0x00, 0x14, 0x01,  // Headers: FIN | END_HEADERS | PRIORITY
+      0x25, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
+      0xff, 0x00, 0x00, 0x00,  // parent stream
+      0x00, 0xdb,              // weight
       0x00, 0x03, 0x62, 0x61,  // @.ba
       0x72, 0x03, 0x66, 0x6f,  // r.fo
       0x6f, 0x00, 0x03, 0x66,  // o@.f
       0x6f, 0x6f, 0x00,        // oo.
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.set_priority(1);
     headers_ir.set_has_priority(true);
     headers_ir.SetHeader("bar", "foo");
@@ skipping 71 matching lines @@
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x04, 0x08, 0x00,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x01,
+      0x00, 0x00, 0x04, 0x08,
+      0x00, 0x00, 0x00, 0x00,
+      0x01, 0x00, 0x00, 0x00,
+      0x01,
     };
     scoped_ptr<SpdyFrame> frame(
         framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 1)));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame with max stream ID";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x04, 0x08, 0x00,
-      0x7f, 0xff, 0xff, 0xff,
-      0x00, 0x00, 0x00, 0x01,
+      0x00, 0x00, 0x04, 0x08,
+      0x00, 0x7f, 0xff, 0xff,
+      0xff, 0x00, 0x00, 0x00,
+      0x01,
     };
     scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
         SpdyWindowUpdateIR(0x7FFFFFFF, 1)));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame with max window delta";
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x7f, 0xff, 0xff, 0xff,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x04, 0x08, 0x00,
-      0x00, 0x00, 0x00, 0x01,
-      0x7f, 0xff, 0xff, 0xff,
+      0x00, 0x00, 0x04, 0x08,
+      0x00, 0x00, 0x00, 0x00,
+      0x01, 0x7f, 0xff, 0xff,
+      0xff,
     };
     scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
         SpdyWindowUpdateIR(1, 0x7FFFFFFF)));
     if (IsSpdy4()) {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, SerializeBlocked) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "BLOCKED frame";
   const unsigned char kType = static_cast<unsigned char>(
       SpdyConstants::SerializeFrameType(spdy_version_, BLOCKED));
   const unsigned char kFrameData[] = {
-    0x00, 0x00, kType, 0x00,
+    0x00, 0x00, 0x00, kType, 0x00,
     0x00, 0x00, 0x00,  0x00,
   };
   SpdyBlockedIR blocked_ir(0);
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(blocked_ir));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, CreateBlocked) {
   if (spdy_version_ <= SPDY3) {
     return;
@@ skipping 16 matching lines @@
 TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   const char kDescription[] = "PUSH_PROMISE frame";
 
   const unsigned char kFrameData[] = {
-    0x00, 0x16, 0x05, 0x04,  // PUSH_PROMISE: END_HEADERS
+    0x00, 0x00, 0x16, 0x05, 0x04,  // PUSH_PROMISE: END_HEADERS
     0x00, 0x00, 0x00, 0x2a,  // Stream 42
     0x00, 0x00, 0x00, 0x39,  // Promised stream 57
     0x00, 0x03, 0x62, 0x61,  // @.ba
     0x72, 0x03, 0x66, 0x6f,  // r.fo
     0x6f, 0x00, 0x03, 0x66,  // o@.f
     0x6f, 0x6f, 0x03, 0x62,  // oo.b
     0x61, 0x72,              // ar
   };
 
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("bar", "foo");
   push_promise.SetHeader("foo", "bar");
   scoped_ptr<SpdySerializedFrame> frame(
     framer.SerializePushPromise(push_promise));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
 
+TEST_P(SpdyFramerTest, CreateContinuationUncompressed) {
+  if (spdy_version_ <= SPDY3) {
+    return;
+  }
+
+  SpdyFramer framer(spdy_version_);
+  framer.set_enable_compression(false);
+  const char kDescription[] = "CONTINUATION frame";
+
+  const unsigned char kFrameData[] = {
+     0x00, 0x00, 0x12, 0x09, 0x00,  // CONTINUATION
+     0x00, 0x00, 0x00, 0x2a,  // Stream 42
+     0x00, 0x03, 0x62, 0x61,  // @.ba
+     0x72, 0x03, 0x66, 0x6f,  // r.fo
+     0x6f, 0x00, 0x03, 0x66,  // o@.f
+     0x6f, 0x6f, 0x03, 0x62,  // oo.b
+     0x61, 0x72,              // ar
+  };
+
+  SpdyContinuationIR continuation(42);
+  continuation.SetHeader("bar", "foo");
+  continuation.SetHeader("foo", "bar");
+  scoped_ptr<SpdySerializedFrame> frame(
+    framer.SerializeContinuation(continuation));
+  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+}
+
 TEST_P(SpdyFramerTest, CreateAltSvc) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "ALTSVC frame";
   const unsigned char kType = static_cast<unsigned char>(
       SpdyConstants::SerializeFrameType(spdy_version_, ALTSVC));
   const unsigned char kFrameData[] = {
-    0x00, 0x17, kType, 0x00,
+    0x00, 0x00, 0x17, kType, 0x00,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x05,
     0x01, 0xbb, 0x00, 0x04,  // Port = 443
     'p',  'i',  'd',  '1',   // Protocol-ID
     0x04, 'h',  'o',  's',
     't',  'o',  'r',  'i',
     'g',  'i',  'n',
   };
   SpdyAltSvcIR altsvc_ir(3);
   altsvc_ir.set_max_age(5);
   altsvc_ir.set_port(443);
   altsvc_ir.set_protocol_id("pid1");
   altsvc_ir.set_host("host");
   altsvc_ir.set_origin("origin");
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, CreatePriority) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "PRIORITY frame";
   const unsigned char kType = static_cast<unsigned char>(
       SpdyConstants::SerializeFrameType(spdy_version_, PRIORITY));
   const unsigned char kFrameData[] = {
-      0x00, 0x05, kType, 0x00,
+      0x00, 0x00, 0x05, kType, 0x00,
       0x00, 0x00, 0x00, 0x02,  // Stream ID = 2
       0x80, 0x00, 0x00,  0x01,  // Exclusive dependency, parent stream ID = 1
       0x10,                     // Weight = 16
   };
   SpdyPriorityIR priority_ir(2, 1, 16, true);
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(priority_ir));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedSynStreamHeaderBlock) {
@@ skipping 305 matching lines @@
     0x00, 0x00, 0x00, length,
     0x00, 0x00, 0x00, 0x00,  // Stream ID
     0x00, 0x00, 0x00, 0x00,  // Status
   };
 
   // SPDY version 4 and up GOAWAY frames are only bound to a minimal length,
   // since it may carry opaque data. Verify that minimal length is tested.
   const unsigned char less_than_min_length =
       framer.GetGoAwayMinimumSize() - framer.GetControlFrameHeaderSize() - 1;
   const unsigned char kV4FrameData[] = {
-    0x00, static_cast<uint8>(less_than_min_length), 0x07, 0x00,
+    0x00, 0x00, static_cast<uint8>(less_than_min_length), 0x07,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,  // Stream Id
     0x00, 0x00, 0x00, 0x00,  // Status
+    0x00,
   };
   const size_t pad_length =
       length + framer.GetControlFrameHeaderSize() -
       (IsSpdy4() ? sizeof(kV4FrameData) : sizeof(kV3FrameData));
   string pad('A', pad_length);
   TestSpdyVisitor visitor(spdy_version_);
 
   if (IsSpdy4()) {
     visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
   } else {
@@ skipping 125 matching lines @@
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x01,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x01,  // 2nd (duplicate) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
   const unsigned char kV4FrameData[] = {
-    0x00, 0x12, 0x04, 0x00,
+    0x00, 0x00, 0x12, 0x04,
     0x00, 0x00, 0x00, 0x00,
-    0x00, 0x01,  // 1st Setting
+    0x00, 0x00, 0x01,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x01,  // 2nd (duplicate) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
   } else if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
   } else {
     visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
   }
 
   if (!IsSpdy4()) {
     EXPECT_EQ(1, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In SPDY 4+, duplicate settings are allowed;
     // each setting replaces the previous value for that setting.
     EXPECT_EQ(3, visitor.setting_count_);
     EXPECT_EQ(0, visitor.error_count_);
     EXPECT_EQ(1, visitor.settings_ack_sent_);
   }
 }
 
+// Tests handling of SETTINGS frame with a setting we don't recognize.
+TEST_P(SpdyFramerTest, ReadUnknownSettingsId) {
+  SpdyFramer framer(spdy_version_);
+
+  const unsigned char kV2FrameData[] = {
+    0x80, spdy_version_ch_, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x1C,
+    0x00, 0x00, 0x00, 0x01,
+    0x10, 0x00, 0x00, 0x00,  // 1st Setting
+    0x00, 0x00, 0x00, 0x02,
+  };
+  const unsigned char kV3FrameData[] = {
+    0x80, spdy_version_ch_, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x1C,
+    0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x10,  // 1st Setting
+    0x00, 0x00, 0x00, 0x02,
+  };
+  const unsigned char kV4FrameData[] = {
+    0x00, 0x00, 0x06, 0x04,
+    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x10,  // 1st Setting
+    0x00, 0x00, 0x00, 0x02,
+  };
+
+  TestSpdyVisitor visitor(spdy_version_);
+  visitor.use_compression_ = false;
+  if (IsSpdy2()) {
+    visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
+  } else if (IsSpdy3()) {
+    visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
+  } else {
+    visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
+  }
+
+  if (!IsSpdy4()) {
+    EXPECT_EQ(0, visitor.setting_count_);
+    EXPECT_EQ(1, visitor.error_count_);
+  } else {
+    // In SPDY 4+, we ignore unknown settings because of extensions.
+    EXPECT_EQ(0, visitor.setting_count_);
+    EXPECT_EQ(0, visitor.error_count_);
+  }
+}
+
 // Tests handling of SETTINGS frame with entries out of order.
 TEST_P(SpdyFramerTest, ReadOutOfOrderSettings) {
   SpdyFramer framer(spdy_version_);
 
   const unsigned char kV2FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x04,
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x03,
     0x02, 0x00, 0x00, 0x00,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x01, 0x00, 0x00, 0x00,  // 2nd (out of order) Setting
     0x00, 0x00, 0x00, 0x03,
     0x03, 0x00, 0x00, 0x00,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
   const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x04,
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x02,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x01,  // 2nd (out of order) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x01, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
   const unsigned char kV4FrameData[] = {
-    0x00, 0x12, 0x04, 0x00,
+    0x00, 0x00, 0x12, 0x04,
     0x00, 0x00, 0x00, 0x00,
-    0x00, 0x02,  // 1st Setting
+    0x00, 0x00, 0x02,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x01,  // 2nd (out of order) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
   } else if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
   } else {
     visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
   }
 
   if (!IsSpdy4()) {
     EXPECT_EQ(1, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In SPDY 4+, settings are allowed in any order.
     EXPECT_EQ(3, visitor.setting_count_);
     EXPECT_EQ(0, visitor.error_count_);
-    // EXPECT_EQ(1, visitor.settings_ack_count_);
   }
 }
 
 TEST_P(SpdyFramerTest, ProcessSettingsAckFrame) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
   SpdyFramer framer(spdy_version_);
 
   const unsigned char kFrameData[] = {
-    0x00, 0x00, 0x04, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x01,
     0x00, 0x00, 0x00, 0x00,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.setting_count_);
   EXPECT_EQ(1, visitor.settings_ack_received_);
@@ skipping 15 matching lines @@
   data_ir.set_padding_len(kPaddingLen);
   scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
   ASSERT_TRUE(frame.get() != NULL);
 
   int bytes_consumed = 0;
 
   // Send the frame header.
   EXPECT_CALL(visitor, OnDataFrameHeader(1,
                                          kPaddingLen + strlen(data_payload),
                                          false));
-  CHECK_EQ(8u, framer.ProcessInput(frame->data(), 8));
+  CHECK_EQ(framer.GetDataFrameMinimumSize(),
+           framer.ProcessInput(frame->data(),
+                               framer.GetDataFrameMinimumSize()));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_READ_PADDING_LENGTH);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
-  bytes_consumed += 8;
+  bytes_consumed += framer.GetDataFrameMinimumSize();
 
   // Send the padding length field.
   CHECK_EQ(1u, framer.ProcessInput(frame->data() + bytes_consumed, 1));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_FORWARD_STREAM_FRAME);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 1;
 
   // Send the first two bytes of the data payload, i.e., "he".
   EXPECT_CALL(visitor, OnStreamFrameData(1, _, 2, false));
   CHECK_EQ(2u, framer.ProcessInput(frame->data() + bytes_consumed, 2));
@@ skipping 93 matching lines @@
   multiple_frame_data.append(string(control_frame->data(),
                                     control_frame->size()));
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned const char*>(multiple_frame_data.data()),
       multiple_frame_data.length());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, visitor.last_window_update_stream_);
   EXPECT_EQ(2u, visitor.last_window_update_delta_);
 }
 
-TEST_P(SpdyFramerTest, CreateContinuationUncompressed) {
-  if (spdy_version_ <= SPDY3) {
-    return;
-  }
-
-  SpdyFramer framer(spdy_version_);
-  framer.set_enable_compression(false);
-  const char kDescription[] = "CONTINUATION frame";
-
-  const unsigned char kFrameData[] = {
-     0x00, 0x12, 0x09, 0x00,  // CONTINUATION
-     0x00, 0x00, 0x00, 0x2a,  // Stream 42
-     0x00, 0x03, 0x62, 0x61,  // @.ba
-     0x72, 0x03, 0x66, 0x6f,  // r.fo
-     0x6f, 0x00, 0x03, 0x66,  // o@.f
-     0x6f, 0x6f, 0x03, 0x62,  // oo.b
-     0x61, 0x72,              // ar
-  };
-
-  SpdyContinuationIR continuation(42);
-  continuation.SetHeader("bar", "foo");
-  continuation.SetHeader("foo", "bar");
-  scoped_ptr<SpdySerializedFrame> frame(
-    framer.SerializeContinuation(continuation));
-  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
-}
-
 TEST_P(SpdyFramerTest, ReadCompressedPushPromise) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("foo", "bar");
   push_promise.SetHeader("bar", "foofoo");
   SpdyHeaderBlock headers = push_promise.name_value_block();
   scoped_ptr<SpdySerializedFrame> frame(
     framer.SerializePushPromise(push_promise));
   EXPECT_TRUE(frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(frame->data()),
       frame->size());
   EXPECT_EQ(42u, visitor.last_push_promise_stream_);
   EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x14, 0x01, 0x08,  // HEADERS: PADDED
+    0x00, 0x00, 0x14, 0x01, 0x08,  // HEADERS: PADDED
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x03,                    // Padding of 3.
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
     0x00, 0x00, 0x00,
 
-    0x00, 0x14, 0x09, 0x00,  // CONTINUATION
+    0x00, 0x00, 0x14, 0x09, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x00, 0x06, 0x63,
 
-    0x00, 0x12, 0x09, 0x04,  // CONTINUATION: END_HEADERS
+    0x00, 0x00, 0x12, 0x09, 0x04,  // CONTINUATION: END_HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x6f, 0x6f, 0x6b, 0x69,
     0x65, 0x00, 0x00, 0x04,
     0x6e, 0x61, 0x6d, 0x65,
     0x05, 0x76, 0x61, 0x6c,
     0x75, 0x65,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
 
   EXPECT_THAT(visitor.headers_, ElementsAre(
       Pair("cookie", "foo=bar; baz=bing; "),
       Pair("name", "value")));
 }
 
 TEST_P(SpdyFramerTest, ReadHeadersWithContinuationAndFin) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x10, 0x01, 0x01,  // HEADERS: FIN
+    0x00, 0x00, 0x10, 0x01, 0x01,  // HEADERS: FIN
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
-    0x00, 0x14, 0x09, 0x00,  // CONTINUATION
+    0x00, 0x00, 0x14, 0x09, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x00, 0x06, 0x63,
 
-    0x00, 0x12, 0x09, 0x04,  // CONTINUATION: END_HEADERS
+    0x00, 0x00, 0x12, 0x09, 0x04,  // CONTINUATION: END_HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x6f, 0x6f, 0x6b, 0x69,
     0x65, 0x00, 0x00, 0x04,
     0x6e, 0x61, 0x6d, 0x65,
     0x05, 0x76, 0x61, 0x6c,
     0x75, 0x65,
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
@@ skipping 10 matching lines @@
       Pair("cookie", "foo=bar; baz=bing; "),
       Pair("name", "value")));
 }
 
 TEST_P(SpdyFramerTest, ReadPushPromiseWithContinuation) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x17, 0x05, 0x08,  // PUSH_PROMISE: PADDED
+    0x00, 0x00, 0x17, 0x05, 0x08,  // PUSH_PROMISE: PADDED
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x00, 0x00, 0x2A,  // Promised stream 42
     0x02,                    // Padding of 2.
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
     0x00, 0x00,
 
-    0x00, 0x14, 0x09, 0x00,  // CONTINUATION
+    0x00, 0x00, 0x14, 0x09, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x00, 0x06, 0x63,
 
-    0x00, 0x12, 0x09, 0x04,  // CONTINUATION: END_HEADERS
+    0x00, 0x00, 0x12, 0x09, 0x04,  // CONTINUATION: END_HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x6f, 0x6f, 0x6b, 0x69,
     0x65, 0x00, 0x00, 0x04,
     0x6e, 0x61, 0x6d, 0x65,
     0x05, 0x76, 0x61, 0x6c,
     0x75, 0x65,
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
@@ skipping 10 matching lines @@
       Pair("cookie", "foo=bar; baz=bing; "),
       Pair("name", "value")));
 }
 
 TEST_P(SpdyFramerTest, ReadContinuationWithWrongStreamId) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x10, 0x01, 0x00,  // HEADERS
+    0x00, 0x00, 0x10, 0x01, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
-    0x00, 0x14, 0x09, 0x00,  // CONTINUATION
+    0x00, 0x00, 0x14, 0x09, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x02,  // Stream 2
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x00, 0x06, 0x63,
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ReadContinuationOutOfOrder) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x10, 0x09, 0x00,  // CONTINUATION
+    0x00, 0x00, 0x18, 0x09, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ExpectContinuationReceiveData) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x10, 0x01, 0x00,  // HEADERS
+    0x00, 0x00, 0x10, 0x01, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
-    0x00, 0x00, 0x00, 0x01,  // DATA on Stream #1
+    0x00, 0x00, 0x00, 0x00, 0x01,  // DATA on Stream #1
     0x00, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, ExpectContinuationReceiveControlFrame) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x10, 0x01, 0x00,  // HEADERS
+    0x00, 0x00, 0x18, 0x01, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
-    0x00, 0x14, 0x08, 0x00,  // HEADERS
+    0x00, 0x00, 0x1c, 0x08, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,  // (Note this is a valid continued encoding).
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x00, 0x06, 0x63,
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, EndSegmentOnDataFrame) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
   const unsigned char kInput[] = {
-    0x00, 0x0c, 0x00, 0x02,  // DATA: END_SEGMENT
+    0x00, 0x00, 0x0c, 0x00, 0x02,  // DATA: END_SEGMENT
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   // TODO(jgraettinger): Verify END_SEGMENT when support is added.
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(12, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
 }
 
 TEST_P(SpdyFramerTest, EndSegmentOnHeadersFrame) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
   const unsigned char kInput[] = {
-    0x00, 0x10, 0x01, 0x06,  // HEADERS: END_SEGMENT | END_HEADERS
+    0x00, 0x00, 0x10, 0x01, 0x06,  // HEADERS: END_SEGMENT | END_HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x06, 0x63, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   // TODO(jgraettinger): Verify END_SEGMENT when support is added.
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
 
   EXPECT_THAT(visitor.headers_, ElementsAre(
       Pair("cookie", "foo=bar")));
 }
 
 TEST_P(SpdyFramerTest, ReadGarbage) {
   SpdyFramer framer(spdy_version_);
   unsigned char garbage_frame[256];
   memset(garbage_frame, ~0, sizeof(garbage_frame));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(garbage_frame, sizeof(garbage_frame));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
+TEST_P(SpdyFramerTest, ReadUnknownExtensionFrame) {
+  if (spdy_version_ <= SPDY3) {
+    return;
+  }
+  SpdyFramer framer(spdy_version_);
+
+  // The unrecognized frame type should still have a valid length.
+  const unsigned char unknown_frame[] = {
+    0x00, 0x00, 0x08, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff,
+  };
+  TestSpdyVisitor visitor(spdy_version_);
+
+  // Simulate the case where the stream id validation checks out.
+  visitor.on_unknown_frame_result_ = true;
+  visitor.use_compression_ = false;
+  visitor.SimulateInFramer(unknown_frame, arraysize(unknown_frame));
+  EXPECT_EQ(0, visitor.error_count_);
+
+  // Follow it up with a valid control frame to make sure we handle
+  // subsequent frames correctly.
+  SpdySettingsIR settings_ir;
+  settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
+                         false,  // persist
+                         false,  // persisted
+                         10);
+  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
+  visitor.SimulateInFramer(
+      reinterpret_cast<unsigned char*>(control_frame->data()),
+      control_frame->size());
+  EXPECT_EQ(0, visitor.error_count_);
+  EXPECT_EQ(1u, static_cast<unsigned>(visitor.setting_count_));
+  EXPECT_EQ(1u, static_cast<unsigned>(visitor.settings_ack_sent_));
+}
+
 TEST_P(SpdyFramerTest, ReadGarbageWithValidLength) {
   if (!IsSpdy4()) {
     return;
   }
   SpdyFramer framer(spdy_version_);
   const unsigned char kFrameData[] = {
-    0x00, 0x10, 0xff, 0xff,
+    0x00, 0x00, 0x08, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff,
   };
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, arraysize(kFrameData));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
@@ skipping 27 matching lines @@
     0xff, 0xff,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kInput, arraysize(kInput));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, SizesTest) {
   SpdyFramer framer(spdy_version_);
-  EXPECT_EQ(8u, framer.GetDataFrameMinimumSize());
   if (IsSpdy4() || IsSpdy5()) {
-    EXPECT_EQ(8u, framer.GetSynReplyMinimumSize());
-    EXPECT_EQ(12u, framer.GetRstStreamMinimumSize());
-    EXPECT_EQ(8u, framer.GetSettingsMinimumSize());
-    EXPECT_EQ(16u, framer.GetPingSize());
-    EXPECT_EQ(16u, framer.GetGoAwayMinimumSize());
-    EXPECT_EQ(8u, framer.GetHeadersMinimumSize());
-    EXPECT_EQ(12u, framer.GetWindowUpdateSize());
-    EXPECT_EQ(8u, framer.GetBlockedSize());
-    EXPECT_EQ(12u, framer.GetPushPromiseMinimumSize());
-    EXPECT_EQ(17u, framer.GetAltSvcMinimumSize());
-    EXPECT_EQ(8u, framer.GetFrameMinimumSize());
-    EXPECT_EQ(16383u, framer.GetFrameMaximumSize());
-    EXPECT_EQ(16375u, framer.GetDataFrameMaximumPayload());
+    EXPECT_EQ(9u, framer.GetDataFrameMinimumSize());
+    EXPECT_EQ(9u, framer.GetControlFrameHeaderSize());
+    EXPECT_EQ(14u, framer.GetSynStreamMinimumSize());
+    EXPECT_EQ(9u, framer.GetSynReplyMinimumSize());
+    EXPECT_EQ(13u, framer.GetRstStreamMinimumSize());
+    EXPECT_EQ(9u, framer.GetSettingsMinimumSize());
+    EXPECT_EQ(17u, framer.GetPingSize());
+    EXPECT_EQ(17u, framer.GetGoAwayMinimumSize());
+    EXPECT_EQ(9u, framer.GetHeadersMinimumSize());
+    EXPECT_EQ(13u, framer.GetWindowUpdateSize());
+    EXPECT_EQ(9u, framer.GetBlockedSize());
+    EXPECT_EQ(13u, framer.GetPushPromiseMinimumSize());
+    EXPECT_EQ(18u, framer.GetAltSvcMinimumSize());
+    EXPECT_EQ(9u, framer.GetFrameMinimumSize());
+    EXPECT_EQ(16393u, framer.GetFrameMaximumSize());
+    EXPECT_EQ(16384u, framer.GetDataFrameMaximumPayload());
   } else {
+    EXPECT_EQ(8u, framer.GetDataFrameMinimumSize());
     EXPECT_EQ(8u, framer.GetControlFrameHeaderSize());
     EXPECT_EQ(18u, framer.GetSynStreamMinimumSize());
     EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetSynReplyMinimumSize());
     EXPECT_EQ(16u, framer.GetRstStreamMinimumSize());
     EXPECT_EQ(12u, framer.GetSettingsMinimumSize());
     EXPECT_EQ(12u, framer.GetPingSize());
     EXPECT_EQ(IsSpdy2() ? 12u : 16u, framer.GetGoAwayMinimumSize());
     EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetHeadersMinimumSize());
     EXPECT_EQ(16u, framer.GetWindowUpdateSize());
     EXPECT_EQ(8u, framer.GetFrameMinimumSize());
@@ skipping 785 matching lines @@
 TEST_P(SpdyFramerTest, RstStreamStatusBounds) {
   const unsigned char kRstStreamStatusTooLow = 0x00;
   const unsigned char kRstStreamStatusTooHigh = 0xff;
   const unsigned char kV3RstStreamInvalid[] = {
     0x80, spdy_version_ch_, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, kRstStreamStatusTooLow
   };
   const unsigned char kV4RstStreamInvalid[] = {
-    0x00, 0x04, 0x03, 0x00,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, kRstStreamStatusTooLow
+    0x00, 0x00, 0x04, 0x03,
+    0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,
+    kRstStreamStatusTooLow
   };
 
   const unsigned char kV3RstStreamNumStatusCodes[] = {
     0x80, spdy_version_ch_, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, kRstStreamStatusTooHigh
   };
   const unsigned char kV4RstStreamNumStatusCodes[] = {
-    0x00, 0x04, 0x03, 0x00,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, kRstStreamStatusTooHigh
+    0x00, 0x00, 0x04, 0x03,
+    0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00,
+    kRstStreamStatusTooHigh
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   if (IsSpdy4()) {
-    EXPECT_CALL(visitor, OnError(_));
+    EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INTERNAL_ERROR));
     framer.ProcessInput(reinterpret_cast<const char*>(kV4RstStreamInvalid),
                         arraysize(kV4RstStreamInvalid));
-    EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
-    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
-      << SpdyFramer::ErrorCodeToString(framer.error_code());
   } else {
     EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INVALID));
     framer.ProcessInput(reinterpret_cast<const char*>(kV3RstStreamInvalid),
                         arraysize(kV3RstStreamInvalid));
-    EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
-    EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+  }
+  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
-  }
 
 
   framer.Reset();
 
   if (IsSpdy4()) {
-    EXPECT_CALL(visitor, OnError(_));
+    EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INTERNAL_ERROR));
     framer.ProcessInput(
         reinterpret_cast<const char*>(kV4RstStreamNumStatusCodes),
         arraysize(kV4RstStreamNumStatusCodes));
-    EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
-    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
-      << SpdyFramer::ErrorCodeToString(framer.error_code());
   } else {
     EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INVALID));
     framer.ProcessInput(
         reinterpret_cast<const char*>(kV3RstStreamNumStatusCodes),
         arraysize(kV3RstStreamNumStatusCodes));
-    EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
-    EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+  }
+  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
+}
+
+// Test handling of GOAWAY frames with out-of-bounds status code.
+TEST_P(SpdyFramerTest, GoAwayStatusBounds) {
+  if (spdy_version_ <= SPDY2) {
+    return;
   }
+  SpdyFramer framer(spdy_version_);
+
+  const unsigned char kV3FrameData[] = {
+    0x80, spdy_version_ch_, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01,  // Stream Id
+    0xff, 0xff, 0xff, 0xff,  // Status
+  };
+  const unsigned char kV4FrameData[] = {
+    0x00, 0x00, 0x0a, 0x07,
+    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,  // Stream id
+    0x01, 0xff, 0xff, 0xff,  // Status
+    0xff, 0x47, 0x41,        // Opaque Description
+  };
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  framer.set_visitor(&visitor);
+
+  if (IsSpdy3()) {
+    EXPECT_CALL(visitor, OnGoAway(1, GOAWAY_OK));
+    framer.ProcessInput(reinterpret_cast<const char*>(kV3FrameData),
+                        arraysize(kV3FrameData));
+  } else {
+    EXPECT_CALL(visitor, OnGoAway(1, GOAWAY_INTERNAL_ERROR));
+    framer.ProcessInput(reinterpret_cast<const char*>(kV4FrameData),
+                        arraysize(kV4FrameData));
+  }
+  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Tests handling of a GOAWAY frame with out-of-bounds stream ID.
 TEST_P(SpdyFramerTest, GoAwayStreamIdBounds) {
   const unsigned char kV2FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x07,
     0x00, 0x00, 0x00, 0x04,
     0xff, 0xff, 0xff, 0xff,
   };
   const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x07,
     0x00, 0x00, 0x00, 0x08,
     0xff, 0xff, 0xff, 0xff,
     0x00, 0x00, 0x00, 0x00,
   };
   const unsigned char kV4FrameData[] = {
-    0x00, 0x08, 0x07, 0x00,
+    0x00, 0x00, 0x08, 0x07,
     0x00, 0x00, 0x00, 0x00,
-    0xff, 0xff, 0xff, 0xff,
-    0x00, 0x00, 0x00, 0x00,
+    0x00, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00,
+    0x00,
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnGoAway(0x7fffffff, GOAWAY_OK));
   if (IsSpdy2()) {
     framer.ProcessInput(reinterpret_cast<const char*>(kV2FrameData),
                         arraysize(kV2FrameData));
@@ skipping 105 matching lines @@
   }
 
   const unsigned char kType = static_cast<unsigned char>(
       SpdyConstants::SerializeFrameType(spdy_version_, ALTSVC));
   {
     TestSpdyVisitor visitor(spdy_version_);
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     const unsigned char kFrameDataLargePIDLen[] = {
-      0x00, 0x17, kType, 0x00,
+      0x00, 0x00, 0x17, kType, 0x00,
       0x00, 0x00, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x05,
       0x01, 0xbb, 0x00, 0x05,  // Port = 443
       'p',  'i',  'd',  '1',   // Protocol-ID
       0x04, 'h',  'o',  's',
       't',  'o',  'r',  'i',
       'g',  'i',  'n',
     };
 
     visitor.SimulateInFramer(kFrameDataLargePIDLen,
                              sizeof(kFrameDataLargePIDLen));
     EXPECT_EQ(1, visitor.error_count_);
     EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
               visitor.framer_.error_code());
   }
 
   {
     TestSpdyVisitor visitor(spdy_version_);
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     const unsigned char kFrameDataPIDLenLargerThanFrame[] = {
-      0x00, 0x17, kType, 0x00,
+      0x00, 0x00, 0x17, kType, 0x00,
       0x00, 0x00, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x05,
       0x01, 0xbb, 0x00, 0x99,  // Port = 443
       'p',  'i',  'd',  '1',   // Protocol-ID
       0x04, 'h',  'o',  's',
       't',  'o',  'r',  'i',
       'g',  'i',  'n',
     };
 
     visitor.SimulateInFramer(kFrameDataPIDLenLargerThanFrame,
                              sizeof(kFrameDataPIDLenLargerThanFrame));
     EXPECT_EQ(1, visitor.error_count_);
     EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
               visitor.framer_.error_code());
   }
 
   {
     TestSpdyVisitor visitor(spdy_version_);
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     const unsigned char kFrameDataLargeHostLen[] = {
-      0x00, 0x17, kType, 0x00,
+      0x00, 0x00, 0x17, kType, 0x00,
       0x00, 0x00, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x05,
       0x01, 0xbb, 0x00, 0x04,  // Port = 443
       'p',  'i',  'd',  '1',   // Protocol-ID
       0x0f, 'h',  'o',  's',
       't',  'o',  'r',  'i',
       'g',  'i',  'n',
     };
 
     visitor.SimulateInFramer(kFrameDataLargeHostLen,
                              sizeof(kFrameDataLargeHostLen));
     EXPECT_EQ(1, visitor.error_count_);
     EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
               visitor.framer_.error_code());
   }
 
   {
     TestSpdyVisitor visitor(spdy_version_);
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     const unsigned char kFrameDataSmallPIDLen[] = {
-      0x00, 0x17, kType, 0x00,
+      0x00, 0x00, 0x17, kType, 0x00,
       0x00, 0x00, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x05,
       0x01, 0xbb, 0x00, 0x01,  // Port = 443
       'p',  'i',  'd',  '1',   // Protocol-ID
       0x04, 'h',  'o',  's',
       't',  'o',  'r',  'i',
       'g',  'i',  'n',
     };
 
     visitor.SimulateInFramer(kFrameDataSmallPIDLen,
@@ skipping 53 matching lines @@
   EXPECT_CALL(visitor, OnPriority(3, 1, 255, false));
   framer.ProcessInput(frame->data(), frame->size());
 
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   // TODO(mlavan): once we actually maintain a priority tree,
   // check that state is adjusted correctly.
 }
 
-// Tests handling of PRIORITY frame with incorrect size.
-TEST_P(SpdyFramerTest, ReadIncorrectlySizedPriority) {
-  if (spdy_version_ <= SPDY3) {
-    return;
-  }
-
-  // PRIORITY frame of size 4, which isn't correct.
-  const unsigned char kFrameData[] = {
-    0x00, 0x04, 0x02, 0x00,
-    0x00, 0x00, 0x00, 0x03,
-    0x00, 0x00, 0x00, 0x01,
-  };
-
-  TestSpdyVisitor visitor(spdy_version_);
-  visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
-
-  EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
-  EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
-            visitor.framer_.error_code())
-      << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
-}
-
 TEST_P(SpdyFramerTest, PriorityWeightMapping) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
   SpdyFramer framer(spdy_version_);
 
   EXPECT_EQ(255u, framer.MapPriorityToWeight(0));
   EXPECT_EQ(219u, framer.MapPriorityToWeight(1));
   EXPECT_EQ(182u, framer.MapPriorityToWeight(2));
   EXPECT_EQ(146u, framer.MapPriorityToWeight(3));
@@ skipping 12 matching lines @@
   EXPECT_EQ(3u, framer.MapWeightToPriority(110));
   EXPECT_EQ(4u, framer.MapWeightToPriority(109));
   EXPECT_EQ(4u, framer.MapWeightToPriority(74));
   EXPECT_EQ(5u, framer.MapWeightToPriority(73));
   EXPECT_EQ(5u, framer.MapWeightToPriority(37));
   EXPECT_EQ(6u, framer.MapWeightToPriority(36));
   EXPECT_EQ(6u, framer.MapWeightToPriority(1));
   EXPECT_EQ(7u, framer.MapWeightToPriority(0));
 }
 
+// Tests handling of PRIORITY frame with incorrect size.
+TEST_P(SpdyFramerTest, ReadIncorrectlySizedPriority) {
+  if (spdy_version_ <= SPDY3) {
+    return;
+  }
+
+  // PRIORITY frame of size 4, which isn't correct.
+  const unsigned char kFrameData[] = {
+    0x00, 0x00, 0x04, 0x02, 0x00,
+    0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01,
+  };
+
+  TestSpdyVisitor visitor(spdy_version_);
+  visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
+
+  EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
+  EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
+            visitor.framer_.error_code())
+      << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
+}
+
 }  // namespace net