DO NOT COMMIT: SPDY 4: Hack SpdyFramer to turn SYN_STREAM and SYN_REPLY into HEADERS semi-transpare…

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 994 matching lines @@
   }
 }
 
 TEST_P(SpdyFramerTest, DuplicateHeader) {
   SpdyFramer framer(spdy_version_);
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
   if (spdy_version_ < 4) {
     frame.WriteControlFrameHeader(framer, SYN_STREAM, CONTROL_FLAG_NONE);
     frame.WriteUInt32(3);  // stream_id
+    frame.WriteUInt32(0);  // associated stream id
+    frame.WriteUInt16(0);  // Priority.
   } else {
-    frame.WriteFramePrefix(framer, SYN_STREAM, CONTROL_FLAG_NONE, 3);
+    frame.WriteFramePrefix(framer, HEADERS, HEADERS_FLAG_PRIORITY, 3);
+    frame.WriteUInt32(framer.GetHighestPriority());
   }
 
-  frame.WriteUInt32(0);  // associated stream id
-  frame.WriteUInt16(0);  // Priority.
-
   if (IsSpdy2()) {
     frame.WriteUInt16(2);  // Number of headers.
     frame.WriteString("name");
     frame.WriteString("value1");
     frame.WriteString("name");
     frame.WriteString("value2");
   } else {
     frame.WriteUInt32(2);  // Number of headers.
     frame.WriteStringPiece32("name");
     frame.WriteStringPiece32("value1");
@@ skipping 14 matching lines @@
                                                &new_headers));
 }
 
 TEST_P(SpdyFramerTest, MultiValueHeader) {
   SpdyFramer framer(spdy_version_);
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
   if (spdy_version_ < 4) {
     frame.WriteControlFrameHeader(framer, SYN_STREAM, CONTROL_FLAG_NONE);
     frame.WriteUInt32(3);  // stream_id
+    frame.WriteUInt32(0);  // associated stream id
+    frame.WriteUInt16(0);  // Priority.
   } else {
-    frame.WriteFramePrefix(framer, SYN_STREAM, CONTROL_FLAG_NONE, 3);
+    frame.WriteFramePrefix(framer, HEADERS, HEADERS_FLAG_PRIORITY, 3);
+    frame.WriteUInt32(framer.GetHighestPriority());
   }
 
-  frame.WriteUInt32(0);  // associated stream id
-  frame.WriteUInt16(0);  // Priority.
-
   string value("value1\0value2");
   if (IsSpdy2()) {
     frame.WriteUInt16(1);  // Number of headers.
     frame.WriteString("name");
     frame.WriteString(value);
   } else {
     frame.WriteUInt32(1);  // Number of headers.
     frame.WriteStringPiece32("name");
     frame.WriteStringPiece32(value);
   }
@@ skipping 245 matching lines @@
     0x00, 0x00, 0x00, 0x03,           // DATA on Stream #3
     0x00, 0x00, 0x00, 0x00,
 
     0x80, spdy_version_ch_, 0x00, 0x03,  // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x00,
   };
 
   const unsigned char kV4Input[] = {
-    0x00, 0x1e, 0x01, 0x00,           // SYN_STREAM #1
+    0x00, 0x1c, 0x08, 0x08,           // SYN_STREAM #1
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x01, 0x00, 0x00,
-    0x00, 0x02, 'h', 'h',
+    0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x02,
-    'v', 'v',
+    'h',  'h',  0x00, 0x00,
+    0x00, 0x02, 'v',  'v',
 
     0x00, 0x24, 0x08, 0x00,           // HEADERS on Stream #1
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x02,
     'h',  '2',  0x00, 0x00,
     0x00, 0x02, 'v',  '2',
     0x00, 0x00, 0x00, 0x02,
     'h',  '3',  0x00, 0x00,
     0x00, 0x02, 'v', '3',
 
     0x00, 0x14, 0x00, 0x00,           // DATA on Stream #1
     0x00, 0x00, 0x00, 0x01,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
-    0x00, 0x12, 0x01, 0x00,           // SYN Stream #3
+    0x00, 0x10, 0x08, 0x08,           // SYN Stream #3
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00,
 
     0x00, 0x10, 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, 0x00, 0x00, 0x01,
     0xde, 0xad, 0xbe, 0xef,
 
@@ skipping 80 matching lines @@
     0x00, 0x00, 0x00, 0x0c,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
     0xde, 0xad, 0xbe, 0xef,
 
     0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1, with EOF
     0x01, 0x00, 0x00, 0x04,
     0xde, 0xad, 0xbe, 0xef,
   };
   const unsigned char kV4Input[] = {
-    0x00, 0x1e, 0x01, 0x00,           // SYN_STREAM #1
+    0x00, 0x1c, 0x08, 0x08,           // SYN_STREAM #1
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x01, 0x00, 0x00,
-    0x00, 0x02, 'h', 'h',
+    0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x02,
-    'v',  'v',
+    'h',  'h',  0x00, 0x00,
+    0x00, 0x02, 'v',  'v',
 
-    0x00, 0x18, 0x02, 0x00,           // SYN REPLY Stream #1
+    0x00, 0x18, 0x08, 0x00,           // SYN REPLY Stream #1
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x02,
     'a',  'a',  0x00, 0x00,
     0x00, 0x02, 'b', 'b',
 
     0x00, 0x14, 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, 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));
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
-  EXPECT_EQ(1, visitor.syn_reply_frame_count_);
-  EXPECT_EQ(0, visitor.headers_frame_count_);
+  if (IsSpdy4()) {
+    EXPECT_EQ(0, visitor.syn_reply_frame_count_);
+    EXPECT_EQ(1, visitor.headers_frame_count_);
+  } else {
+    EXPECT_EQ(1, visitor.syn_reply_frame_count_);
+    EXPECT_EQ(0, visitor.headers_frame_count_);
+  }
   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[] = {
@@ skipping 25 matching lines @@
 
     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',
   };
   const unsigned char kV4Input[] = {
-    0x00, 0x1e, 0x01, 0x00,           // SYN_STREAM #1
+    0x00, 0x1c, 0x08, 0x08,           // SYN_STREAM #1
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x01, 0x00, 0x00,
-    0x00, 0x02, 'h', 'h',
+    0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x02,
-    'v', 'v',
+    'h',  'h',  0x00, 0x00,
+    0x00, 0x02, 'v',  'v',
 
-    0x00, 0x18, 0x02, 0x01,           // SYN_REPLY #1, with FIN
+    0x00, 0x18, 0x08, 0x01,           // SYN_REPLY #1, with FIN
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x02,
     'a', 'a',   0x00, 0x00,
     0x00, 0x02, 'b', 'b',
   };
 
   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));
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
-  EXPECT_EQ(1, visitor.syn_reply_frame_count_);
-  EXPECT_EQ(0, visitor.headers_frame_count_);
+  if (IsSpdy4()) {
+    EXPECT_EQ(0, visitor.syn_reply_frame_count_);
+    EXPECT_EQ(1, visitor.headers_frame_count_);
+  } else {
+    EXPECT_EQ(1, visitor.syn_reply_frame_count_);
+    EXPECT_EQ(0, visitor.headers_frame_count_);
+  }
   EXPECT_EQ(0, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(1, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, HeaderCompression) {
   SpdyFramer send_framer(spdy_version_);
   SpdyFramer recv_framer(spdy_version_);
@@ skipping 390 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, 0x2e, 0x01, 0x00,
+      0x00, 0x2c, 0x08, 0x08,
       0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x00,
-      kPri, kCre, 0x00, 0x00,
-      0x00, 0x02, 0x00, 0x00,
-      0x00, 0x03, 'b',  'a',
-      'r',  0x00, 0x00, 0x00,
-      0x03, 'f',  'o',  'o',
+      0x00, 0x00, 0x00, 0x07,
+      0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x00, 0x00, 0x03, 'b',
-      'a',  'r'
+      'b',  'a',  'r',  0x00,
+      0x00, 0x00, 0x03, 'f',
+      'o',  'o',  0x00, 0x00,
+      0x00, 0x03, 'f',  'o',
+      'o',  0x00, 0x00, 0x00,
+      0x03, 'b', 'a', 'r'
     };
     scoped_ptr<SpdyFrame> frame(
         framer.CreateSynStream(1,  // stream id
                                0,  // associated stream id
                                framer.GetLowestPriority(),
                                kCre,  // credential slot
                                CONTROL_FLAG_NONE,
                                false,  // compress
                                &headers));
     if (IsSpdy2()) {
@@ 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, 0x2b, 0x01, 0x01,
-      0x7f, 0xff, 0xff, 0xff,
+      0x00, 0x29, 0x08, 0x09,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x00,
-      0x00, 0x02, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x00,
-      0x00, 0x03, 'f',  'o',
-      'o',  0x00, 0x00, 0x00,
-      0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
-      'b',  'a',  'r'
+      'f',  'o',  'o',  0x00,
+      0x00, 0x00, 0x03, 'f',
+      'o',  'o',  0x00, 0x00,
+      0x00, 0x03, 'b',  'a',
+      'r'
     };
     scoped_ptr<SpdyFrame> frame(
         framer.CreateSynStream(0x7fffffff,  // stream id
                                0x7fffffff,  // associated stream id
                                framer.GetHighestPriority(),
                                0,  // credential slot
                                CONTROL_FLAG_FIN,
                                false,  // compress
                                &headers));
     if (IsSpdy2()) {
@@ skipping 35 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, 0x2b, 0x01, 0x01,
+      0x00, 0x29, 0x08, 0x09,
       0x7f, 0xff, 0xff, 0xff,
-      0x7f, 0xff, 0xff, 0xff,
-      kPri, 0x00, 0x00, 0x00,
-      0x00, 0x02, 0x00, 0x00,
-      0x00, 0x03, 'b',  'a',
-      'r',  0x00, 0x00, 0x00,
-      0x03, 'f',  'o',  'o',
+      0x00, 0x00, 0x00, 0x01,
+      0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x00, 0x00, 0x00
+      'b',  'a',  'r',  0x00,
+      0x00, 0x00, 0x03, 'f',
+      'o',  'o',  0x00, 0x00,
+      0x00, 0x03, 'f',  'o',
+      'o',  0x00, 0x00, 0x00,
+      0x00
     };
     scoped_ptr<SpdyFrame> frame(
         framer.CreateSynStream(0x7fffffff,  // stream id
                                0x7fffffff,  // associated stream id
                                1,  // priority
                                0,  // credential slot
                                CONTROL_FLAG_FIN,
                                false,  // compress
                                &headers));
     if (IsSpdy2()) {
@@ skipping 827 matching lines @@
       0x66, 0x80, 0x00, 0x4a,
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x10, 0x95, 0x96,
       0x9f, 0x0f, 0xa2, 0x00,
       0x02, 0x28, 0x29, 0xb1,
       0x08, 0x20, 0x80, 0x00,
       0x00, 0x00, 0x00, 0xff,
       0xff,
     };
     const unsigned char kV4FrameData[] = {
-      0x00, 0x35, 0x08, 0x00,
+      0x00, 0x25, 0x08, 0x00,
       0x00, 0x00, 0x00, 0x01,
       0x38, 0xea, 0xe3, 0xc6,
       0xa7, 0xc2, 0x02, 0xe5,
       0x0e, 0x50, 0xc2, 0x4b,
       0x4a, 0x04, 0xe5, 0x0b,
       0x66, 0x80, 0x00, 0x4a,
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x10, 0x95, 0x96,
       0x9f, 0x0f, 0xa2, 0x00,
       0x02, 0x28, 0x29, 0xb1,
@@ skipping 200 matching lines @@
       framer.CreateSynReply(1,                     // stream_id
                             CONTROL_FLAG_NONE,
                             true,                  // compress
                             &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
-  EXPECT_EQ(1, visitor.syn_reply_frame_count_);
+  if (IsSpdy4()) {
+    EXPECT_EQ(0, visitor.syn_reply_frame_count_);
+    EXPECT_EQ(1, visitor.headers_frame_count_);
+  } else {
+    EXPECT_EQ(1, visitor.syn_reply_frame_count_);
+    EXPECT_EQ(0, visitor.headers_frame_count_);
+  }
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateHeaders(1,                     // stream_id
@@ skipping 634 matching lines @@
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, arraysize(kFrameData));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, SizesTest) {
   SpdyFramer framer(spdy_version_);
   EXPECT_EQ(8u, framer.GetDataFrameMinimumSize());
   if (IsSpdy4()) {
+    EXPECT_EQ(8u, framer.GetControlFrameHeaderSize());
+    EXPECT_EQ(12u, framer.GetSynStreamMinimumSize());
     EXPECT_EQ(8u, framer.GetSynReplyMinimumSize());
     EXPECT_EQ(12u, framer.GetRstStreamSize());
     EXPECT_EQ(12u, framer.GetSettingsMinimumSize());
+    EXPECT_EQ(8u, framer.GetSynReplyMinimumSize());
+    EXPECT_EQ(12u, framer.GetRstStreamSize());
+    EXPECT_EQ(12u, framer.GetSettingsMinimumSize());
     EXPECT_EQ(12u, framer.GetPingSize());
     EXPECT_EQ(16u, framer.GetGoAwaySize());
     EXPECT_EQ(8u, framer.GetHeadersMinimumSize());
     EXPECT_EQ(12u, framer.GetWindowUpdateSize());
     EXPECT_EQ(10u, framer.GetCredentialMinimumSize());
     EXPECT_EQ(8u, framer.GetBlockedSize());
     EXPECT_EQ(12u, framer.GetPushPromiseMinimumSize());
     EXPECT_EQ(8u, framer.GetFrameMinimumSize());
     EXPECT_EQ(65535u, framer.GetFrameMaximumSize());
     EXPECT_EQ(65527u, framer.GetDataFrameMaximumPayload());
@@ skipping 205 matching lines @@
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(8, SYN_STREAM, _, _));
 
     SpdyHeaderBlock headers;
     headers["foo"] = "bar";
     scoped_ptr<SpdyFrame> frame(
         framer.CreateSynStream(8, 3, 1, 0, CONTROL_FLAG_NONE, true, &headers));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    int set_flags = flags;
+    if(IsSpdy4()) {
+      set_flags |= HEADERS_FLAG_PRIORITY;  // Required for SYN_STREAM simulation.
+    }
+    SetFrameFlags(frame.get(), set_flags, spdy_version_);
 
-    if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
+    if (!IsSpdy4() &&
+        flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
+      EXPECT_CALL(visitor, OnError(_));
+    } else if (IsSpdy4() &&
+               flags & ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(8, SYN_STREAM, _));
-      EXPECT_CALL(visitor, OnSynStream(8, 3, 1, 0, flags & CONTROL_FLAG_FIN,
-                                       flags & CONTROL_FLAG_UNIDIRECTIONAL));
+      if (IsSpdy4()) {
+        EXPECT_CALL(visitor, OnSynStream(8, 0, 1, 0, flags & CONTROL_FLAG_FIN,
+                                         false));
+      } else {
+        EXPECT_CALL(visitor, OnSynStream(8, 3, 1, 0, flags & CONTROL_FLAG_FIN,
+                                         flags & CONTROL_FLAG_UNIDIRECTIONAL));
+      }
       EXPECT_CALL(visitor, OnControlFrameHeaderData(8, _, _))
           .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       }
     }
 
     framer.ProcessInput(frame->data(), frame->size());
-    if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
+    if (!IsSpdy4() &&
+        flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
+          << SpdyFramer::ErrorCodeToString(framer.error_code());
+    } else if (IsSpdy4() &&
+        flags & ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY)) {
+      EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
+      EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
+                framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 TEST_P(SpdyFramerTest, SynReplyFrameFlags) {
+  if (IsSpdy4()) {
+    // Covered by HEADERS case.
+    return;
+  }
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyHeaderBlock headers;
     headers["foo"] = "bar";
     scoped_ptr<SpdyFrame> frame(
@@ skipping 119 matching lines @@
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 TEST_P(SpdyFramerTest, HeadersFrameFlags) {
   for (int flags = 0; flags < 256; ++flags) {
+    if (IsSpdy4() && flags & HEADERS_FLAG_PRIORITY) {
+      // Covered by SYN_STREAM case.
+      continue;
+    }
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyHeaderBlock headers;
     headers["foo"] = "bar";
     scoped_ptr<SpdyFrame> frame(
         framer.CreateHeaders(57, CONTROL_FLAG_NONE, true, &headers));
@@ skipping 327 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