Update SPDY4 length field to exclude frame prefix length.

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 45 matching lines @@
       SpdyFramer* framer, const SpdyFrameType& frame) {
     DecompressionVisitor visitor(framer->protocol_version());
     framer->set_visitor(&visitor);
     CHECK_EQ(frame.size(), framer->ProcessInput(frame.data(), frame.size()));
     CHECK_EQ(SpdyFramer::SPDY_RESET, framer->state());
     framer->set_visitor(NULL);
 
     char* buffer = visitor.ReleaseBuffer();
     CHECK(buffer != NULL);
     SpdyFrame* decompressed_frame = new SpdyFrame(buffer, visitor.size(), true);
-    if (framer->protocol_version() == 4) {
-      SetFrameLength(decompressed_frame,
-                     visitor.size(),
-                     framer->protocol_version());
-    } else {
-      SetFrameLength(decompressed_frame,
-                     visitor.size() - framer->GetControlFrameHeaderSize(),
-                     framer->protocol_version());
-    }
+    SetFrameLength(decompressed_frame,
+                   visitor.size() - framer->GetControlFrameHeaderSize(),
+                   framer->protocol_version());
     return decompressed_frame;
   }
 
   class DecompressionVisitor : public SpdyFramerVisitorInterface {
    public:
     explicit DecompressionVisitor(SpdyMajorVersion version)
         : version_(version), size_(0), finished_(false) {}
 
     void ResetBuffer() {
       CHECK(buffer_.get() == NULL);
@@ skipping 961 matching lines @@
 
     0x80, spdy_version_ch_, 0x00, 0x03,  // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x00,
   };
 
   // SYN_STREAM doesn't exist in SPDY4, so instead we send
   // HEADERS frames with PRIORITY and END_HEADERS set.
   const unsigned char kV4Input[] = {
-    0x00, 0x0d, 0x08, 0x0c,           // HEADERS: PRIORITY | END_HEADERS
+    0x00, 0x05, 0x08, 0x0c,           // HEADERS: PRIORITY | END_HEADERS
     0x00, 0x00, 0x00, 0x01,           // Stream 1
     0x00, 0x00, 0x00, 0x00,           // Priority 0
     0x82,                             // :method: GET
 
-    0x00, 0x09, 0x08, 0x04,           // HEADERS: END_HEADERS
+    0x00, 0x01, 0x08, 0x04,           // HEADERS: END_HEADERS
     0x00, 0x00, 0x00, 0x01,           // Stream 1
     0x8c,                             // :status: 200
 
-    0x00, 0x14, 0x00, 0x00,           // DATA on Stream #1
+    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, 0x0d, 0x08, 0x0c,           // HEADERS: PRIORITY | END_HEADERS
+    0x00, 0x05, 0x08, 0x0c,           // HEADERS: PRIORITY | END_HEADERS
     0x00, 0x00, 0x00, 0x03,           // Stream 3
     0x00, 0x00, 0x00, 0x00,           // Priority 0
     0x82,                             // :method: GET
 
-    0x00, 0x10, 0x00, 0x00,           // DATA on Stream #3
+    0x00, 0x08, 0x00, 0x00,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x03,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x00, 0x0c, 0x00, 0x00,           // DATA on Stream #1
+    0x00, 0x04, 0x00, 0x00,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x01,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x00, 0x0c, 0x03, 0x00,           // RST_STREAM on Stream #1
+    0x00, 0x04, 0x03, 0x00,           // RST_STREAM on Stream #1
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
 
-    0x00, 0x08, 0x00, 0x00,           // DATA on Stream #3
+    0x00, 0x00, 0x00, 0x00,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x03,
 
-    0x00, 0x17, 0x03, 0x00,           // RST_STREAM on Stream #3
+    0x00, 0x0f, 0x03, 0x00,           // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x00,
     0x52, 0x45, 0x53, 0x45,           // opaque data
     0x54, 0x53, 0x54, 0x52,
     0x45, 0x41, 0x4d,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
@@ skipping 78 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, 0x0d, 0x08, 0x0c,           // HEADERS: PRIORITY | END_HEADERS
+    0x00, 0x05, 0x08, 0x0c,           // HEADERS: PRIORITY | END_HEADERS
     0x00, 0x00, 0x00, 0x01,           // Stream 1
     0x00, 0x00, 0x00, 0x00,           // Priority 0
     0x82,                             // :method: GET
 
-    0x00, 0x09, 0x08, 0x04,           // HEADERS: END_HEADERS
+    0x00, 0x01, 0x08, 0x04,           // HEADERS: END_HEADERS
     0x00, 0x00, 0x00, 0x01,           // Stream 1
     0x8c,                             // :status: 200
 
-    0x00, 0x14, 0x00, 0x00,           // DATA on Stream #1
+    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, 0x0c, 0x00, 0x01,           // DATA on Stream #1, with FIN
+    0x00, 0x04, 0x00, 0x01,           // DATA on Stream #1, with FIN
     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 {
@@ skipping 50 matching lines @@
     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, 0x0d, 0x08, 0x0c,           // HEADERS: PRIORITY | END_HEADERS
+    0x00, 0x05, 0x08, 0x0c,           // HEADERS: PRIORITY | END_HEADERS
     0x00, 0x00, 0x00, 0x01,           // Stream 1
     0x00, 0x00, 0x00, 0x00,           // Priority 0
     0x82,                             // :method: GET
 
-    0x00, 0x09, 0x08, 0x05,           // HEADERS: FIN | END_HEADERS
+    0x00, 0x01, 0x08, 0x05,           // HEADERS: FIN | END_HEADERS
     0x00, 0x00, 0x00, 0x01,           // Stream 1
     0x8c,                             // :status: 200
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   if (IsSpdy2()) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   } else {
@@ skipping 182 matching lines @@
       net::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, 0x0c, 0x09, 0x00,
+    0x00, 0x04, 0x09, 0x00,
     0x00, 0x00, 0x00, 0x01,
     0x12, 0x34, 0x56, 0x78
   };
 
   if (IsSpdy4()) {
-     CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+    CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
   } else {
-     CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+    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, 0x0d, 0x00, 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(
@@ skipping 17 matching lines @@
   {
     const char kDescription[] = "'hello' data frame with 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, 0x15, 0x00, 0x10,      // Length = 13.  PAD_LOW set.
+      0x00, 0x0d, 0x00, 0x10,      // Length = 13.  PAD_LOW set.
       0x00, 0x00, 0x00, 0x01,
       0x07,                        // Pad Low 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)));
@@ skipping 10 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, 0x09, 0x00, 0x00,
+      0x00, 0x01, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0xff
     };
     net::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, 0x0d, 0x00, 0x01,
+      0x00, 0x05, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
       'h',  'e',  'l',  'l',
       'o'
     };
     net::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, 0x08, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x01,
     };
     net::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));
     }
   }
 
   {
     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, 0x0d, 0x00, 0x01,
+      0x00, 0x05, 0x00, 0x01,
       0x7f, 0xff, 0xff, 0xff,
       'h',  'e',  'l',  'l',
       'o'
     };
     net::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));
@@ skipping 56 matching lines @@
       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, 0x1e, 0x08, 0x0c,  // HEADERS: PRIORITY | END_HEADERS
+      0x00, 0x16, 0x08, 0x0c,  // HEADERS: PRIORITY | END_HEADERS
       0x00, 0x00, 0x00, 0x01,  // Stream 1
       0x00, 0x00, 0x00, 0x07,  // Priority 7
       0x40, 0x03, 0x62, 0x61,  // @.ba
       0x72, 0x03, 0x66, 0x6f,  // r.fo
       0x6f, 0x40, 0x03, 0x66,  // o@.f
       0x6f, 0x6f, 0x03, 0x62,  // oo.b
       0x61, 0x72,              // ar
     };
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(framer.GetLowestPriority());
@@ skipping 34 matching lines @@
       0x00, 0x00, 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, 0x1b, 0x08, 0x0d,  // HEADERS: PRIORITY | FIN | END_HEADERS
+      0x00, 0x13, 0x08, 0x0d,  // HEADERS: PRIORITY | FIN | END_HEADERS
       0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
       0x00, 0x00, 0x00, 0x00,  // Priority 0
       0x40, 0x00, 0x03, 0x66,  // @..f
       0x6f, 0x6f, 0x40, 0x03,  // oo@.
       0x66, 0x6f, 0x6f, 0x03,  // foo.
       0x62, 0x61, 0x72,        // bar
     };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(framer.GetHighestPriority());
@@ skipping 36 matching lines @@
       kPri, 0x00, 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, 0x1b, 0x08, 0x0d,  // HEADERS: PRIORITY | FIN | END_HEADERS
+      0x00, 0x13, 0x08, 0x0d,  // HEADERS: PRIORITY | FIN | END_HEADERS
       0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
       0x00, 0x00, 0x00, 0x01,  // Priority 1
       0x40, 0x03, 0x62, 0x61,  // @.ba
       0x72, 0x03, 0x66, 0x6f,  // r.fo
       0x6f, 0x40, 0x03, 0x66,  // o@.f
       0x6f, 0x6f, 0x00,        // oo.
     };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(1);
@@ skipping 100 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, 0x1a, 0x08, 0x04,  // HEADER: END_HEADERS
+      0x00, 0x12, 0x08, 0x04,  // HEADER: END_HEADERS
       0x00, 0x00, 0x00, 0x01,  // Stream 1
       0x40, 0x03, 0x62, 0x61,  // @.ba
       0x72, 0x03, 0x66, 0x6f,  // r.fo
       0x6f, 0x40, 0x03, 0x66,  // o@.f
       0x6f, 0x6f, 0x03, 0x62,  // oo.b
       0x61, 0x72,              // ar
     };
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
@@ skipping 29 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, 0x17, 0x08, 0x05,  // HEADER: FIN | END_HEADERS
+      0x00, 0x0f, 0x08, 0x05,  // HEADER: FIN | END_HEADERS
       0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
       0x40, 0x00, 0x03, 0x66,  // @..f
       0x6f, 0x6f, 0x40, 0x03,  // oo@.
       0x66, 0x6f, 0x6f, 0x03,  // foo.
       0x62, 0x61, 0x72,        // bar
     };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("", "foo");
     syn_reply.SetHeader("foo", "bar");
@@ skipping 29 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, 0x17, 0x08, 0x05,  // HEADER: FIN | END_HEADERS
+      0x00, 0x0f, 0x08, 0x05,  // HEADER: FIN | END_HEADERS
       0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
       0x40, 0x03, 0x62, 0x61,  // @.ba
       0x72, 0x03, 0x66, 0x6f,  // r.fo
       0x6f, 0x40, 0x03, 0x66,  // o@.f
       0x6f, 0x6f, 0x00,        // oo.
     };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "");
@@ skipping 72 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, 0x0f, 0x03, 0x00,
+      0x00, 0x07, 0x03, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
       0x52, 0x53, 0x54
     };
     net::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, 0x0c, 0x03, 0x00,
+      0x00, 0x04, 0x03, 0x00,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     net::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, 0x0c, 0x03, 0x00,
+      0x00, 0x04, 0x03, 0x00,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x06,
     };
     net::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 {
@@ skipping 16 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, 0x02, 0x03, 0x04,
       0x0a, 0x0b, 0x0c, 0x0d,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x0d, 0x04, 0x00,
+      0x00, 0x05, 0x04, 0x00,
       0x00, 0x00, 0x00, 0x00,
       0x01, 0x0a, 0x0b, 0x0c,
       0x0d,
     };
 
     uint32 kValue = 0x0a0b0c0d;
     SpdySettingsIR settings_ir;
 
     SpdySettingsFlags kFlags = static_cast<SpdySettingsFlags>(0x01);
     SpdySettingsIds kId = static_cast<SpdySettingsIds>(0x020304);
@@ skipping 39 matching lines @@
       0x00, 0x00, 0x00, 0x00,  // 1st Setting
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x01,  // 2nd Setting
       0x00, 0x00, 0x00, 0x02,
       0x02, 0x00, 0x00, 0x02,  // 3rd Setting
       0x00, 0x00, 0x00, 0x03,
       0x03, 0x00, 0x00, 0x03,  // 4th Setting
       0xff, 0x00, 0x00, 0x04,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x1c, 0x04, 0x00,
+      0x00, 0x14, 0x04, 0x00,
       0x00, 0x00, 0x00, 0x00,
       0x01,                    // 1st Setting
       0x00, 0x00, 0x00, 0x01,
       0x02,                    // 2nd Setting
       0x00, 0x00, 0x00, 0x02,
       0x03,                    // 3rd Setting
       0x00, 0x00, 0x00, 0x03,
       0x04,                    // 4th Setting
       0xff, 0x00, 0x00, 0x04,
     };
@@ skipping 27 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, 0x08, 0x04, 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, 0x10, 0x06, 0x00,
+      0x00, 0x08, 0x06, 0x00,
       0x00, 0x00, 0x00, 0x00,
       0x12, 0x34, 0x56, 0x78,
       0x9a, 0xbc, 0xde, 0xff,
     };
     const unsigned char kV4FrameDataWithAck[] = {
-      0x00, 0x10, 0x06, 0x01,
+      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());
@@ skipping 23 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, 0x12, 0x07, 0x00,
+      0x00, 0x0a, 0x07, 0x00,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00,  // Stream id
       0x00, 0x00, 0x00, 0x00,  // Status
       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()) {
@@ skipping 10 matching lines @@
       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, 0x02,  // Status
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x12, 0x07, 0x00,
+      0x00, 0x0a, 0x07, 0x00,
       0x00, 0x00, 0x00, 0x00,
       0x7f, 0xff, 0xff, 0xff,  // Stream Id
       0x00, 0x00, 0x00, 0x02,  // Status
       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()) {
@@ skipping 29 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, 0x1a, 0x08, 0x04,  // Headers: END_HEADERS
+       0x00, 0x12, 0x08, 0x04,  // Headers: END_HEADERS
        0x00, 0x00, 0x00, 0x01,  // Stream 1
        0x40, 0x03, 0x62, 0x61,  // @.ba
        0x72, 0x03, 0x66, 0x6f,  // r.fo
        0x6f, 0x40, 0x03, 0x66,  // o@.f
        0x6f, 0x6f, 0x03, 0x62,  // oo.b
        0x61, 0x72,              // ar
     };
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
@@ skipping 29 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, 0x17, 0x08, 0x05,  // HEADER: FIN | END_HEADERS
+      0x00, 0x0f, 0x08, 0x05,  // HEADER: FIN | END_HEADERS
       0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
       0x40, 0x00, 0x03, 0x66,  // @..f
       0x6f, 0x6f, 0x40, 0x03,  // oo@.
       0x66, 0x6f, 0x6f, 0x03,  // foo.
       0x62, 0x61, 0x72,        // bar
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.SetHeader("", "foo");
     headers_ir.SetHeader("foo", "bar");
@@ skipping 29 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, 0x17, 0x08, 0x05,  // HEADER: FIN | END_HEADERS
+      0x00, 0x0f, 0x08, 0x05,  // HEADER: FIN | END_HEADERS
       0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
       0x40, 0x03, 0x62, 0x61,  // @.ba
       0x72, 0x03, 0x66, 0x6f,  // r.fo
       0x6f, 0x40, 0x03, 0x66,  // o@.f
       0x6f, 0x6f, 0x00,        // oo.
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
      headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
@@ skipping 72 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, 0x0c, 0x09, 0x00,
+      0x00, 0x04, 0x09, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     scoped_ptr<SpdyFrame> frame(
         framer.SerializeWindowUpdate(net::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, 0x0c, 0x09, 0x00,
+      0x00, 0x04, 0x09, 0x00,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
         net::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, 0x0c, 0x09, 0x00,
+      0x00, 0x04, 0x09, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0x7f, 0xff, 0xff, 0xff,
     };
     scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
         net::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_ < SPDY4) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "BLOCKED frame";
   const unsigned char kFrameData[] = {
-    0x00, 0x08, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 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_ < SPDY4) {
     return;
@@ skipping 16 matching lines @@
 TEST_P(SpdyFramerTest, CreatePushPromise) {
   if (spdy_version_ < SPDY4) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "PUSH_PROMISE frame";
 
   const unsigned char kFrameData[] = {
-    0x00, 0x1e, 0x0c, 0x04,  // PUSH_PROMISE: END_HEADERS
+    0x00, 0x16, 0x0c, 0x04,  // PUSH_PROMISE: END_HEADERS
     0x00, 0x00, 0x00, 0x2a,  // Stream 42
     0x00, 0x00, 0x00, 0x39,  // Promised stream 57
     0x40, 0x03, 0x62, 0x61,  // @.ba
     0x72, 0x03, 0x66, 0x6f,  // r.fo
     0x6f, 0x40, 0x03, 0x66,  // o@.f
     0x6f, 0x6f, 0x03, 0x62,  // oo.b
     0x61, 0x72,              // ar
   };
 
   SpdyPushPromiseIR push_promise(42, 57);
@@ skipping 246 matching lines @@
   const unsigned char length =  1 + SpdyFramer::kControlFrameBufferSize;
   const unsigned char kV3FrameData[] = {  // Also applies for V2.
     0x80, spdy_version_ch_, 0x00, 0x07,
     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() - 1;
+  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, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,  // Stream Id
     0x00, 0x00, 0x00, 0x00,  // Status
   };
   const size_t pad_length =
       length + framer.GetControlFrameHeaderSize() -
       (IsSpdy4() ? sizeof(kV4FrameData) : sizeof(kV3FrameData));
   string pad('A', pad_length);
@@ skipping 18 matching lines @@
 TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) {
   SpdyFramer framer(spdy_version_);
   SpdySettingsIR settings_ir;
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
   SetFrameLength(control_frame.get(), 0, spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       framer.GetControlFrameHeaderSize());
-  // Should generate an error, since zero-len settings frames are unsupported.
-  EXPECT_EQ(1, visitor.error_count_);
+  if (spdy_version_ < 4) {
+    // Should generate an error, since zero-len settings frames are unsupported.
+    EXPECT_EQ(1, visitor.error_count_);
+  } else {
+    // Zero-len settings frames are permitted as of SPDY 4.
+    EXPECT_EQ(0, visitor.error_count_);
+  }
 }
 
 // Tests handling of SETTINGS frames with invalid length.
 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
   SpdyFramer framer(spdy_version_);
   SpdySettingsIR settings_ir;
 
   // Add a setting to pad the frame so that we don't get a buffer overflow when
   // calling SimulateInFramer() below.
   SettingsMap settings;
@@ skipping 92 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, 0x17, 0x04, 0x00,
+    0x00, 0x0f, 0x04, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x01,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x01,  // 2nd (duplicate) Setting
     0x00, 0x00, 0x00, 0x03,
     0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
@@ skipping 38 matching lines @@
     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, 0x17, 0x04, 0x00,
+    0x00, 0x0f, 0x04, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x02,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x01,  // 2nd (out of order) Setting
     0x00, 0x00, 0x00, 0x03,
     0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
@@ skipping 17 matching lines @@
   }
 }
 
 TEST_P(SpdyFramerTest, ProcessSettingsAckFrame) {
   if (spdy_version_ < 4) {
     return;
   }
   SpdyFramer framer(spdy_version_);
 
   const unsigned char kFrameData[] = {
-    0x00, 0x08, 0x04, 0x01,
+    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 149 matching lines @@
 TEST_P(SpdyFramerTest, CreateContinuation) {
   if (spdy_version_ < SPDY4) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "CONTINUATION frame";
 
   const unsigned char kFrameData[] = {
-     0x00, 0x1a, 0x0d, 0x00,  // CONTINUATION
+     0x00, 0x12, 0x0d, 0x00,  // CONTINUATION
      0x00, 0x00, 0x00, 0x2a,  // Stream 42
      0x40, 0x03, 0x62, 0x61,  // @.ba
      0x72, 0x03, 0x66, 0x6f,  // r.fo
      0x6f, 0x40, 0x03, 0x66,  // o@.f
      0x6f, 0x6f, 0x03, 0x62,  // oo.b
      0x61, 0x72,              // ar
   };
 
   SpdyContinuationIR continuation(42);
   continuation.SetHeader("bar", "foo");
@@ skipping 25 matching lines @@
   EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) {
   if (spdy_version_ < 4) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x18, 0x08, 0x00,  // HEADERS
+    0x00, 0x10, 0x08, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
-    0x00, 0x1c, 0x0D, 0x00,  // CONTINUATION
+    0x00, 0x14, 0x0D, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x40, 0x06, 0x43,
 
-    0x00, 0x1a, 0x0D, 0x04,  // CONTINUATION: END_HEADERS
+    0x00, 0x12, 0x0D, 0x04,  // CONTINUATION: END_HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x6f, 0x6f, 0x6b, 0x69,
     0x65, 0x00, 0x40, 0x04,
     0x6e, 0x61, 0x6d, 0x65,
     0x05, 0x76, 0x61, 0x6c,
     0x75, 0x65,
   };
 
   SpdyFramer framer(spdy_version_);
   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_ < 4) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x18, 0x08, 0x01,  // HEADERS: FIN
+    0x00, 0x10, 0x08, 0x01,  // HEADERS: FIN
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
-    0x00, 0x1c, 0x0D, 0x00,  // CONTINUATION
+    0x00, 0x14, 0x0D, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x40, 0x06, 0x43,
 
-    0x00, 0x1a, 0x0D, 0x04,  // CONTINUATION: END_HEADERS
+    0x00, 0x12, 0x0D, 0x04,  // CONTINUATION: END_HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x6f, 0x6f, 0x6b, 0x69,
     0x65, 0x00, 0x40, 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_ < 4) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x1c, 0x0C, 0x00,  // PUSH_PROMISE
+    0x00, 0x14, 0x0C, 0x00,  // PUSH_PROMISE
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x00, 0x00, 0x00, 0x2A,  // Promised stream 42
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
-    0x00, 0x1c, 0x0D, 0x00,  // CONTINUATION
+    0x00, 0x14, 0x0D, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x40, 0x06, 0x43,
 
-    0x00, 0x1a, 0x0D, 0x04,  // CONTINUATION: END_HEADERS
+    0x00, 0x12, 0x0D, 0x04,  // CONTINUATION: END_HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x6f, 0x6f, 0x6b, 0x69,
     0x65, 0x00, 0x40, 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_ < 4) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x18, 0x08, 0x00,  // HEADERS
+    0x00, 0x10, 0x08, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
-    0x00, 0x1c, 0x0D, 0x00,  // CONTINUATION
+    0x00, 0x14, 0x0D, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x02,  // Stream 2
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x40, 0x06, 0x43,
   };
 
   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_ < 4) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x18, 0x0D, 0x00,  // CONTINUATION
+    0x00, 0x10, 0x0D, 0x00,  // CONTINUATION
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 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_ < 4) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x18, 0x08, 0x00,  // HEADERS
+    0x00, 0x10, 0x08, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
     0x00, 0x00, 0x00, 0x01,  // DATA on Stream #1
     0x00, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
   };
@@ skipping 12 matching lines @@
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, ExpectContinuationReceiveControlFrame) {
   if (spdy_version_ < 4) {
     return;
   }
 
   const unsigned char kInput[] = {
-    0x00, 0x18, 0x08, 0x00,  // HEADERS
+    0x00, 0x10, 0x08, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,
     0x6f, 0x6b, 0x69, 0x65,
     0x07, 0x66, 0x6f, 0x6f,
     0x3d, 0x62, 0x61, 0x72,
 
-    0x00, 0x1c, 0x08, 0x00,  // HEADERS
+    0x00, 0x14, 0x08, 0x00,  // HEADERS
     0x00, 0x00, 0x00, 0x01,  // Stream 1
     0x40, 0x06, 0x43, 0x6f,  // (Note this is a valid continued encoding).
     0x6f, 0x6b, 0x69, 0x65,
     0x08, 0x62, 0x61, 0x7a,
     0x3d, 0x62, 0x69, 0x6e,
     0x67, 0x40, 0x06, 0x43,
   };
 
   SpdyFramer framer(spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
@@ skipping 13 matching lines @@
 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, ReadGarbageWithValidLength) {
+  if (!IsSpdy4()) {
+    return;
+  }
+  SpdyFramer framer(spdy_version_);
+  const unsigned char kFrameData[] = {
+    0x00, 0x10, 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_);
+}
+
 TEST_P(SpdyFramerTest, ReadGarbageWithValidVersion) {
   if (IsSpdy4()) {
     // Not valid for SPDY 4 since there is no version field.
     return;
   }
   SpdyFramer framer(spdy_version_);
   const unsigned char kFrameData[] = {
     0x80, spdy_version_ch_, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff,
   };
@@ skipping 771 matching lines @@
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
   framer.set_debug_visitor(&debug_visitor);
 
   EXPECT_CALL(debug_visitor, OnSendCompressedFrame(1, SYN_STREAM, _, _));
 
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
   // Adjust size to remove the name/value block.
-  if (IsSpdy4()) {
-    SetFrameLength(
-        frame.get(),
-        framer.GetSynStreamMinimumSize(),
-        spdy_version_);
-  } else {
-    SetFrameLength(
-        frame.get(),
-        framer.GetSynStreamMinimumSize() - framer.GetControlFrameHeaderSize(),
-        spdy_version_);
-  }
+  SetFrameLength(
+      frame.get(),
+      framer.GetSynStreamMinimumSize() - framer.GetControlFrameHeaderSize(),
+      spdy_version_);
 
   EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(1, SYN_STREAM, _));
   EXPECT_CALL(visitor, OnSynStream(1, 0, 1, false, false));
   EXPECT_CALL(visitor, OnControlFrameHeaderData(1, NULL, 0));
 
   framer.ProcessInput(frame->data(), framer.GetSynStreamMinimumSize());
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
@@ skipping 14 matching lines @@
 TEST_P(SpdyFramerTest, RstStreamStatusBounds) {
   DCHECK_GE(0xff, RST_STREAM_NUM_STATUS_CODES);
 
   const unsigned char kV3RstStreamInvalid[] = {
     0x80, spdy_version_ch_, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, RST_STREAM_INVALID
   };
   const unsigned char kV4RstStreamInvalid[] = {
-    0x00, 0x0c, 0x03, 0x00,
+    0x00, 0x04, 0x03, 0x00,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, RST_STREAM_INVALID
   };
 
   const unsigned char kV3RstStreamNumStatusCodes[] = {
     0x80, spdy_version_ch_, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, RST_STREAM_NUM_STATUS_CODES
   };
   const unsigned char kV4RstStreamNumStatusCodes[] = {
-    0x00, 0x0c, 0x03, 0x00,
+    0x00, 0x04, 0x03, 0x00,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, RST_STREAM_NUM_STATUS_CODES
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INVALID));
   if (IsSpdy4()) {
@@ skipping 29 matching lines @@
     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, 0x10, 0x07, 0x00,
+    0x00, 0x08, 0x07, 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));
@@ skipping 28 matching lines @@
   SpdyBlockedIR blocked_ir(0);
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(blocked_ir));
   framer.ProcessInput(frame->data(), framer.GetBlockedSize());
 
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 }  // namespace net