SPDY - unforked spdy_framer and spdy_protocol tests.

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 "base/memory/scoped_ptr.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "testing/platform_test.h"
 
 namespace {
 
-// Default SPDY version for unit tests.
-const int SPDY_VERSION_FOR_TESTS = 3;
-
 // The current default spdy version as a byte to be included in const
 // byte arrays below. Name choice is unfortunate, but better to fit to four
 // bytes than not.
-unsigned char kVer = SPDY_VERSION_FOR_TESTS;
+unsigned char kVer = 2;

[Ryan Hamilton, 2012/03/14 17:32:08]

Please eliminate this too.  Using spdy_version_ instead of kVer seems
reasonable, to me.

 
 spdy::SpdySetting SpdySettingFromWireFormat(uint32 key, uint32 value) {
   return spdy::SpdySetting(
-      spdy::SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, key),
+      spdy::SettingsFlagsAndId::FromWireFormat(kVer, key),
       value);
 }
 
 }  // namespace
 
 namespace spdy {
 
-namespace test_spdy3 {
+namespace test {
 
 static const size_t kMaxDecompressedSize = 1024;
 
 class SpdyFramerTestUtil {
  public:
   // Decompress a single frame using the decompression context held by
   // the SpdyFramer. The implemention will CHECK fail if the input is anything
   // other than a single, well-formed compressed frame.
   //
   // Returns a new decompressed SpdyFrame.
@@ skipping 397 matching lines @@
   SpdyControlType header_control_type_;
   bool header_buffer_valid_;
   SpdyHeaderBlock headers_;
 
   scoped_array<char> credential_buffer_;
   size_t credential_buffer_length_;
   size_t credential_buffer_size_;
   SpdyCredential credential_;
 };
 
-}  // namespace test_spdy3
+}  // namespace test
 
 }  // namespace spdy
 
 using spdy::SpdyControlFlags;
 using spdy::SpdyControlFrame;
 using spdy::SpdyDataFrame;
 using spdy::SpdyFrame;
 using spdy::SpdyFrameBuilder;
 using spdy::SpdyFramer;
 using spdy::SpdyHeaderBlock;
 using spdy::SpdySynStreamControlFrame;
 using spdy::kControlFlagMask;
 using spdy::kLengthMask;
 using spdy::CONTROL_FLAG_NONE;
 using spdy::DATA_FLAG_COMPRESSED;
 using spdy::DATA_FLAG_FIN;
 using spdy::SYN_STREAM;
-using spdy::test_spdy3::CompareCharArraysWithHexError;
-using spdy::test_spdy3::SpdyFramerTestUtil;
-using spdy::test_spdy3::TestSpdyVisitor;
+using spdy::test::CompareCharArraysWithHexError;
+using spdy::test::SpdyFramerTestUtil;
+using spdy::test::TestSpdyVisitor;
 
 namespace spdy {
 
-TEST(SpdyFrameBuilderSpdy3Test, WriteLimits) {
+TEST(SpdyFrameBuilderTest, WriteLimits) {
   SpdyFrameBuilder builder(kLengthMask + 4);
   // length field should fail.
   EXPECT_FALSE(builder.WriteBytes(reinterpret_cast<const void*>(0x1),
                                   kLengthMask + 1));
   EXPECT_EQ(0, builder.length());
 
   // Writing a block of the maximum allowed size should succeed.
   const std::string kLargeData(kLengthMask, 'A');
   builder.WriteUInt32(kLengthMask);
   EXPECT_EQ(4, builder.length());
   EXPECT_TRUE(builder.WriteBytes(kLargeData.data(), kLengthMask));
   EXPECT_EQ(4 + kLengthMask, static_cast<unsigned>(builder.length()));
 }
 
-class SpdyFramerSpdy3Test : public PlatformTest {
- public:
+enum SpdyFramerTestTypes {
+  SPDY2,
+  SPDY3,
+};
+
+class SpdyFramerTest
+    : public ::testing::TestWithParam<SpdyFramerTestTypes> {
+ protected:
+  virtual void SetUp() {
+    if (GetParam() == SPDY2) {
+      kVer = 2;
+      spdy_version_ = 2;
+    } else {
+      kVer = 3;
+      spdy_version_ = 3;
+    }
+  }
+
   virtual void TearDown() {}
 
- protected:
   void CompareFrame(const std::string& description,
                     const SpdyFrame& actual_frame,
                     const unsigned char* expected,
                     const int expected_len) {
     const unsigned char* actual =
         reinterpret_cast<const unsigned char*>(actual_frame.data());
     int actual_len = actual_frame.length() + SpdyFrame::kHeaderSize;
     CompareCharArraysWithHexError(
         description, actual, actual_len, expected, expected_len);
   }
@@ skipping 18 matching lines @@
       if (it->second.compare(it2->second) != 0) {
         LOG(ERROR) << "Expected header named '" << it->first
                    << "' to have a value of '" << it->second
                    << "'. The actual value received was '" << it2->second
                    << "'." << std::endl;
         return false;
       }
     }
     return true;
   }
+
+  // Default SPDY version for unit tests.

[Ryan Hamilton, 2012/03/14 17:32:08]

// Version of SPDY protocol to be used 

+  int spdy_version_;
 };
 
 
+//-----------------------------------------------------------------------------
+// All tests are run with two different SPDY versions: SPDY/2 and SPDY/3.
+INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
+                        SpdyFramerTest,
+                        ::testing::Values(SPDY2, SPDY3));
+
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
-TEST_F(SpdyFramerSpdy3Test, HeaderBlockInBuffer) {
+TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "charlie";
   SpdyFramer framer(kVer);
 
   // Encode the header block into a SynStream frame.
   scoped_ptr<SpdySynStreamControlFrame> frame(
       framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE, false, &headers));
   EXPECT_TRUE(frame.get() != NULL);
   std::string serialized_headers(frame->header_block(),
                                  frame->header_block_len());
   SpdyHeaderBlock new_headers;
   EXPECT_TRUE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                               serialized_headers.size(),
                                               &new_headers));
 
   EXPECT_EQ(headers.size(), new_headers.size());
   EXPECT_EQ(headers["alpha"], new_headers["alpha"]);
   EXPECT_EQ(headers["gamma"], new_headers["gamma"]);
 }
 
 // Test that if there's not a full frame, we fail to parse it.
-TEST_F(SpdyFramerSpdy3Test, UndersizedHeaderBlockInBuffer) {
+TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "charlie";
   SpdyFramer framer(kVer);
 
   // Encode the header block into a SynStream frame.
   scoped_ptr<SpdySynStreamControlFrame> frame(
       framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE, false, &headers));
   EXPECT_TRUE(frame.get() != NULL);
 
   std::string serialized_headers(frame->header_block(),
                                  frame->header_block_len());
   SpdyHeaderBlock new_headers;
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                                serialized_headers.size() - 2,
                                                &new_headers));
 }
 
-TEST_F(SpdyFramerSpdy3Test, OutOfOrderHeaders) {
+TEST_P(SpdyFramerTest, OutOfOrderHeaders) {
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
 
   frame.WriteUInt16(kControlFlagMask | 1);
   frame.WriteUInt16(SYN_STREAM);
   frame.WriteUInt32(0);  // Placeholder for the length.
   frame.WriteUInt32(3);  // stream_id
   frame.WriteUInt32(0);  // Associated stream id
   frame.WriteUInt16(0);  // Priority.
 
-  if (SPDY_VERSION_FOR_TESTS < 3) {
+  if (spdy_version_ < 3) {

[Ryan Hamilton, 2012/03/14 17:32:08]

I notice that this same predicate is used repeatedly in the test (spdy_version_
< 3).  It might be worth adding a method IsSpdy2() or IsSpdy3() to
SpdyFramerTest and using that instead.  You might want/need to do that server
side first, so feel free to do it in another CL if you wish.

     frame.WriteUInt16(2);  // Number of headers.
     frame.WriteString("gamma");
     frame.WriteString("gamma");
     frame.WriteString("alpha");
     frame.WriteString("alpha");
   } else {
     frame.WriteUInt32(2);  // Number of headers.
     frame.WriteStringPiece32("gamma");
     frame.WriteStringPiece32("gamma");
     frame.WriteStringPiece32("alpha");
     frame.WriteStringPiece32("alpha");
   }
   // write the length
   frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
   std::string serialized_headers(syn_frame.header_block(),
                                  syn_frame.header_block_len());
   SpdyFramer framer(kVer);
   framer.set_enable_compression(false);
   EXPECT_TRUE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                               serialized_headers.size(),
                                               &new_headers));
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateCredential) {
+TEST_P(SpdyFramerTest, CreateCredential) {
   SpdyFramer framer(kVer);
 
   {
     const char kDescription[] = "CREDENTIAL frame";
     const unsigned char kFrameData[] = {
       0x80, kVer, 0x00, 0x0A,
       0x00, 0x00, 0x00, 0x33,
       0x00, 0x03, 0x00, 0x00,
       0x00, 0x05, 'p',  'r',
       'o',  'o',  'f',  0x00,
@@ skipping 12 matching lines @@
     credential.slot = 3;
     credential.proof = "proof";
     credential.certs.push_back("a cert");
     credential.certs.push_back("another cert");
     credential.certs.push_back("final cert");
     scoped_ptr<SpdyFrame> frame(framer.CreateCredentialFrame(credential));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, ParseCredentialFrameData) {
+TEST_P(SpdyFramerTest, ParseCredentialFrameData) {
   SpdyFramer framer(kVer);
 
   {
     unsigned char kFrameData[] = {
       0x80, kVer, 0x00, 0x0A,
       0x00, 0x00, 0x00, 0x33,
       0x00, 0x03, 0x00, 0x00,
       0x00, 0x05, 'p',  'r',
       'o',  'o',  'f',  0x00,
       0x00, 0x00, 0x06, 'a',
@@ skipping 17 matching lines @@
     EXPECT_EQ("a cert", credential.certs.front());
     credential.certs.erase(credential.certs.begin());
     EXPECT_EQ("another cert", credential.certs.front());
     credential.certs.erase(credential.certs.begin());
     EXPECT_EQ("final cert", credential.certs.front());
     credential.certs.erase(credential.certs.begin());
     EXPECT_TRUE(credential.certs.empty());
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, DuplicateHeader) {
+TEST_P(SpdyFramerTest, DuplicateHeader) {
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
 
   frame.WriteUInt16(kControlFlagMask | 1);
   frame.WriteUInt16(SYN_STREAM);
   frame.WriteUInt32(0);  // Placeholder for the length.
   frame.WriteUInt32(3);  // stream_id
   frame.WriteUInt32(0);  // associated stream id
   frame.WriteUInt16(0);  // Priority.
 
-  if (SPDY_VERSION_FOR_TESTS < 3) {
+  if (spdy_version_ < 3) {
     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");
     frame.WriteStringPiece32("name");
     frame.WriteStringPiece32("value2");
   }
   // write the length
   frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
   std::string serialized_headers(syn_frame.header_block(),
                                  syn_frame.header_block_len());
   SpdyFramer framer(kVer);
   framer.set_enable_compression(false);
   // This should fail because duplicate headers are verboten by the spec.
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                                serialized_headers.size(),
                                                &new_headers));
 }
 
-TEST_F(SpdyFramerSpdy3Test, MultiValueHeader) {
+TEST_P(SpdyFramerTest, MultiValueHeader) {
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
 
   frame.WriteUInt16(kControlFlagMask | 1);
   frame.WriteUInt16(SYN_STREAM);
   frame.WriteUInt32(0);  // Placeholder for the length.
   frame.WriteUInt32(3);  // stream_id
   frame.WriteUInt32(0);  // associated stream id
   frame.WriteUInt16(0);  // Priority.
 
   std::string value("value1\0value2");
-  if (SPDY_VERSION_FOR_TESTS < 3) {
+  if (spdy_version_ < 3) {
     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);
   }
   // write the length
   frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
   std::string serialized_headers(syn_frame.header_block(),
                                  syn_frame.header_block_len());
   SpdyFramer framer(kVer);
   framer.set_enable_compression(false);
   EXPECT_TRUE(framer.ParseHeaderBlockInBuffer(serialized_headers.c_str(),
                                               serialized_headers.size(),
                                               &new_headers));
   EXPECT_TRUE(new_headers.find("name") != new_headers.end());
   EXPECT_EQ(value, new_headers.find("name")->second);
 }
 
-TEST_F(SpdyFramerSpdy3Test, BasicCompression) {
+TEST_P(SpdyFramerTest, BasicCompression) {
   SpdyHeaderBlock headers;
   headers["server"] = "SpdyServer 1.0";
   headers["date"] = "Mon 12 Jan 2009 12:12:12 PST";
   headers["status"] = "200";
   headers["version"] = "HTTP/1.1";
   headers["content-type"] = "text/html";
   headers["content-length"] = "12";
 
   SpdyFramer framer(kVer);
   framer.set_enable_compression(true);
@@ skipping 25 matching lines @@
   // from scratch.
   scoped_ptr<SpdySynStreamControlFrame>
       uncompressed_frame(framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE,
                                                 false, &headers));
   EXPECT_EQ(frame3->length(), uncompressed_frame->length());
   EXPECT_EQ(0,
       memcmp(frame3->data(), uncompressed_frame->data(),
       SpdyFrame::kHeaderSize + uncompressed_frame->length()));
 }
 
-TEST_F(SpdyFramerSpdy3Test, Basic) {
+TEST_P(SpdyFramerTest, Basic) {
   const unsigned char kV2Input[] = {
     0x80, kVer, 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',
     0x00, 0x02, 'v', 'v',
 
     0x80, kVer, 0x00, 0x08,   // HEADERS on Stream #1
@@ skipping 93 matching lines @@
     0x00, 0x00, 0x00, 0x03,   // DATA on Stream #3
     0x00, 0x00, 0x00, 0x00,
 
     0x80, kVer, 0x00, 0x03,   // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x00,
   };
 
   TestSpdyVisitor visitor;
-  if (SPDY_VERSION_FOR_TESTS < 3) {
+  if (spdy_version_ < 3) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(24, visitor.data_bytes_);
   EXPECT_EQ(2, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(4, visitor.data_frame_count_);
 }
 
 // Test that the FIN flag on a data frame signifies EOF.
-TEST_F(SpdyFramerSpdy3Test, FinOnDataFrame) {
+TEST_P(SpdyFramerTest, FinOnDataFrame) {
   const unsigned char kV2Input[] = {
     0x80, kVer, 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',
     0x00, 0x02, 'v', 'v',
 
     0x80, kVer, 0x00, 0x02,   // SYN REPLY Stream #1
@@ skipping 38 matching lines @@
     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,
   };
 
   TestSpdyVisitor visitor;
-  if (SPDY_VERSION_FOR_TESTS < 3) {
+  if (spdy_version_ < 3) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   }
 
   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_);
   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_F(SpdyFramerSpdy3Test, FinOnSynReplyFrame) {
+TEST_P(SpdyFramerTest, FinOnSynReplyFrame) {
   const unsigned char kV2Input[] = {
     0x80, kVer, 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',
     0x00, 0x02, 'v', 'v',
 
     0x80, kVer, 0x00, 0x02,   // SYN REPLY Stream #1
@@ skipping 20 matching lines @@
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
     0x00, 0x02, 'a', 'a',
     0x00, 0x00, 0x00, 0x02,
     'b', 'b',
   };
 
   TestSpdyVisitor visitor;
-  if (SPDY_VERSION_FOR_TESTS < 3) {
+  if (spdy_version_ < 3) {
     visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
   } else {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   }
 
   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_);
   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_F(SpdyFramerSpdy3Test, HeaderCompression) {
+TEST_P(SpdyFramerTest, HeaderCompression) {
   SpdyFramer send_framer(kVer);
   SpdyFramer recv_framer(kVer);
 
   send_framer.set_enable_compression(true);
   recv_framer.set_enable_compression(true);
 
   const char kHeader1[] = "header1";
   const char kHeader2[] = "header2";
   const char kHeader3[] = "header3";
   const char kValue1[] = "value1";
@@ skipping 58 matching lines @@
   EXPECT_EQ(kValue3, decompressed_headers[kHeader3]);
 
   // We didn't have data streams, so we shouldn't have (de)compressors.
   EXPECT_EQ(0, send_framer.num_stream_compressors());
   EXPECT_EQ(0, send_framer.num_stream_decompressors());
   EXPECT_EQ(0, recv_framer.num_stream_compressors());
   EXPECT_EQ(0, recv_framer.num_stream_decompressors());
 }
 
 // Verify we don't leak when we leave streams unclosed
-TEST_F(SpdyFramerSpdy3Test, UnclosedStreamDataCompressors) {
+TEST_P(SpdyFramerTest, UnclosedStreamDataCompressors) {
   SpdyFramer send_framer(kVer);
 
   send_framer.set_enable_compression(true);
 
   const char kHeader1[] = "header1";
   const char kHeader2[] = "header2";
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
 
   SpdyHeaderBlock block;
@@ skipping 32 matching lines @@
 
   // We closed the streams, so all compressors should be down.
   EXPECT_EQ(0, visitor.framer_.num_stream_compressors());
   EXPECT_EQ(0, visitor.framer_.num_stream_decompressors());
   EXPECT_EQ(0, send_framer.num_stream_compressors());
   EXPECT_EQ(0, send_framer.num_stream_decompressors());
 }
 
 // Verify we can decompress the stream even if handed over to the
 // framer 1 byte at a time.
-TEST_F(SpdyFramerSpdy3Test, UnclosedStreamDataCompressorsOneByteAtATime) {
+TEST_P(SpdyFramerTest, UnclosedStreamDataCompressorsOneByteAtATime) {
   SpdyFramer send_framer(kVer);
 
   send_framer.set_enable_compression(true);
 
   const char kHeader1[] = "header1";
   const char kHeader2[] = "header2";
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
 
   SpdyHeaderBlock block;
@@ skipping 40 matching lines @@
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(1, visitor.data_frame_count_);
 
   // We closed the streams, so all compressors should be down.
   EXPECT_EQ(0, visitor.framer_.num_stream_compressors());
   EXPECT_EQ(0, visitor.framer_.num_stream_decompressors());
   EXPECT_EQ(0, send_framer.num_stream_compressors());
   EXPECT_EQ(0, send_framer.num_stream_decompressors());
 }
 
-TEST_F(SpdyFramerSpdy3Test, WindowUpdateFrame) {
+TEST_P(SpdyFramerTest, WindowUpdateFrame) {
   SpdyFramer framer(kVer);
   scoped_ptr<SpdyWindowUpdateControlFrame> window_update_frame(
       framer.CreateWindowUpdate(1, 0x12345678));
 
   const unsigned char expected_data_frame[] = {
       0x80, kVer, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x12, 0x34, 0x56, 0x78
   };
 
   EXPECT_EQ(16u, window_update_frame->size());
   EXPECT_EQ(0,
             memcmp(window_update_frame->data(), expected_data_frame, 16));
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateDataFrame) {
+TEST_P(SpdyFramerTest, CreateDataFrame) {
   SpdyFramer framer(kVer);
 
   {
     const char kDescription[] = "'hello' data frame, no FIN";
     const unsigned char kFrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h', 'e', 'l', 'l',
       'o'
     };
@@ skipping 65 matching lines @@
         new unsigned char[kFrameSize]);
     memcpy(expected_frame_data.get(), kFrameHeader, arraysize(kFrameHeader));
     memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
 
     scoped_ptr<SpdyFrame> frame(framer.CreateDataFrame(
         1, kData.data(), kData.size(), DATA_FLAG_FIN));
     CompareFrame(kDescription, *frame, expected_frame_data.get(), kFrameSize);
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateSynStreamUncompressed) {
+TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) {
   SpdyFramer framer(kVer);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_STREAM frame, lowest pri, no FIN";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "bar";
 
-    const unsigned char kPri =
-        (SPDY_VERSION_FOR_TESTS != 2) ? 0xE0 : 0xC0;
+    const unsigned char kPri = (spdy_version_ != 2) ? 0xE0 : 0xC0;
     const unsigned char kV2FrameData[] = {
       0x80, kVer, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x20,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
       kPri, 0x00, 0x00, 0x02,
       0x00, 0x03, 'b',  'a',
       'r',  0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x03,
       'f',  'o',  'o',  0x00,
@@ skipping 11 matching lines @@
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'b',
       'a',  'r'
     };
     scoped_ptr<SpdySynStreamControlFrame> frame(framer.CreateSynStream(
         1, 0, framer.GetLowestPriority(), CONTROL_FLAG_NONE, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
     EXPECT_EQ(1u, SpdyFramer::GetControlFrameStreamId(frame.get()));
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header name, highest pri, FIN, "
         "max stream ID";
 
     SpdyHeaderBlock headers;
     headers[""] = "foo";
@@ skipping 23 matching lines @@
       'o',  0x00, 0x00, 0x00,
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r'
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateSynStream(
         0x7fffffff, 0x7fffffff, framer.GetHighestPriority(), CONTROL_FLAG_FIN,
         false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header val, high pri, FIN, "
         "max stream ID";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "";
 
-    const unsigned char kPri =
-        (SPDY_VERSION_FOR_TESTS != 2) ? 0x20 : 0x40;
+    const unsigned char kPri = (spdy_version_ != 2) ? 0x20 : 0x40;
     const unsigned char kV2FrameData[] = {
       0x80, kVer, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x1D,
       0x7f, 0xff, 0xff, 0xff,
       0x7f, 0xff, 0xff, 0xff,
       kPri, 0x00, 0x00, 0x02,
       0x00, 0x03, 'b',  'a',
       'r',  0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x03,
       'f',  'o',  'o',  0x00,
@@ skipping 10 matching lines @@
       '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, 0x7fffffff, 1, CONTROL_FLAG_FIN, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateSynStreamCompressed) {
+TEST_P(SpdyFramerTest, CreateSynStreamCompressed) {
   SpdyFramer framer(kVer);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] =
         "SYN_STREAM frame, low pri, no FIN";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "bar";
 
-    const SpdyPriority priority =
-        (SPDY_VERSION_FOR_TESTS != 2) ? 4 : 2;
+    const SpdyPriority priority = (spdy_version_ != 2) ? 4 : 2;
     const unsigned char kV2FrameData[] = {
       0x80, kVer, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x25,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
       0x80, 0x00, 0x38, 0xea,
       0xdf, 0xa2, 0x51, 0xb2,
       0x62, 0x60, 0x62, 0x60,
       0x4e, 0x4a, 0x2c, 0x62,
       0x60, 0x4e, 0xcb, 0xcf,
@@ skipping 12 matching lines @@
       0xC2, 0x4B, 0x4A, 0x04,
       0xE5, 0x0B, 0xE6, 0xB4,
       0xFC, 0x7C, 0x24, 0x0A,
       0x28, 0x08, 0x00, 0x00,
       0x00, 0xFF, 0xFF
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateSynStream(
         1, 0, priority, CONTROL_FLAG_NONE, true, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateSynReplyUncompressed) {
+TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) {
   SpdyFramer framer(kVer);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "bar";
 
@@ skipping 18 matching lines @@
       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.CreateSynReply(
         1, CONTROL_FLAG_NONE, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header name, FIN, max stream ID";
 
     SpdyHeaderBlock headers;
     headers[""] = "foo";
     headers["foo"] = "bar";
 
@@ skipping 18 matching lines @@
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r'
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateSynReply(
         0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header val, FIN, max stream ID";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "";
 
@@ skipping 18 matching lines @@
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x00
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateSynReply(
         0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateSynReplyCompressed) {
+TEST_P(SpdyFramerTest, CreateSynReplyCompressed) {
   SpdyFramer framer(kVer);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "bar";
 
@@ skipping 20 matching lines @@
       0x4a, 0x04, 0xe5, 0x0b,
       0xe6, 0xb4, 0xfc, 0x7c,
       0x24, 0x0a, 0x28, 0x08,
       0x00, 0x00, 0x00, 0xff,
       0xff
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateSynReply(
         1, CONTROL_FLAG_NONE, true, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateRstStream) {
+TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer(kVer);
 
   {
     const char kDescription[] = "RST_STREAM frame";
     const unsigned char kFrameData[] = {
       0x80, kVer, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
@@ skipping 23 matching lines @@
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x06,
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateRstStream(0x7FFFFFFF,
                                                        INTERNAL_ERROR));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateSettings) {
+TEST_P(SpdyFramerTest, CreateSettings) {
   SpdyFramer framer(kVer);
 
   {
     const char kDescription[] = "Network byte order SETTINGS frame";
 
     uint32 kValue = 0x0a0b0c0d;
     uint8 kFlags = 0x04;
     uint32 kId = 0x030201;
     SettingsFlagsAndId idAndFlags(kFlags, kId);
 
@@ skipping 16 matching lines @@
       0x80, kVer, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x0c,
       0x00, 0x00, 0x00, 0x01,
       0x04, 0x03, 0x02, 0x01,
       0x0a, 0x0b, 0x0c, 0x0d,
     };
 
     scoped_ptr<SpdySettingsControlFrame> frame(framer.CreateSettings(settings));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kFrameDatav2 : kFrameDatav3,
+                 (spdy_version_ < 3) ? kFrameDatav2 : kFrameDatav3,
                  arraysize(kFrameDatav3));  // Size is unchanged among versions.
     EXPECT_EQ(SpdyFramer::kInvalidStream,
               SpdyFramer::GetControlFrameStreamId(frame.get()));
 
     // Make sure that ParseSettings also works as advertised.
     SpdySettings parsed_settings;
     EXPECT_TRUE(framer.ParseSettings(frame.get(), &parsed_settings));
     EXPECT_EQ(settings.size(), parsed_settings.size());
     EXPECT_EQ(kFlags, parsed_settings.back().first.flags());
     EXPECT_EQ(kId, parsed_settings.back().first.id());
@@ skipping 61 matching lines @@
     const unsigned char kFrameData[] = {
       0x80, kVer, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateSettings(settings));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreatePingFrame) {
+TEST_P(SpdyFramerTest, CreatePingFrame) {
   SpdyFramer framer(kVer);
 
   {
     const char kDescription[] = "PING frame";
     const unsigned char kFrameData[] = {
         0x80, kVer, 0x00, 0x06,
         0x00, 0x00, 0x00, 0x04,
         0x12, 0x34, 0x56, 0x78,
     };
     scoped_ptr<SpdyPingControlFrame> frame(framer.CreatePingFrame(0x12345678u));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
     EXPECT_EQ(SpdyFramer::kInvalidStream,
               SpdyFramer::GetControlFrameStreamId(frame.get()));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateGoAway) {
+TEST_P(SpdyFramerTest, CreateGoAway) {
   SpdyFramer framer(kVer);
 
   {
     const char kDescription[] = "GOAWAY frame";
     const unsigned char kFrameData[] = {
       0x80, kVer, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
     };
     scoped_ptr<SpdyGoAwayControlFrame> frame(framer.CreateGoAway(0));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
     EXPECT_EQ(SpdyFramer::kInvalidStream,
               SpdyFramer::GetControlFrameStreamId(frame.get()));
   }
 
   {
     const char kDescription[] = "GOAWAY frame with max stream ID";
     const unsigned char kFrameData[] = {
       0x80, kVer, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x04,
       0x7f, 0xff, 0xff, 0xff,
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateGoAway(0x7FFFFFFF));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateHeadersUncompressed) {
+TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {
   SpdyFramer framer(kVer);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "bar";
 
@@ skipping 18 matching lines @@
       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.CreateHeaders(
         1, CONTROL_FLAG_NONE, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header name, FIN, max stream ID";
 
     SpdyHeaderBlock headers;
     headers[""] = "foo";
     headers["foo"] = "bar";
 
@@ skipping 18 matching lines @@
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r'
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
         0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "";
 
@@ skipping 18 matching lines @@
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x00
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
         0x7fffffff, CONTROL_FLAG_FIN, false, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateHeadersCompressed) {
+TEST_P(SpdyFramerTest, CreateHeadersCompressed) {
   SpdyFramer framer(kVer);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
 
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "bar";
 
@@ skipping 20 matching lines @@
       0x4a, 0x04, 0xe5, 0x0b,
       0xe6, 0xb4, 0xfc, 0x7c,
       0x24, 0x0a, 0x28, 0x08,
       0x00, 0x00, 0x00, 0xff,
       0xff
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateHeaders(
         1, CONTROL_FLAG_NONE, true, &headers));
     CompareFrame(kDescription,
                  *frame,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? kV2FrameData : kV3FrameData,
-                 (SPDY_VERSION_FOR_TESTS < 3) ? arraysize(kV2FrameData)
-                                              : arraysize(kV3FrameData));
+                 (spdy_version_ < 3) ? kV2FrameData : kV3FrameData,
+                 (spdy_version_ < 3) ? arraysize(kV2FrameData)
+                                     : arraysize(kV3FrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, CreateWindowUpdate) {
+TEST_P(SpdyFramerTest, CreateWindowUpdate) {
   SpdyFramer framer(kVer);
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame";
     const unsigned char kFrameData[] = {
       0x80, kVer, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
@@ skipping 21 matching lines @@
       0x80, kVer, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x7f, 0xff, 0xff, 0xff,
     };
     scoped_ptr<SpdyFrame> frame(framer.CreateWindowUpdate(1, 0x7FFFFFFF));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, DuplicateFrame) {
+TEST_P(SpdyFramerTest, DuplicateFrame) {
   SpdyFramer framer(kVer);
 
   {
     const char kDescription[] = "PING frame";
     const unsigned char kFrameData[] = {
         0x80, kVer, 0x00, 0x06,
         0x00, 0x00, 0x00, 0x04,
         0x12, 0x34, 0x56, 0x78,
     };
     scoped_ptr<SpdyFrame> frame1(framer.CreatePingFrame(0x12345678u));
     CompareFrame(kDescription, *frame1, kFrameData, arraysize(kFrameData));
 
     scoped_ptr<SpdyFrame> frame2(framer.DuplicateFrame(*frame1));
     CompareFrame(kDescription, *frame2, kFrameData, arraysize(kFrameData));
   }
 }
 
 // This test case reproduces conditions that caused ExpandControlFrameBuffer to
 // fail to expand the buffer control frame buffer when it should have, allowing
 // the framer to overrun the buffer, and smash other heap contents. This test
 // relies on the debug version of the heap manager, which checks for buffer
 // overrun errors during delete processing. Regression test for b/2974814.
-TEST_F(SpdyFramerSpdy3Test, ExpandBuffer_HeapSmash) {
+TEST_P(SpdyFramerTest, ExpandBuffer_HeapSmash) {
   // Sweep through the area of problematic values, to make sure we always cover
   // the danger zone, even if it moves around at bit due to SPDY changes.
   for (uint16 val2_len = SpdyFramer::kControlFrameBufferInitialSize - 50;
        val2_len < SpdyFramer::kControlFrameBufferInitialSize;
        val2_len++) {
     std::string val2 = std::string(val2_len, 'a');
     SpdyHeaderBlock headers;
     headers["bar"] = "foo";
     headers["foo"] = "baz";
     headers["grue"] = val2.c_str();
     SpdyFramer framer(kVer);
     scoped_ptr<SpdySynStreamControlFrame> template_frame(
         framer.CreateSynStream(1,                      // stream_id
                                0,                      // associated_stream_id
                                1,                      // priority
                                CONTROL_FLAG_NONE,
                                false,                  // compress
                                &headers));
     EXPECT_TRUE(template_frame.get() != NULL);
     TestSpdyVisitor visitor;
     visitor.SimulateInFramer(
         reinterpret_cast<unsigned char*>(template_frame.get()->data()),
          template_frame.get()->length() + SpdyControlFrame::kHeaderSize);
     EXPECT_EQ(1, visitor.syn_frame_count_);
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, ControlFrameSizesAreValidated) {
+TEST_P(SpdyFramerTest, ControlFrameSizesAreValidated) {
   // Create a GoAway frame that has a few extra bytes at the end.
   // We create enough overhead to require the framer to expand its frame buffer.
   size_t overhead = SpdyFramer::kUncompressedControlFrameBufferInitialSize;
   SpdyFramer framer(kVer);
   scoped_ptr<SpdyGoAwayControlFrame> goaway(framer.CreateGoAway(1));
   goaway->set_length(goaway->length() + overhead);
   std::string pad('A', overhead);
   TestSpdyVisitor visitor;
 
   // First attempt without validation on.
@@ skipping 12 matching lines @@
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(goaway->data()),
       goaway->length() - overhead + SpdyControlFrame::kHeaderSize);
   visitor.SimulateInFramer(
       reinterpret_cast<const unsigned char*>(pad.c_str()),
       overhead);
   EXPECT_EQ(1, visitor.error_count_);  // This generated an error.
   EXPECT_EQ(1, visitor.goaway_count_);  // Unchanged from before.
 }
 
-TEST_F(SpdyFramerSpdy3Test, ReadZeroLenSettingsFrame) {
+TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) {
   SpdyFramer framer(kVer);
   SpdySettings settings;
   scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
   control_frame->set_length(0);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   // Should generate an error, since zero-len settings frames are unsupported.
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frames with invalid length.
-TEST_F(SpdyFramerSpdy3Test, ReadBogusLenSettingsFrame) {
+TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
   SpdyFramer framer(kVer);
   SpdySettings settings;
   // Add a setting to pad the frame so that we don't get a buffer overflow when
   // calling SimulateInFramer() below.
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 1), 0x00000002));
   scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
   control_frame->set_length(5);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   // Should generate an error, since zero-len settings frames are unsupported.
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frames larger than the frame buffer size.
-TEST_F(SpdyFramerSpdy3Test, ReadLargeSettingsFrame) {
+TEST_P(SpdyFramerTest, ReadLargeSettingsFrame) {
   SpdyFramer framer(kVer);
   SpdySettings settings;
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 1), 0x00000002));
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 2), 0x00000003));
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 3), 0x00000004));
   scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
   EXPECT_LT(SpdyFramer::kUncompressedControlFrameBufferInitialSize,
             control_frame->length() + SpdyControlFrame::kHeaderSize);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
@@ skipping 18 matching lines @@
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(settings.size() * 2, static_cast<unsigned>(visitor.setting_count_));
   EXPECT_EQ(2, visitor.settings_frame_count_);
 }
 
 // Tests handling of SETTINGS frame with duplicate entries.
-TEST_F(SpdyFramerSpdy3Test, ReadDuplicateSettings) {
+TEST_P(SpdyFramerTest, ReadDuplicateSettings) {
   SpdyFramer framer(kVer);
   SpdySettings settings;
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 1), 0x00000002));
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 1), 0x00000003));
   // This last setting should not be processed due to error above.
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 3), 0x00000003));
   scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
 
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(1, visitor.setting_count_);
   EXPECT_EQ(1, visitor.settings_frame_count_);
 }
 
 // Tests handling of SETTINGS frame with entries out of order.
-TEST_F(SpdyFramerSpdy3Test, ReadOutOfOrderSettings) {
+TEST_P(SpdyFramerTest, ReadOutOfOrderSettings) {
   SpdyFramer framer(kVer);
   SpdySettings settings;
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 2), 0x00000002));
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 1), 0x00000003));
   // This last setting should not be processed due to error above.
   settings.push_back(SpdySetting(SettingsFlagsAndId(0, 3), 0x00000003));
   scoped_ptr<SpdyFrame> control_frame(framer.CreateSettings(settings));
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
 
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(1, visitor.setting_count_);
   EXPECT_EQ(1, visitor.settings_frame_count_);
 }
 
-TEST_F(SpdyFramerSpdy3Test, ReadCredentialFrame) {
+TEST_P(SpdyFramerTest, ReadCredentialFrame) {
   SpdyCredential credential;
   credential.slot = 3;
   credential.proof = "proof";
   credential.certs.push_back("a cert");
   credential.certs.push_back("another cert");
   credential.certs.push_back("final cert");
   SpdyFramer framer(kVer);
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateCredentialFrame(credential));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.get()->data()),
       control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.credential_count_);
   EXPECT_EQ(control_frame->length(), visitor.credential_buffer_length_);
   EXPECT_EQ(credential.slot, visitor.credential_.slot);
   EXPECT_EQ(credential.proof, visitor.credential_.proof);
   EXPECT_EQ(credential.certs.size(), visitor.credential_.certs.size());
   for (size_t i = 0; i < credential.certs.size(); i++) {
     EXPECT_EQ(credential.certs[i], visitor.credential_.certs[i]);
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, ReadCredentialFrameWithCorruptProof) {
+TEST_P(SpdyFramerTest, ReadCredentialFrameWithCorruptProof) {
   SpdyCredential credential;
   credential.slot = 3;
   credential.proof = "proof";
   credential.certs.push_back("a cert");
   credential.certs.push_back("another cert");
   credential.certs.push_back("final cert");
   SpdyFramer framer(kVer);
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateCredentialFrame(credential));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   unsigned char* data =
       reinterpret_cast<unsigned char*>(control_frame.get()->data());
   size_t offset = SpdyControlFrame::kHeaderSize + 4;
   data[offset] = 0xFF;  // Proof length is past the end of the frame
   visitor.SimulateInFramer(
       data, control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
 }
 
-TEST_F(SpdyFramerSpdy3Test, ReadCredentialFrameWithCorruptCertificate) {
+TEST_P(SpdyFramerTest, ReadCredentialFrameWithCorruptCertificate) {
   SpdyCredential credential;
   credential.slot = 3;
   credential.proof = "proof";
   credential.certs.push_back("a cert");
   credential.certs.push_back("another cert");
   credential.certs.push_back("final cert");
   SpdyFramer framer(kVer);
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateCredentialFrame(credential));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   unsigned char* data =
       reinterpret_cast<unsigned char*>(control_frame.get()->data());
   size_t offset = SpdyControlFrame::kHeaderSize + credential.proof.length();
   data[offset] = 0xFF;  // Certificate length is past the end of the frame
   visitor.SimulateInFramer(
       data, control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
 }
 
-TEST_F(SpdyFramerSpdy3Test, ReadGarbage) {
+TEST_P(SpdyFramerTest, ReadGarbage) {
   SpdyFramer framer(kVer);
   unsigned char garbage_frame[256];
   memset(garbage_frame, ~0, sizeof(garbage_frame));
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(garbage_frame, sizeof(garbage_frame));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
-TEST_F(SpdyFramerSpdy3Test, ReadGarbageWithValidVersion) {
+TEST_P(SpdyFramerTest, ReadGarbageWithValidVersion) {
   SpdyFramer framer(kVer);
   char garbage_frame[256];
   memset(garbage_frame, ~0, sizeof(garbage_frame));
   SpdyControlFrame control_frame(&garbage_frame[0], false);
-  control_frame.set_version(SPDY_VERSION_FOR_TESTS);
+  control_frame.set_version(spdy_version_);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       sizeof(garbage_frame));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
-TEST_F(SpdyFramerSpdy3Test, StateToStringTest) {
+TEST_P(SpdyFramerTest, StateToStringTest) {
   EXPECT_STREQ("ERROR",
                SpdyFramer::StateToString(SpdyFramer::SPDY_ERROR));
   EXPECT_STREQ("DONE",
                SpdyFramer::StateToString(SpdyFramer::SPDY_DONE));
   EXPECT_STREQ("AUTO_RESET",
                SpdyFramer::StateToString(SpdyFramer::SPDY_AUTO_RESET));
   EXPECT_STREQ("RESET",
                SpdyFramer::StateToString(SpdyFramer::SPDY_RESET));
   EXPECT_STREQ("READING_COMMON_HEADER",
                SpdyFramer::StateToString(
@@ skipping 17 matching lines @@
                SpdyFramer::StateToString(
                    SpdyFramer::SPDY_CREDENTIAL_FRAME_PAYLOAD));
   EXPECT_STREQ("SPDY_SETTINGS_FRAME_PAYLOAD",
                SpdyFramer::StateToString(
                    SpdyFramer::SPDY_SETTINGS_FRAME_PAYLOAD));
   EXPECT_STREQ("UNKNOWN_STATE",
                SpdyFramer::StateToString(
                    SpdyFramer::SPDY_SETTINGS_FRAME_PAYLOAD + 1));
 }
 
-TEST_F(SpdyFramerSpdy3Test, ErrorCodeToStringTest) {
+TEST_P(SpdyFramerTest, ErrorCodeToStringTest) {
   EXPECT_STREQ("NO_ERROR",
                SpdyFramer::ErrorCodeToString(SpdyFramer::SPDY_NO_ERROR));
   EXPECT_STREQ("INVALID_CONTROL_FRAME",
                SpdyFramer::ErrorCodeToString(
                    SpdyFramer::SPDY_INVALID_CONTROL_FRAME));
   EXPECT_STREQ("CONTROL_PAYLOAD_TOO_LARGE",
                SpdyFramer::ErrorCodeToString(
                    SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE));
   EXPECT_STREQ("ZLIB_INIT_FAILURE",
                SpdyFramer::ErrorCodeToString(
                    SpdyFramer::SPDY_ZLIB_INIT_FAILURE));
   EXPECT_STREQ("UNSUPPORTED_VERSION",
                SpdyFramer::ErrorCodeToString(
                    SpdyFramer::SPDY_UNSUPPORTED_VERSION));
   EXPECT_STREQ("DECOMPRESS_FAILURE",
                SpdyFramer::ErrorCodeToString(
                    SpdyFramer::SPDY_DECOMPRESS_FAILURE));
   EXPECT_STREQ("COMPRESS_FAILURE",
                SpdyFramer::ErrorCodeToString(
                    SpdyFramer::SPDY_COMPRESS_FAILURE));
   EXPECT_STREQ("UNKNOWN_ERROR",
                SpdyFramer::ErrorCodeToString(SpdyFramer::LAST_ERROR));
 }
 
-TEST_F(SpdyFramerSpdy3Test, StatusCodeToStringTest) {
+TEST_P(SpdyFramerTest, StatusCodeToStringTest) {
   EXPECT_STREQ("INVALID",
                SpdyFramer::StatusCodeToString(INVALID));
   EXPECT_STREQ("PROTOCOL_ERROR",
                SpdyFramer::StatusCodeToString(PROTOCOL_ERROR));
   EXPECT_STREQ("INVALID_STREAM",
                SpdyFramer::StatusCodeToString(INVALID_STREAM));
   EXPECT_STREQ("REFUSED_STREAM",
                SpdyFramer::StatusCodeToString(REFUSED_STREAM));
   EXPECT_STREQ("UNSUPPORTED_VERSION",
                SpdyFramer::StatusCodeToString(UNSUPPORTED_VERSION));
   EXPECT_STREQ("CANCEL",
                SpdyFramer::StatusCodeToString(CANCEL));
   EXPECT_STREQ("INTERNAL_ERROR",
                SpdyFramer::StatusCodeToString(INTERNAL_ERROR));
   EXPECT_STREQ("FLOW_CONTROL_ERROR",
                SpdyFramer::StatusCodeToString(FLOW_CONTROL_ERROR));
   EXPECT_STREQ("UNKNOWN_STATUS",
                SpdyFramer::StatusCodeToString(NUM_STATUS_CODES));
 }
 
-TEST_F(SpdyFramerSpdy3Test, ControlTypeToStringTest) {
+TEST_P(SpdyFramerTest, ControlTypeToStringTest) {
   EXPECT_STREQ("SYN_STREAM",
                SpdyFramer::ControlTypeToString(SYN_STREAM));
   EXPECT_STREQ("SYN_REPLY",
                SpdyFramer::ControlTypeToString(SYN_REPLY));
   EXPECT_STREQ("RST_STREAM",
                SpdyFramer::ControlTypeToString(RST_STREAM));
   EXPECT_STREQ("SETTINGS",
                SpdyFramer::ControlTypeToString(SETTINGS));
   EXPECT_STREQ("NOOP",
                SpdyFramer::ControlTypeToString(NOOP));
   EXPECT_STREQ("PING",
                SpdyFramer::ControlTypeToString(PING));
   EXPECT_STREQ("GOAWAY",
                SpdyFramer::ControlTypeToString(GOAWAY));
   EXPECT_STREQ("HEADERS",
                SpdyFramer::ControlTypeToString(HEADERS));
   EXPECT_STREQ("WINDOW_UPDATE",
                SpdyFramer::ControlTypeToString(WINDOW_UPDATE));
   EXPECT_STREQ("CREDENTIAL",
                SpdyFramer::ControlTypeToString(CREDENTIAL));
   EXPECT_STREQ("UNKNOWN_CONTROL_TYPE",
                SpdyFramer::ControlTypeToString(NUM_CONTROL_FRAME_TYPES));
 }
 
-TEST_F(SpdyFramerSpdy3Test, GetMinimumControlFrameSizeTest) {
+TEST_P(SpdyFramerTest, GetMinimumControlFrameSizeTest) {
   EXPECT_EQ(SpdySynStreamControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(SYN_STREAM));
   EXPECT_EQ(SpdySynReplyControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(SYN_REPLY));
   EXPECT_EQ(SpdyRstStreamControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(RST_STREAM));
   EXPECT_EQ(SpdySettingsControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(SETTINGS));
   EXPECT_EQ(SpdyFrame::kHeaderSize,
             SpdyFramer::GetMinimumControlFrameSize(NOOP));
   EXPECT_EQ(SpdyPingControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(PING));
   EXPECT_EQ(SpdyGoAwayControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(GOAWAY));
   EXPECT_EQ(SpdyHeadersControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(HEADERS));
   EXPECT_EQ(SpdyWindowUpdateControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(WINDOW_UPDATE));
   EXPECT_EQ(SpdyCredentialControlFrame::size(),
             SpdyFramer::GetMinimumControlFrameSize(CREDENTIAL));
   EXPECT_EQ(static_cast<size_t>(0x7FFFFFFF),
             SpdyFramer::GetMinimumControlFrameSize(NUM_CONTROL_FRAME_TYPES));
 }
 
-TEST_F(SpdyFramerSpdy3Test, CatchProbableHttpResponse) {
+TEST_P(SpdyFramerTest, CatchProbableHttpResponse) {
   SpdyFramerTestUtil::DecompressionVisitor visitor;
   visitor.set_allow_data_frames(true);
   {
     SpdyFramer framer(kVer);
     framer.set_visitor(&visitor);
     framer.ProcessInput("HTTP/1.1", 8);
     EXPECT_TRUE(framer.probable_http_response());
   }
   {
     SpdyFramer framer(kVer);
     framer.set_visitor(&visitor);
     framer.ProcessInput("HTTP/1.0", 8);
     EXPECT_TRUE(framer.probable_http_response());
   }
 }
 
-TEST_F(SpdyFramerSpdy3Test, SettingsFlagsAndId) {
+TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
   const uint32 kId = 0x020304;
   const uint32 kFlags = 0x01;
   const uint32 kWireFormat =
-      htonl((SPDY_VERSION_FOR_TESTS < 3) ? 0x04030201 : 0x01020304);
+      htonl((spdy_version_ < 3) ? 0x04030201 : 0x01020304);
 
   SettingsFlagsAndId id_and_flags =
-      SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, kWireFormat);
+      SettingsFlagsAndId::FromWireFormat(spdy_version_, kWireFormat);
   EXPECT_EQ(kId, id_and_flags.id());
   EXPECT_EQ(kFlags, id_and_flags.flags());
-  EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat(SPDY_VERSION_FOR_TESTS));
+  EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat(spdy_version_));
 }
 
 }  // namespace