Stop using SpdySynStreamIR for SPDY 4.

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 655 matching lines @@
 // All tests are run with 3 different SPDY versions: SPDY/2, SPDY/3, SPDY/4.
 INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
                         SpdyFramerTest,
                         ::testing::Values(SPDY2, SPDY3, SPDY4));
 
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
 TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
-  // Encode the header block into a SynStream frame.
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.set_priority(1);
-  syn_stream.SetHeader("alpha", "beta");
-  syn_stream.SetHeader("gamma", "charlie");
-  syn_stream.SetHeader("cookie", "key1=value1; key2=value2");
-  scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+  // Encode the header block into a Headers frame.
+  SpdyHeadersIR headers(1);
+  headers.set_priority(1);
+  headers.SetHeader("alpha", "beta");
+  headers.SetHeader("gamma", "charlie");
+  headers.SetHeader("cookie", "key1=value1; key2=value2");
+  scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
   EXPECT_TRUE(frame.get() != NULL);
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(frame->data()),
       frame->size());
 
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
-  EXPECT_TRUE(CompareHeaderBlocks(&syn_stream.name_value_block(),
+  EXPECT_TRUE(CompareHeaderBlocks(&headers.name_value_block(),
                                   &visitor.headers_));
 }
 
 // Test that if there's not a full frame, we fail to parse it.
 TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
-  // Encode the header block into a SynStream frame.
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.set_priority(1);
-  syn_stream.SetHeader("alpha", "beta");
-  syn_stream.SetHeader("gamma", "charlie");
-  scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+  // Encode the header block into a Headers frame.
+  SpdyHeadersIR headers(1);
+  headers.set_priority(1);
+  headers.SetHeader("alpha", "beta");
+  headers.SetHeader("gamma", "charlie");
+  scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
   EXPECT_TRUE(frame.get() != NULL);
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(frame->data()),
       frame->size() - 2);
 
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0u, visitor.headers_.size());
@@ skipping 273 matching lines @@
   // Expect frames 3 to be the same as a uncompressed frame created
   // from scratch.
   framer.set_enable_compression(false);
   scoped_ptr<SpdyFrame> uncompressed_frame(
       framer.SerializeSynStream(syn_stream));
   CompareFrames("Uncompressed SYN_STREAM", *frame3, *uncompressed_frame);
 }
 
 TEST_P(SpdyFramerTest, CompressEmptyHeaders) {
   // See crbug.com/172383
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.SetHeader("server", "SpdyServer 1.0");
-  syn_stream.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
-  syn_stream.SetHeader("status", "200");
-  syn_stream.SetHeader("version", "HTTP/1.1");
-  syn_stream.SetHeader("content-type", "text/html");
-  syn_stream.SetHeader("content-length", "12");
-  syn_stream.SetHeader("x-empty-header", "");
+  SpdyHeadersIR headers(1);
+  headers.SetHeader("server", "SpdyServer 1.0");
+  headers.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
+  headers.SetHeader("status", "200");
+  headers.SetHeader("version", "HTTP/1.1");
+  headers.SetHeader("content-type", "text/html");
+  headers.SetHeader("content-length", "12");
+  headers.SetHeader("x-empty-header", "");
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
-  scoped_ptr<SpdyFrame> frame1(framer.SerializeSynStream(syn_stream));
+  scoped_ptr<SpdyFrame> frame1(framer.SerializeHeaders(headers));
 }
 
 TEST_P(SpdyFramerTest, Basic) {
   const unsigned char kV2Input[] = {
     0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x14,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x02, 'h', 'h',
@@ skipping 421 matching lines @@
   decompressed_headers.clear();
   EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
                                                    serialized_headers.size(),
                                                    &decompressed_headers));
   EXPECT_EQ(3u, decompressed_headers.size());
   EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
   EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
   EXPECT_EQ(kValue3, decompressed_headers[kHeader3]);
 }
 
-// Verify we don't leak when we leave streams unclosed
-TEST_P(SpdyFramerTest, UnclosedStreamDataCompressors) {
-  SpdyFramer send_framer(spdy_version_);
-
-  send_framer.set_enable_compression(true);
-
-  const char kHeader1[] = "header1";
-  const char kHeader2[] = "header2";
-  const char kValue1[] = "value1";
-  const char kValue2[] = "value2";
-
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.SetHeader(kHeader1, kValue1);
-  syn_stream.SetHeader(kHeader2, kValue2);
-  scoped_ptr<SpdyFrame> syn_frame(send_framer.SerializeSynStream(syn_stream));
-  EXPECT_TRUE(syn_frame.get() != NULL);
-
-  StringPiece bytes = "this is a test test test test test!";
-  SpdyDataIR data_ir(1, bytes);
-  data_ir.set_fin(true);
-  scoped_ptr<SpdyFrame> send_frame(send_framer.SerializeData(data_ir));
-  EXPECT_TRUE(send_frame.get() != NULL);
-
-  // Run the inputs through the framer.
-  TestSpdyVisitor visitor(spdy_version_);
-  visitor.use_compression_ = true;
-  const unsigned char* data;
-  data = reinterpret_cast<const unsigned char*>(syn_frame->data());
-  visitor.SimulateInFramer(data, syn_frame->size());
-  data = reinterpret_cast<const unsigned char*>(send_frame->data());
-  visitor.SimulateInFramer(data, send_frame->size());
-
-  EXPECT_EQ(0, visitor.error_count_);
-  EXPECT_EQ(1, visitor.syn_frame_count_);
-  EXPECT_EQ(0, visitor.syn_reply_frame_count_);
-  EXPECT_EQ(0, visitor.headers_frame_count_);
-  EXPECT_EQ(bytes.size(), static_cast<unsigned>(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(1, visitor.data_frame_count_);
-}
-
 // Verify we can decompress the stream even if handed over to the
 // framer 1 byte at a time.
 TEST_P(SpdyFramerTest, UnclosedStreamDataCompressorsOneByteAtATime) {
   SpdyFramer send_framer(spdy_version_);
 
   send_framer.set_enable_compression(true);
 
   const char kHeader1[] = "header1";
   const char kHeader2[] = "header2";
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
 
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.SetHeader(kHeader1, kValue1);
-  syn_stream.SetHeader(kHeader2, kValue2);
-  scoped_ptr<SpdyFrame> syn_frame(send_framer.SerializeSynStream(syn_stream));
-  EXPECT_TRUE(syn_frame.get() != NULL);
+  SpdyHeadersIR headers(1);
+  headers.SetHeader(kHeader1, kValue1);
+  headers.SetHeader(kHeader2, kValue2);
+  scoped_ptr<SpdyFrame> headers_frame(send_framer.SerializeHeaders(headers));
+  EXPECT_TRUE(headers_frame.get() != NULL);
 
   const char bytes[] = "this is a test test test test test!";
   SpdyDataIR data_ir(1, StringPiece(bytes, arraysize(bytes)));
   data_ir.set_fin(true);
   scoped_ptr<SpdyFrame> send_frame(send_framer.SerializeData(data_ir));
   EXPECT_TRUE(send_frame.get() != NULL);
 
   // Run the inputs through the framer.
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   const unsigned char* data;
-  data = reinterpret_cast<const unsigned char*>(syn_frame->data());
-  for (size_t idx = 0; idx < syn_frame->size(); ++idx) {
+  data = reinterpret_cast<const unsigned char*>(headers_frame->data());
+  for (size_t idx = 0; idx < headers_frame->size(); ++idx) {
     visitor.SimulateInFramer(data + idx, 1);
     ASSERT_EQ(0, visitor.error_count_);
   }
   data = reinterpret_cast<const unsigned char*>(send_frame->data());
   for (size_t idx = 0; idx < send_frame->size(); ++idx) {
     visitor.SimulateInFramer(data + idx, 1);
     ASSERT_EQ(0, visitor.error_count_);
   }
 
   EXPECT_EQ(0, visitor.error_count_);
-  EXPECT_EQ(1, visitor.syn_frame_count_);
+  EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
-  EXPECT_EQ(0, visitor.headers_frame_count_);
+  EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(arraysize(bytes), static_cast<unsigned>(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(1, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrame) {
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
@@ skipping 317 matching lines @@
     memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
 
     SpdyDataIR data_ir(1, StringPiece(kData.data(), kData.size()));
     data_ir.set_fin(true);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     CompareFrame(kDescription, *frame, expected_frame_data.get(), kFrameSize);
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) {
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_STREAM unsupported in SPDY>3
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_STREAM frame, lowest pri, no FIN";
 
     const unsigned char kPri = IsSpdy2() ? 0xC0 : 0xE0;
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x20,
@@ skipping 14 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, 0x03, 'b',
       'a',  'r'
     };
-    const unsigned char kV4FrameData[] = {
-      0x00, 0x17, 0x01, 0x24,  // HEADERS: PRIORITY | END_HEADERS
-      0x00, 0x00, 0x00, 0x01,  // Stream 1
-      0x00, 0x00, 0x00, 0x00,  // Non-exclusive dependency 0. Weight 0.
-      0x00, 0x00, 0x03, 0x62,
-      0x61, 0x72, 0x03, 0x66,
-      0x6f, 0x6f, 0x00, 0x03,
-      0x66, 0x6f, 0x6f, 0x03,
-      0x62, 0x61, 0x72,
-    };
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(framer.GetLowestPriority());
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header name, highest pri, FIN, "
         "max stream ID";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
@@ skipping 14 matching lines @@
       0x7f, 0xff, 0xff, 0xff,
       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, 0x14, 0x01, 0x25,  // HEADERS: PRIORITY | FIN | END_HEADERS
-      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
-      0x00, 0x00, 0x00, 0x00,  // Non-exclusive dependency 0. Weight 255.
-      0xff, 0x00, 0x00, 0x03,
-      0x66, 0x6f, 0x6f, 0x00,
-      0x03, 0x66, 0x6f, 0x6f,
-      0x03, 0x62, 0x61, 0x72,
-    };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(framer.GetHighestPriority());
     syn_stream.set_fin(true);
     syn_stream.SetHeader("", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header val, high pri, FIN, "
         "max stream ID";
 
     const unsigned char kPri = IsSpdy2() ? 0x40 : 0x20;
     const unsigned char kV2FrameData[] = {
@@ skipping 15 matching lines @@
       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, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x00
     };
-    const unsigned char kV4FrameData[] = {
-      0x00, 0x14, 0x01, 0x25,  // HEADERS: PRIORITY | FIN | END_HEADERS
-      0x7f, 0xff, 0xff, 0xff,  // Stream 0x7fffffff
-      0x00, 0x00, 0x00, 0x00,  // Non-exclusive dependency 0. Weight 219.
-      0xdb, 0x00, 0x03, 0x62,
-      0x61, 0x72, 0x03, 0x66,
-      0x6f, 0x6f, 0x00, 0x03,
-      0x66, 0x6f, 0x6f, 0x00,
-    };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(1);
     syn_stream.set_fin(true);
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynStreamCompressed) {
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_STREAM not supported for SPDY>3
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] =
         "SYN_STREAM frame, low pri, no FIN";
 
     const SpdyPriority priority = IsSpdy2() ? 2 : 4;
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
@@ skipping 34 matching lines @@
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(priority);
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      // Deflate compression doesn't apply to HPACK.
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) {
   if (spdy_version_ > SPDY3) {
+    // SYN_REPLY unsupported in SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
@@ skipping 12 matching lines @@
       0x00, 0x00, 0x00, 0x01,
       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,  // HEADER: 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
-    };
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header name, FIN, max stream ID";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x01, 0x00, 0x00, 0x19,
@@ skipping 11 matching lines @@
       0x7f, 0xff, 0xff, 0xff,
       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
-    };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header val, FIN, max stream ID";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x01, 0x00, 0x00, 0x19,
@@ skipping 11 matching lines @@
       0x7f, 0xff, 0xff, 0xff,
       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.
-    };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynReplyCompressed) {
   if (spdy_version_ > SPDY3) {
+    // SYN_REPLY unsupported in SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
 
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
@@ skipping 31 matching lines @@
     };
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy2()) {
       CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      // Deflate compression doesn't apply to HPACK.
+      LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "RST_STREAM frame";
@@ skipping 468 matching lines @@
     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, 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");
+    headers_ir.SetHeader("foo", "");
+    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    if (IsSpdy2() || IsSpdy3()) {
+      // HEADERS with priority not supported.
+    } else {
+      CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
+    }
+  }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateHeadersCompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
@@ skipping 229 matching lines @@
       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) {
+  if (spdy_version_ > SPDY3) {
+    // SYN_STREAM not supported in SPDY>3
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "vv");
   syn_stream.SetHeader("bb", "ww");
   SpdyHeaderBlock headers = syn_stream.name_value_block();
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
@@ skipping 215 matching lines @@
 // Check that the framer stops delivering header data chunks once the visitor
 // declares it doesn't want any more. This is important to guard against
 // "zip bomb" types of attacks.
 TEST_P(SpdyFramerTest, ControlFrameMuchTooLarge) {
   const size_t kHeaderBufferChunks = 4;
   const size_t kHeaderBufferSize =
       TestSpdyVisitor::header_data_chunk_max_size() * kHeaderBufferChunks;
   const size_t kBigValueSize = kHeaderBufferSize * 2;
   string big_value(kBigValueSize, 'x');
   SpdyFramer framer(spdy_version_);
-  SpdySynStreamIR syn_stream(1);
-  syn_stream.set_priority(1);
-  syn_stream.set_fin(true);
-  syn_stream.SetHeader("aa", big_value);
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
+  SpdyHeadersIR headers(1);
+  headers.set_priority(1);
+  headers.set_fin(true);
+  headers.SetHeader("aa", big_value);
+  scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.set_header_buffer_size(kHeaderBufferSize);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_FALSE(visitor.header_buffer_valid_);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
@@ skipping 1183 matching lines @@
             << 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, SynStreamFrameFlags) {
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_STREAM not supported in SPDY>3
+    return;
+  }
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(8, SYN_STREAM, _, _));
 
     SpdySynStreamIR syn_stream(8);
     syn_stream.set_associated_to_stream_id(3);
     syn_stream.set_priority(1);
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     int set_flags = flags;
-    if (IsSpdy4()) {
-      // PRIORITY required for SYN_STREAM simulation.
-      set_flags |= HEADERS_FLAG_PRIORITY;
-
-      // TODO(jgraettinger): Add padding to SynStreamIR, and implement framing.
-      set_flags &= ~HEADERS_FLAG_PAD_LOW;
-      set_flags &= ~HEADERS_FLAG_PAD_HIGH;
-    }
     SetFrameFlags(frame.get(), set_flags, spdy_version_);
 
-    if (!IsSpdy4() &&
-        flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
-      EXPECT_CALL(visitor, OnError(_));
-    } else if (IsSpdy4() &&
-               flags & ~(CONTROL_FLAG_FIN |
-                         HEADERS_FLAG_PRIORITY |
-                         HEADERS_FLAG_END_HEADERS |
-                         HEADERS_FLAG_END_SEGMENT |
-                         HEADERS_FLAG_PAD_LOW |
-                         HEADERS_FLAG_PAD_HIGH)) {
+    if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(8, SYN_STREAM, _));
-      if (IsSpdy4()) {
-        EXPECT_CALL(visitor, OnSynStream(8, 0, 1, flags & CONTROL_FLAG_FIN,
-                                         false));
-      } else {
-        EXPECT_CALL(visitor, OnSynStream(8, 3, 1, flags & CONTROL_FLAG_FIN,
-                                         flags & CONTROL_FLAG_UNIDIRECTIONAL));
-      }
+      EXPECT_CALL(visitor, OnSynStream(8, 3, 1, flags & CONTROL_FLAG_FIN,
+                                       flags & CONTROL_FLAG_UNIDIRECTIONAL));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(8, _, _))
           .WillRepeatedly(testing::Return(true));
-      if (flags & DATA_FLAG_FIN && (!IsSpdy4() ||
-                                    flags & HEADERS_FLAG_END_HEADERS)) {
+      if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       } else {
         // Do not close the stream if we are expecting a CONTINUATION frame.
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true)).Times(0);
       }
     }
 
     framer.ProcessInput(frame->data(), frame->size());
-    if (!IsSpdy4() &&
-        flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
+    if (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 |
-                  HEADERS_FLAG_END_HEADERS |
-                  HEADERS_FLAG_END_SEGMENT |
-                  HEADERS_FLAG_PAD_LOW |
-                  HEADERS_FLAG_PAD_HIGH)) {
-      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.
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_REPLY not supported in SPDY>3
     return;
   }
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySynReplyIR syn_reply(37);
@@ skipping 168 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::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyHeadersIR headers_ir(57);
+    if (IsSpdy4() && (flags & HEADERS_FLAG_PRIORITY)) {
+      headers_ir.set_priority(3);
+      headers_ir.set_has_priority(true);
+    }
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
     int set_flags = flags;
     if (IsSpdy4()) {
       // TODO(jgraettinger): Add padding to SpdyHeadersIR,
       // and implement framing.
       set_flags &= ~HEADERS_FLAG_PAD_LOW;
       set_flags &= ~HEADERS_FLAG_PAD_HIGH;
     }
     SetFrameFlags(frame.get(), set_flags, spdy_version_);
 
     if (!IsSpdy4() && flags & ~CONTROL_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else if (IsSpdy4() && flags & ~(CONTROL_FLAG_FIN |
                                       HEADERS_FLAG_END_HEADERS |
                                       HEADERS_FLAG_END_SEGMENT |
                                       HEADERS_FLAG_PAD_LOW |
-                                      HEADERS_FLAG_PAD_HIGH)) {
+                                      HEADERS_FLAG_PAD_HIGH |
+                                      HEADERS_FLAG_PRIORITY)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
-      EXPECT_CALL(visitor, OnHeaders(57,
-                                     flags & CONTROL_FLAG_FIN,
-                                     (flags & HEADERS_FLAG_END_HEADERS) ||
-                                      !IsSpdy4()));
+      if (spdy_version_ > SPDY3 && flags & HEADERS_FLAG_PRIORITY) {
+        EXPECT_CALL(visitor, OnSynStream(57,        // stream id
+                                         0,         // associated stream id
+                                         3,         // priority
+                                         flags & CONTROL_FLAG_FIN,
+                                         false));  // unidirectional
+      } else {
+        EXPECT_CALL(visitor, OnHeaders(57,
+                                       flags & CONTROL_FLAG_FIN,
+                                       (flags & HEADERS_FLAG_END_HEADERS) ||
+                                        !IsSpdy4()));
+      }
       EXPECT_CALL(visitor, OnControlFrameHeaderData(57, _, _))
           .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN  && (!IsSpdy4() ||
                                      flags & HEADERS_FLAG_END_HEADERS)) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       } else {
         // Do not close the stream if we are expecting a CONTINUATION frame.
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true)).Times(0);
       }
     }
 
     framer.ProcessInput(frame->data(), frame->size());
     if (!IsSpdy4() && flags & ~CONTROL_FLAG_FIN) {
       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_END_HEADERS |
                                       HEADERS_FLAG_END_SEGMENT |
                                       HEADERS_FLAG_PAD_LOW |
-                                      HEADERS_FLAG_PAD_HIGH)) {
+                                      HEADERS_FLAG_PAD_HIGH |
+                                      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 if (IsSpdy4() && ~(flags & HEADERS_FLAG_END_HEADERS)) {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
@@ skipping 185 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 // TODO(mlavan): Add TEST_P(SpdyFramerTest, AltSvcFrameFlags)
 
 // TODO(hkhalil): Add TEST_P(SpdyFramerTest, BlockedFrameFlags)
 
 TEST_P(SpdyFramerTest, EmptySynStream) {
+  if (!IsSpdy2() && !IsSpdy3()) {
+    // SYN_STREAM not supported in SPDY>3.
+    return;
+  }
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   testing::StrictMock<test::MockDebugVisitor> debug_visitor;
   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);
@@ skipping 428 matching lines @@
   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));
 }
 
 }  // namespace net