Remove enum SpdyMajorVersion.

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 "net/spdy/spdy_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 49 matching lines @@
   //
   // Returns a new decompressed SpdySerializedFrame.
   template <class SpdyFrameType>
   static SpdySerializedFrame DecompressFrame(SpdyFramer* framer,
                                              const SpdyFrameType& frame) {
     DecompressionVisitor visitor;
     framer->set_visitor(&visitor);
     CHECK_EQ(frame.size(), framer->ProcessInput(frame.data(), frame.size()));
     CHECK_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer->state());
     framer->set_visitor(nullptr);
-    SpdyFramer serializer(framer->protocol_version());
+    SpdyFramer serializer;
     serializer.set_enable_compression(false);
     return serializer.SerializeFrame(visitor.GetFrame());
   }
 
   class DecompressionVisitor : public SpdyFramerVisitorInterface {
    public:
     DecompressionVisitor() : finished_(false) {}
 
     const SpdyFrameIR& GetFrame() const {
       CHECK(finished_);
@@ skipping 182 matching lines @@
   }
 };
 
 class TestSpdyVisitor : public SpdyFramerVisitorInterface,
                         public SpdyFramerDebugVisitorInterface {
  public:
   // This is larger than our max frame size because header blocks that
   // are too long can spill over into CONTINUATION frames.
   static const size_t kDefaultHeaderBufferSize = 16 * 1024 * 1024;
 
-  explicit TestSpdyVisitor(SpdyMajorVersion version)
-      : framer_(version),
-        use_compression_(false),
+  TestSpdyVisitor()
+      : use_compression_(false),
         error_count_(0),
         headers_frame_count_(0),
         push_promise_frame_count_(0),
         goaway_count_(0),
         setting_count_(0),
         settings_ack_sent_(0),
         settings_ack_received_(0),
         continuation_count_(0),
         altsvc_count_(0),
         priority_count_(0),
@@ skipping 221 matching lines @@
           (rand() % std::min(input_remaining, kMaxReadSize)) + 1;
       size_t bytes_processed = framer_.ProcessInput(input_ptr, bytes_read);
       input_remaining -= bytes_processed;
       input_ptr += bytes_processed;
     }
   }
 
   void InitHeaderStreaming(SpdyFrameType header_control_type,
                            SpdyStreamId stream_id) {
     if (!SpdyConstants::IsValidFrameType(
-            framer_.protocol_version(),
-            SpdyConstants::SerializeFrameType(framer_.protocol_version(),
-                                              header_control_type))) {
+            SpdyConstants::SerializeFrameType(header_control_type))) {
       DLOG(FATAL) << "Attempted to init header streaming with "
                   << "invalid control frame type: " << header_control_type;
     }
     memset(header_buffer_.get(), 0, header_buffer_size_);
     header_buffer_length_ = 0;
     header_stream_id_ = stream_id;
     header_control_type_ = header_control_type;
     header_buffer_valid_ = true;
     DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
   }
@@ skipping 68 matching lines @@
 };
 
 // Retrieves serialized headers from a HEADERS frame.
 StringPiece GetSerializedHeaders(const SpdySerializedFrame& frame,
                                  const SpdyFramer& framer) {
   SpdyFrameReader reader(frame.data(), frame.size());
   reader.Seek(3);  // Seek past the frame length.
 
   uint8_t serialized_type;
   reader.ReadUInt8(&serialized_type);
-  SpdyFrameType type =
-      SpdyConstants::ParseFrameType(framer.protocol_version(), serialized_type);
+  SpdyFrameType type = SpdyConstants::ParseFrameType(serialized_type);
   DCHECK_EQ(HEADERS, type);
   uint8_t flags;
   reader.ReadUInt8(&flags);
 
   return StringPiece(frame.data() + framer.GetHeadersMinimumSize(),
                      frame.size() - framer.GetHeadersMinimumSize());
 }
 
 class SpdyFramerTest : public ::testing::Test {
  protected:
@@ skipping 10 matching lines @@
   void CompareFrames(const string& description,
                      const SpdySerializedFrame& expected_frame,
                      const SpdySerializedFrame& actual_frame) {
     CompareCharArraysWithHexError(
         description,
         reinterpret_cast<const unsigned char*>(expected_frame.data()),
         expected_frame.size(),
         reinterpret_cast<const unsigned char*>(actual_frame.data()),
         actual_frame.size());
   }
-
-  // Version of SPDY protocol to be used.
-  SpdyMajorVersion spdy_version_ = HTTP2;
 };
 
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
 TEST_F(SpdyFramerTest, HeaderBlockInBuffer) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(false);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size());
 
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(headers.header_block(), visitor.headers_);
 }
 
 // Test that if there's not a full frame, we fail to parse it.
 TEST_F(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(false);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   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());
 }
 
 // Test that we treat incoming upper-case or mixed-case header values as
 // malformed.
 TEST_F(SpdyFramerTest, RejectUpperCaseHeaderBlockValue) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(false);
 
-  SpdyFrameBuilder frame(1024, spdy_version_);
+  SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS, 0, 1);
   frame.WriteUInt32(1);
   frame.WriteStringPiece32("Name1");
   frame.WriteStringPiece32("value1");
   frame.RewriteLength(framer);
 
-  SpdyFrameBuilder frame2(1024, spdy_version_);
+  SpdyFrameBuilder frame2(1024);
   frame2.BeginNewFrame(framer, HEADERS, 0, 1);
   frame2.WriteUInt32(2);
   frame2.WriteStringPiece32("name1");
   frame2.WriteStringPiece32("value1");
   frame2.WriteStringPiece32("nAmE2");
   frame2.WriteStringPiece32("value2");
   frame2.RewriteLength(framer);
 
   SpdySerializedFrame control_frame(frame.take());
   StringPiece serialized_headers = GetSerializedHeaders(control_frame, framer);
   SpdySerializedFrame control_frame2(frame2.take());
   StringPiece serialized_headers2 =
       GetSerializedHeaders(control_frame2, framer);
 
   SpdyHeaderBlock new_headers;
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(
       serialized_headers.data(), serialized_headers.size(), &new_headers));
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(
       serialized_headers2.data(), serialized_headers2.size(), &new_headers));
 }
 
 // Test that we can encode and decode stream dependency values in a header
 // frame.
 TEST_F(SpdyFramerTest, HeaderStreamDependencyValues) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(false);
 
   const SpdyStreamId parent_stream_id_test_array[] = {0, 3};
   for (SpdyStreamId parent_stream_id : parent_stream_id_test_array) {
     const bool exclusive_test_array[] = {true, false};
     for (bool exclusive : exclusive_test_array) {
       SpdyHeadersIR headers(1);
       headers.set_has_priority(true);
       headers.set_parent_stream_id(parent_stream_id);
       headers.set_exclusive(exclusive);
       SpdySerializedFrame frame(
           SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
-      TestSpdyVisitor visitor(spdy_version_);
+      TestSpdyVisitor visitor;
       visitor.use_compression_ = false;
       visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                                frame.size());
 
       EXPECT_TRUE(visitor.header_has_priority_);
       EXPECT_EQ(parent_stream_id, visitor.header_parent_stream_id_);
       EXPECT_EQ(exclusive, visitor.header_exclusive_);
     }
   }
 }
 
 // Test that if we receive a frame with payload length field at the
 // advertised max size, we do not set an error in ProcessInput.
 TEST_F(SpdyFramerTest, AcceptMaxFrameSizeSetting) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // DATA frame with maximum allowed payload length.
   unsigned char kH2FrameData[] = {
       0x00, 0x40, 0x00,        // Length: 2^14
       0x00,                    //   Type: HEADERS
       0x00,                    //  Flags: None
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  // Junk payload
   };
 
   SpdySerializedFrame frame(reinterpret_cast<char*>(kH2FrameData),
                             sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnDataFrameHeader(1, 1 << 14, false));
   EXPECT_CALL(visitor, OnStreamFrameData(1, _, 4));
   framer.ProcessInput(frame.data(), frame.size());
   EXPECT_FALSE(framer.HasError());
 }
 
 // Test that if we receive a frame with payload length larger than the
 // advertised max size, we set an error of SPDY_INVALID_CONTROL_FRAME_SIZE.
 TEST_F(SpdyFramerTest, ExceedMaxFrameSizeSetting) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // DATA frame with too large payload length.
   unsigned char kH2FrameData[] = {
       0x00, 0x40, 0x01,        // Length: 2^14 + 1
       0x00,                    //   Type: HEADERS
       0x00,                    //  Flags: None
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  // Junk payload
   };
 
   SpdySerializedFrame frame(reinterpret_cast<char*>(kH2FrameData),
                             sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   framer.ProcessInput(frame.data(), frame.size());
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_OVERSIZED_PAYLOAD, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a DATA frame with padding length larger than the
 // payload length, we set an error of SPDY_INVALID_PADDING
 TEST_F(SpdyFramerTest, OversizedDataPaddingError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // DATA frame with invalid padding length.
   // |kH2FrameData| has to be |unsigned char|, because Chromium on Windows uses
   // MSVC, where |char| is signed by default, which would not compile because of
   // the element exceeding 127.
   unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x00,                    //   Type: DATA
       0x09,                    //  Flags: END_STREAM|PADDED
@@ skipping 14 matching lines @@
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_PADDING, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a DATA frame with padding length not larger than the
 // payload length, we do not set an error of SPDY_INVALID_PADDING
 TEST_F(SpdyFramerTest, CorrectlySizedDataPaddingNoError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // DATA frame with valid Padding length
   char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x00,                    //   Type: DATA
       0x08,                    //  Flags: PADDED
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x04,                    // PadLen: 4 trailing bytes
       0x00, 0x00, 0x00, 0x00,  // Padding
@@ skipping 14 matching lines @@
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_FALSE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS frame with padding length larger than the
 // payload length, we set an error of SPDY_INVALID_PADDING
 TEST_F(SpdyFramerTest, OversizedHeadersPaddingError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // HEADERS frame with invalid padding length.
   // |kH2FrameData| has to be |unsigned char|, because Chromium on Windows uses
   // MSVC, where |char| is signed by default, which would not compile because of
   // the element exceeding 127.
   unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x01,                    //   Type: HEADERS
       0x08,                    //  Flags: PADDED
@@ skipping 11 matching lines @@
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_PADDING, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS frame with padding length not larger
 // than the payload length, we do not set an error of SPDY_INVALID_PADDING
 TEST_F(SpdyFramerTest, CorrectlySizedHeadersPaddingNoError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // HEADERS frame with invalid Padding length
   char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x01,                    //   Type: HEADERS
       0x08,                    //  Flags: PADDED
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x04,                    // PadLen: 4 trailing bytes
       0x00, 0x00, 0x00, 0x00,  // Padding
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnHeaders(1, false, 0, 0, false, false, false));
   EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_FALSE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a DATA with stream ID zero, we signal an error
 // (but don't crash).
 TEST_F(SpdyFramerTest, DataWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   const char bytes[] = "hello";
   SpdyDataIR data_ir(0, bytes);
   SpdySerializedFrame frame(framer.SerializeData(data_ir));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS with stream ID zero, we signal an error
 // (but don't crash).
 TEST_F(SpdyFramerTest, HeadersWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyHeadersIR headers(0);
   headers.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PRIORITY with stream ID zero, we signal an error
 // (but don't crash).
 TEST_F(SpdyFramerTest, PriorityWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyPriorityIR priority_ir(0, 1, 16, true);
   SpdySerializedFrame frame(framer.SerializeFrame(priority_ir));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a RST_STREAM with stream ID zero, we signal an error
 // (but don't crash).
 TEST_F(SpdyFramerTest, RstStreamWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyRstStreamIR rst_stream_ir(0, RST_STREAM_PROTOCOL_ERROR);
   SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream_ir));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a SETTINGS with stream ID other than zero,
 // we signal an error (but don't crash).
 TEST_F(SpdyFramerTest, SettingsWithStreamIdNotZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // Settings frame with invalid StreamID of 0x01
   char kH2FrameData[] = {
       0x00, 0x00, 0x06,        // Length: 6
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x04,              //  Param: INITIAL_WINDOW_SIZE
       0x0a, 0x0b, 0x0c, 0x0d,  //  Value: 168496141
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a GOAWAY with stream ID other than zero,
 // we signal an error (but don't crash).
 TEST_F(SpdyFramerTest, GoawayWithStreamIdNotZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // GOAWAY frame with invalid StreamID of 0x01
   char kH2FrameData[] = {
       0x00, 0x00, 0x0a,        // Length: 10
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  //   Last: 0
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
       0x47, 0x41,              // Description
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a CONTINUATION with stream ID zero, we signal an
 // SPDY_INVALID_STREAM_ID.
 TEST_F(SpdyFramerTest, ContinuationWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyContinuationIR continuation(0);
   auto some_nonsense_encoding =
       base::MakeUnique<string>("some nonsense encoding");
   continuation.take_encoding(std::move(some_nonsense_encoding));
   continuation.set_end_headers(true);
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with stream ID zero, we signal an
 // SPDY_INVALID_STREAM_ID.
 TEST_F(SpdyFramerTest, PushPromiseWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(0, 4);
   push_promise.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with promised stream ID zero, we
 // signal SPDY_INVALID_STREAM_ID.
 TEST_F(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(3, 0);
   push_promise.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_F(SpdyFramerTest, DuplicateHeader) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   // Frame builder with plentiful buffer size.
-  SpdyFrameBuilder frame(1024, spdy_version_);
+  SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS, 0, 3);
 
   frame.WriteUInt32(2);  // Number of headers.
   frame.WriteStringPiece32("name");
   frame.WriteStringPiece32("value1");
   frame.WriteStringPiece32("name");
   frame.WriteStringPiece32("value2");
   // write the length
   frame.RewriteLength(framer);
 
   SpdyHeaderBlock new_headers;
   framer.set_enable_compression(false);
   SpdySerializedFrame control_frame(frame.take());
   StringPiece serialized_headers = GetSerializedHeaders(control_frame, framer);
   // This should fail because duplicate headers are verboten by the spec.
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(
       serialized_headers.data(), serialized_headers.size(), &new_headers));
 }
 
 TEST_F(SpdyFramerTest, MultiValueHeader) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   // Frame builder with plentiful buffer size.
-  SpdyFrameBuilder frame(1024, spdy_version_);
+  SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS,
                       HEADERS_FLAG_PRIORITY | HEADERS_FLAG_END_HEADERS, 3);
   frame.WriteUInt32(0);   // Priority exclusivity and dependent stream.
   frame.WriteUInt8(255);  // Priority weight.
 
   string value("value1\0value2", 13);
   // TODO(jgraettinger): If this pattern appears again, move to test class.
   SpdyHeaderBlock header_set;
   header_set["name"] = value;
   string buffer;
   HpackEncoder encoder(ObtainHpackHuffmanTable());
   encoder.EncodeHeaderSetWithoutCompression(header_set, &buffer);
   frame.WriteBytes(&buffer[0], buffer.size());
   // write the length
   frame.RewriteLength(framer);
 
   framer.set_enable_compression(false);
   SpdySerializedFrame control_frame(frame.take());
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
 
   EXPECT_THAT(visitor.headers_,
               testing::ElementsAre(testing::Pair("name", StringPiece(value))));
 }
 
 TEST_F(SpdyFramerTest, CompressEmptyHeaders) {
   // See crbug.com/172383
   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_);
+  SpdyFramer framer;
   framer.set_enable_compression(true);
   SpdySerializedFrame frame1(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
 }
 
 TEST_F(SpdyFramerTest, Basic) {
   // Send HEADERS frames with PRIORITY and END_HEADERS set.
   // frame-format off
   const unsigned char kH2Input[] = {
       0x00, 0x00, 0x05,        // Length: 5
@@ skipping 49 matching lines @@
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
 
       0x00, 0x00, 0x04,        // Length: 4
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x00, 0x08,  //  Error: CANCEL
   };
   // frame-format on
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kH2Input, sizeof(kH2Input));
 
   EXPECT_EQ(24, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.fin_frame_count_);
 
   EXPECT_EQ(3, visitor.headers_frame_count_);
   EXPECT_TRUE(visitor.fin_opaque_data_.empty());
 
   EXPECT_EQ(0, visitor.fin_flag_count_);
@@ skipping 29 matching lines @@
       0xde, 0xad, 0xbe, 0xef,  //
 
       0x00, 0x00, 0x04,        // Length: 4
       0x00,                    //   Type: DATA
       0x01,                    //  Flags: END_STREAM
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0xde, 0xad, 0xbe, 0xef,  // Payload
   };
   // frame-format on
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kH2Input, sizeof(kH2Input));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, 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.end_of_stream_count_);
   EXPECT_EQ(2, visitor.data_frame_count_);
 }
@@ skipping 10 matching lines @@
       0x82,                    // Weight: 131
 
       0x00, 0x00, 0x01,        // Length: 1
       0x01,                    //   Type: HEADERS
       0x05,                    //  Flags: END_STREAM|END_HEADERS
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x8c,                    // :status: 200
   };
   // frame-format on
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kH2Input, sizeof(kH2Input));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, 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.end_of_stream_count_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 // Verify we can decompress the stream even if handed over to the
 // framer 1 byte at a time.
 TEST_F(SpdyFramerTest, UnclosedStreamDataCompressorsOneByteAtATime) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   framer.set_enable_compression(true);
 
   const char kHeader1[] = "header1";
   const char kHeader2[] = "header2";
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
 
   SpdyHeadersIR headers(1);
   headers.SetHeader(kHeader1, kValue1);
   headers.SetHeader(kHeader2, kValue2);
   SpdySerializedFrame headers_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
   const char bytes[] = "this is a test test test test test!";
   SpdyDataIR data_ir(1, StringPiece(bytes, arraysize(bytes)));
   data_ir.set_fin(true);
   SpdySerializedFrame send_frame(framer.SerializeData(data_ir));
 
   // Run the inputs through the framer.
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = true;
   const unsigned char* data;
   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.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.end_of_stream_count_);
   EXPECT_EQ(1, visitor.data_frame_count_);
 }
 
 TEST_F(SpdyFramerTest, WindowUpdateFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdySerializedFrame frame(
       framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x12345678)));
 
   const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678";
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x08,                    //   Type: WINDOW_UPDATE
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x12, 0x34, 0x56, 0x78,  // Increment: 305419896
   };
 
   CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
 }
 
 TEST_F(SpdyFramerTest, CreateDataFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   {
     const char kDescription[] = "'hello' data frame, no FIN";
     // frame-format off
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x05,        // Length: 5
         0x00,                    //   Type: DATA
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         'h',  'e',  'l',  'l',   // Payload
@@ skipping 181 matching lines @@
         0x6f,                    //
     };
     SpdyDataIR data_ir(0x7fffffff, "hello");
     data_ir.set_fin(true);
     SpdySerializedFrame frame(framer.SerializeData(data_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_F(SpdyFramerTest, CreateRstStream) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   {
     const char kDescription[] = "RST_STREAM frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x03,                    //   Type: RST_STREAM
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x00, 0x00, 0x00, 0x01,  //  Error: PROTOCOL_ERROR
     };
@@ skipping 25 matching lines @@
         0x7f, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff
         0x00, 0x00, 0x00, 0x02,  //  Error: INTERNAL_ERROR
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF, RST_STREAM_INTERNAL_ERROR);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_F(SpdyFramerTest, CreateSettings) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   {
     const char kDescription[] = "Network byte order SETTINGS frame";
 
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x06,        // Length: 6
         0x04,                    //   Type: SETTINGS
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x00, 0x04,              //  Param: INITIAL_WINDOW_SIZE
@@ skipping 26 matching lines @@
         0x00, 0x00, 0x00, 0x07,  //  Value: 7
         0x00, 0x04,              //  Param: INITIAL_WINDOW_SIZE
         0x00, 0x00, 0x00, 0x08,  //  Value: 8
         0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
         0x00, 0x00, 0x00, 0x05,  //  Value: 5
         0x00, 0x02,              //  Param: ENABLE_PUSH
         0x00, 0x00, 0x00, 0x06,  //  Value: 6
     };
 
     SpdySettingsIR settings_ir;
-    settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
+    settings_ir.AddSetting(SpdyConstants::ParseSettingId(1),
                            false,  // persist
                            false,  // persisted
                            5);
-    settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 2),
+    settings_ir.AddSetting(SpdyConstants::ParseSettingId(2),
                            false,  // persist
                            false,  // persisted
                            6);
-    settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 3),
+    settings_ir.AddSetting(SpdyConstants::ParseSettingId(3),
                            false,  // persist
                            false,  // persisted
                            7);
-    settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 4),
+    settings_ir.AddSetting(SpdyConstants::ParseSettingId(4),
                            false,  // persist
                            false,  // persisted
                            8);
     SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
 
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 
   {
     const char kDescription[] = "Empty SETTINGS frame";
 
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x00,        // Length: 0
         0x04,                    //   Type: SETTINGS
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
     };
     SpdySettingsIR settings_ir;
     SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_F(SpdyFramerTest, CreatePingFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   {
     const char kDescription[] = "PING frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x08,        // Length: 8
         0x06,                    //   Type: PING
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x12, 0x34, 0x56, 0x78,  // Opaque
         0x9a, 0xbc, 0xde, 0xff,  //     Data
@@ skipping 16 matching lines @@
 
     // Tests SpdyPingIR when the ping is an ack.
     ping_ir.set_is_ack(true);
     frame = framer.SerializePing(ping_ir);
     CompareFrame(kDescription, frame, kH2FrameDataWithAck,
                  arraysize(kH2FrameDataWithAck));
   }
 }
 
 TEST_F(SpdyFramerTest, CreateGoAway) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   {
     const char kDescription[] = "GOAWAY frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x0a,        // Length: 10
         0x07,                    //   Type: GOAWAY
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x00, 0x00, 0x00, 0x00,  //   Last: 0
         0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
@@ skipping 15 matching lines @@
         0x00, 0x00, 0x00, 0x02,  //  Error: INTERNAL_ERROR
         0x47, 0x41,              // Description
     };
     SpdyGoAwayIR goaway_ir(0x7FFFFFFF, GOAWAY_INTERNAL_ERROR, "GA");
     SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_F(SpdyFramerTest, CreateHeadersUncompressed) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
     // frame-format off
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x12,        // Length: 18
         0x01,                    //   Type: HEADERS
         0x04,                    //  Flags: END_HEADERS
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
@@ skipping 231 matching lines @@
     SpdySerializedFrame frame(
         SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_F(SpdyFramerTest, CreateHeadersCompressed) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(true);
 
   {
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
     SpdySerializedFrame frame(
         SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
     // Deflate compression doesn't apply to HPACK.
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_F(SpdyFramerTest, CreateWindowUpdate) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x08,                    //   Type: WINDOW_UPDATE
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x00, 0x00, 0x00, 0x01,  // Increment: 1
     };
@@ skipping 25 matching lines @@
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x7f, 0xff, 0xff, 0xff,  // Increment: 0x7fffffff
     };
     SpdySerializedFrame frame(
         framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x7FFFFFFF)));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_F(SpdyFramerTest, SerializeBlocked) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   const char kDescription[] = "BLOCKED frame";
-  const unsigned char kType = static_cast<unsigned char>(
-      SpdyConstants::SerializeFrameType(spdy_version_, BLOCKED));
+  const unsigned char kType =
+      static_cast<unsigned char>(SpdyConstants::SerializeFrameType(BLOCKED));
   const unsigned char kFrameData[] = {
       0x00,  0x00, 0x00,        // Length: 0
       kType,                    //   Type: BLOCKED
       0x00,                     //  Flags: none
       0x00,  0x00, 0x00, 0x00,  // Stream: 0
   };
   SpdyBlockedIR blocked_ir(0);
   SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_F(SpdyFramerTest, CreateBlocked) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   const char kDescription[] = "BLOCKED frame";
   const SpdyStreamId kStreamId = 3;
 
   SpdySerializedFrame frame_serialized(
       framer.SerializeBlocked(SpdyBlockedIR(kStreamId)));
   SpdyBlockedIR blocked_ir(kStreamId);
   SpdySerializedFrame frame_created(framer.SerializeFrame(blocked_ir));
 
   CompareFrames(kDescription, frame_serialized, frame_created);
 }
 
 TEST_F(SpdyFramerTest, CreatePushPromiseUncompressed) {
   {
     // Test framing PUSH_PROMISE without padding.
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame without padding";
 
     // frame-format off
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0x16,        // Length: 22
         0x05,                    //   Type: PUSH_PROMISE
         0x04,                    //  Flags: END_HEADERS
         0x00, 0x00, 0x00, 0x29,  // Stream: 41
         0x00, 0x00, 0x00, 0x3a,  // Promise: 58
@@ skipping 14 matching lines @@
 
     SpdyPushPromiseIR push_promise(41, 58);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 
   {
     // Test framing PUSH_PROMISE with one byte of padding.
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame with one byte of padding";
 
     // frame-format off
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0x17,        // Length: 23
         0x05,                    //   Type: PUSH_PROMISE
         0x0c,                    //  Flags: END_HEADERS|PADDED
         0x00, 0x00, 0x00, 0x29,  // Stream: 41
         0x00,                    // PadLen: 0 trailing bytes
@@ skipping 16 matching lines @@
     SpdyPushPromiseIR push_promise(41, 58);
     push_promise.set_padding_len(1);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 
   {
     // Test framing PUSH_PROMISE with 177 bytes of padding.
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame with 177 bytes of padding";
 
     // frame-format off
     // clang-format off
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0xc7,        // Length: 199
         0x05,                    //   Type: PUSH_PROMISE
         0x0c,                    //  Flags: END_HEADERS|PADDED
         0x00, 0x00, 0x00, 0x2a,  // Stream: 42
@@ skipping 37 matching lines @@
     push_promise.set_padding_len(177);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 }
 
 // Regression test for https://crbug.com/464748.
 TEST_F(SpdyFramerTest, GetNumberRequiredContinuationFrames) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   EXPECT_EQ(1u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 16374));
   EXPECT_EQ(2u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 16374 + 1));
   EXPECT_EQ(2u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 2 * 16374));
   EXPECT_EQ(3u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 2 * 16374 + 1));
 }
 
 TEST_F(SpdyFramerTest, CreateContinuationUncompressed) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(false);
   const char kDescription[] = "CONTINUATION frame";
 
   // frame-format off
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x09,                    //   Type: CONTINUATION
       0x04,                    //  Flags: END_HEADERS
       0x00, 0x00, 0x00, 0x2a,  // Stream: 42
 
@@ skipping 23 matching lines @@
   continuation.set_end_headers(true);
 
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 // Test that if we send an unexpected CONTINUATION
 // we signal an error (but don't crash).
 TEST_F(SpdyFramerTest, SendUnexpectedContinuation) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // frame-format off
   char kH2FrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x09,                    //   Type: CONTINUATION
       0x04,                    //  Flags: END_HEADERS
       0x00, 0x00, 0x00, 0x2a,  // Stream: 42
 
       0x00,              // Unindexed Entry
@@ skipping 18 matching lines @@
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_F(SpdyFramerTest, CreatePushPromiseThenContinuationUncompressed) {
   {
     // Test framing in a case such that a PUSH_PROMISE frame, with one byte of
     // padding, cannot hold all the data payload, which is overflowed to the
     // consecutive CONTINUATION frame.
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_enable_compression(false);
     const char kDescription[] =
         "PUSH_PROMISE and CONTINUATION frames with one byte of padding";
 
     // frame-format off
     const unsigned char kPartialPushPromiseFrameData[] = {
         0x00, 0x3f, 0xf6,        // Length: 16374
         0x05,                    //   Type: PUSH_PROMISE
         0x08,                    //  Flags: PADDED
         0x00, 0x00, 0x00, 0x2a,  // Stream: 42
@@ skipping 76 matching lines @@
 
     // Compare the CONTINUATION frame against the template.
     frame_data += TestSpdyVisitor::sent_control_frame_max_size();
     CompareCharArraysWithHexError(
         kDescription, frame_data, arraysize(kContinuationFrameData),
         kContinuationFrameData, arraysize(kContinuationFrameData));
   }
 }
 
 TEST_F(SpdyFramerTest, CreateAltSvc) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   const char kDescription[] = "ALTSVC frame";
-  const char kType = static_cast<unsigned char>(
-      SpdyConstants::SerializeFrameType(spdy_version_, ALTSVC));
+  const char kType =
+      static_cast<unsigned char>(SpdyConstants::SerializeFrameType(ALTSVC));
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x49, kType, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x06, 'o',
       'r',  'i',  'g',  'i',   'n',  'p',  'i',  'd',  '1',  '=',  '"',  'h',
       'o',  's',  't',  ':',   '4',  '4',  '3',  '"',  ';',  ' ',  'm',  'a',
       '=',  '5',  ',',  'p',   '%',  '2',  '2',  '%',  '3',  'D',  'i',  '%',
       '3',  'A',  'd',  '=',   '"',  'h',  '_',  '\\', '\\', 'o',  '\\', '"',
       's',  't',  ':',  '1',   '2',  '3',  '"',  ';',  ' ',  'm',  'a',  '=',
       '4',  '2',  ';',  ' ',   'v',  '=',  '"',  '2',  '4',  '"'};
   SpdyAltSvcIR altsvc_ir(3);
   altsvc_ir.set_origin("origin");
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector()));
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "p\"=i:d", "h_\\o\"st", 123, 42,
       SpdyAltSvcWireFormat::VersionVector{24}));
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_F(SpdyFramerTest, CreatePriority) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   const char kDescription[] = "PRIORITY frame";
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x02,                    //   Type: PRIORITY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x02,  // Stream: 2
       0x80, 0x00, 0x00, 0x01,  // Parent: 1 (Exclusive)
       0x10,                    // Weight: 17
   };
   SpdyPriorityIR priority_ir(2, 1, 17, true);
   SpdySerializedFrame frame(framer.SerializeFrame(priority_ir));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   SpdyPriorityIR priority2(2);
   priority2.set_parent_stream_id(1);
   priority2.set_weight(17);
   priority2.set_exclusive(true);
   frame = framer.SerializeFrame(priority2);
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_F(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdyHeadersIR headers_ir(1);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
   EXPECT_EQ(headers_ir.header_block(), visitor.headers_);
 }
 
 TEST_F(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdyHeadersIR headers_ir(1);
   headers_ir.set_fin(true);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(headers_ir.header_block(), visitor.headers_);
 }
 
 TEST_F(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(false);
   SpdyHeadersIR headers(1);
   headers.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   string big_value(kBigValueSize, 'x');
   headers.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
   EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 }
 
 TEST_F(SpdyFramerTest, MultipleContinuationFramesWithIterator) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(false);
   auto headers = base::MakeUnique<SpdyHeadersIR>(1);
   headers->set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   string big_valuex(kBigValueSize, 'x');
   headers->SetHeader("aa", big_valuex);
   string big_valuez(kBigValueSize, 'z');
   headers->SetHeader("bb", big_valuez);
 
   SpdyFramer::SpdyHeaderFrameIterator frame_it(&framer, std::move(headers));
 
   EXPECT_TRUE(frame_it.HasNextFrame());
   SpdySerializedFrame headers_frame(frame_it.NextFrame());
   EXPECT_EQ(headers_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(headers_frame.data()),
       headers_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 
   EXPECT_TRUE(frame_it.HasNextFrame());
@@ skipping 21 matching lines @@
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 
   EXPECT_FALSE(frame_it.HasNextFrame());
 }
 
 TEST_F(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_enable_compression(false);
   SpdyPushPromiseIR push_promise(1, 2);
   push_promise.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   string big_value(kBigValueSize, 'x');
   push_promise.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(framer.SerializePushPromise(push_promise));
   EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 }
 
 // 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_F(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_);
+  SpdyFramer framer;
   SpdyHeadersIR headers(1);
   headers.set_fin(true);
   headers.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.set_header_buffer_size(kHeaderBufferSize);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   // It's up to the visitor to ignore extraneous header data; the framer
   // won't throw an error.
   EXPECT_GT(visitor.header_bytes_received_, visitor.header_buffer_size_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
 }
 
 TEST_F(SpdyFramerTest, ControlFrameSizesAreValidated) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   // Create a GoAway frame that has a few extra bytes at the end.
   // We create enough overhead to overflow the framer's control frame buffer.
   ASSERT_LE(SpdyFramerPeer::ControlFrameBufferSize(), 250u);
   const size_t length = SpdyFramerPeer::ControlFrameBufferSize() + 1;
 
   // HTTP/2 GOAWAY frames are only bound by a minimal length, since they may
   // carry opaque data. Verify that minimal length is tested.
-  ASSERT_GT(framer.GetGoAwayMinimumSize(), framer.GetFrameHeaderSize());
+  ASSERT_GT(framer.GetGoAwayMinimumSize(), SpdyConstants::kFrameHeaderSize);
   const size_t less_than_min_length =
-      framer.GetGoAwayMinimumSize() - framer.GetFrameHeaderSize() - 1;
+      framer.GetGoAwayMinimumSize() - SpdyConstants::kFrameHeaderSize - 1;
   ASSERT_LE(less_than_min_length, std::numeric_limits<unsigned char>::max());
   const unsigned char kH2Len = static_cast<unsigned char>(less_than_min_length);
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, kH2Len,        // Length: min length - 1
       0x07,                      //   Type: GOAWAY
       0x00,                      //  Flags: none
       0x00, 0x00, 0x00,   0x00,  // Stream: 0
       0x00, 0x00, 0x00,   0x00,  //   Last: 0
       0x00, 0x00, 0x00,          // Truncated Status Field
   };
   const size_t pad_length =
-      length + framer.GetFrameHeaderSize() - sizeof(kH2FrameData);
+      length + SpdyConstants::kFrameHeaderSize - sizeof(kH2FrameData);
   string pad(pad_length, 'A');
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
 
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
   visitor.SimulateInFramer(reinterpret_cast<const unsigned char*>(pad.c_str()),
                            pad.length());
 
   EXPECT_EQ(1, visitor.error_count_);  // This generated an error.
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(0, visitor.goaway_count_);  // Frame not parsed.
 }
 
 TEST_F(SpdyFramerTest, ReadZeroLenSettingsFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdySettingsIR settings_ir;
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
-  SetFrameLength(&control_frame, 0, spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SetFrameLength(&control_frame, 0);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       framer.GetFrameHeaderSize());
   // Zero-len settings frames are permitted as of HTTP/2.
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frames with invalid length.
 TEST_F(SpdyFramerTest, ReadBogusLenSettingsFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdySettingsIR settings_ir;
 
   // Add a setting to pad the frame so that we don't get a buffer overflow when
   // calling SimulateInFramer() below.
   settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, false, false,
                          0x00000002);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   const size_t kNewLength = 14;
-  SetFrameLength(&control_frame, kNewLength, spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SetFrameLength(&control_frame, kNewLength);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       framer.GetFrameHeaderSize() + kNewLength);
   // Should generate an error, since its not possible to have a
   // settings frame of length kNewLength.
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of SETTINGS frames larger than the frame buffer size.
 TEST_F(SpdyFramerTest, ReadLargeSettingsFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdySettingsIR settings_ir;
-  settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
+  settings_ir.AddSetting(SpdyConstants::ParseSettingId(1),
                          false,  // persist
                          false,  // persisted
                          5);
-  settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 2),
+  settings_ir.AddSetting(SpdyConstants::ParseSettingId(2),
                          false,  // persist
                          false,  // persisted
                          6);
-  settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 3),
+  settings_ir.AddSetting(SpdyConstants::ParseSettingId(3),
                          false,  // persist
                          false,  // persisted
                          7);
 
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   EXPECT_LT(SpdyFramerPeer::ControlFrameBufferSize(), control_frame.size());
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
 
   // Read all at once.
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(3, visitor.setting_count_);
   EXPECT_EQ(1, visitor.settings_ack_sent_);
 
   // Read data in small chunks.
   size_t framed_data = 0;
   size_t unframed_data = control_frame.size();
   size_t kReadChunkSize = 5;  // Read five bytes at a time.
   while (unframed_data > 0) {
     size_t to_read = std::min(kReadChunkSize, unframed_data);
     visitor.SimulateInFramer(
         reinterpret_cast<unsigned char*>(control_frame.data() + framed_data),
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(3 * 2, visitor.setting_count_);
   EXPECT_EQ(2, visitor.settings_ack_sent_);
 }
 
 // Tests handling of SETTINGS frame with duplicate entries.
 TEST_F(SpdyFramerTest, ReadDuplicateSettings) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
       0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
       0x00, 0x03,              //  Param: MAX_CONCURRENT_STREAMS
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
   };
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
   // In HTTP/2, duplicate settings are allowed;
   // each setting replaces the previous value for that setting.
   EXPECT_EQ(3, visitor.setting_count_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.settings_ack_sent_);
 }
 
 // Tests handling of SETTINGS frame with a setting we don't recognize.
 TEST_F(SpdyFramerTest, ReadUnknownSettingsId) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x06,        // Length: 6
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x10,              //  Param: 16
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
   };
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
   // In HTTP/2, we ignore unknown settings because of extensions.
   EXPECT_EQ(0, visitor.setting_count_);
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frame with entries out of order.
 TEST_F(SpdyFramerTest, ReadOutOfOrderSettings) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x02,              //  Param: ENABLE_PUSH
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
       0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
       0x00, 0x03,              //  Param: MAX_CONCURRENT_STREAMS
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
   };
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
   // In HTTP/2, settings are allowed in any order.
   EXPECT_EQ(3, visitor.setting_count_);
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 TEST_F(SpdyFramerTest, ProcessSettingsAckFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x00,        // Length: 0
       0x04,                    //   Type: SETTINGS
       0x01,                    //  Flags: ACK
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
   };
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.setting_count_);
   EXPECT_EQ(1, visitor.settings_ack_received_);
 }
 
 TEST_F(SpdyFramerTest, ProcessDataFrameWithPadding) {
   const int kPaddingLen = 119;
   const char data_payload[] = "hello";
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyDataIR data_ir(1, data_payload);
   data_ir.set_padding_len(kPaddingLen);
   SpdySerializedFrame frame(framer.SerializeData(data_ir));
 
   int bytes_consumed = 0;
 
   // Send the frame header.
   EXPECT_CALL(visitor,
@@ skipping 33 matching lines @@
   bytes_consumed += 100;
 
   // Send rest of the padding payload.
   EXPECT_CALL(visitor, OnStreamPadding(1, 18));
   CHECK_EQ(18u, framer.ProcessInput(frame.data() + bytes_consumed, 18));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_READY_FOR_FRAME);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
 }
 
 TEST_F(SpdyFramerTest, ReadWindowUpdate) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdySerializedFrame control_frame(
       framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2)));
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1u, visitor.last_window_update_stream_);
   EXPECT_EQ(2, visitor.last_window_update_delta_);
 }
 
 TEST_F(SpdyFramerTest, ReadCompressedPushPromise) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("foo", "bar");
   push_promise.SetHeader("bar", "foofoo");
   SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size());
   EXPECT_EQ(42u, visitor.last_push_promise_stream_);
   EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_);
   EXPECT_EQ(push_promise.header_block(), visitor.headers_);
 }
 
 TEST_F(SpdyFramerTest, ReadHeadersWithContinuation) {
   // frame-format off
@@ skipping 30 matching lines @@
       'o',  'o',  'k',  'i',  'e',  // Name (continued)
       0x00,                         // Value Len: 0
       0x00,                         // Unindexed Entry
       0x04,                         // Name Len: 4
       'n',  'a',  'm',  'e',        // Name
       0x05,                         // Value Len: 5
       'v',  'a',  'l',  'u',  'e',  // Value
   };
   // frame-format on
 
-  SpdyFramer framer(spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SpdyFramer framer;
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
 
   EXPECT_THAT(
       visitor.headers_,
@@ skipping 34 matching lines @@
       'o',  'o',  'k',  'i',  'e',  // Name (continued)
       0x00,                         // Value Len: 0
       0x00,                         // Unindexed Entry
       0x04,                         // Name Len: 4
       'n',  'a',  'm',  'e',        // Name
       0x05,                         // Value Len: 5
       'v',  'a',  'l',  'u',  'e',  // Value
   };
   // frame-format on
 
-  SpdyFramer framer(spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SpdyFramer framer;
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.fin_flag_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
 
   EXPECT_THAT(
@@ skipping 26 matching lines @@
     0x00, 0x00, 0x12, 0x09,  // CONTINUATION
     0x04, 0x00, 0x00, 0x00,  // END_HEADERS
     0x01, 'o',  'o',  'k',   // Stream 1
     'i',  'e',  0x00, 0x00,
     0x04, 'n',  'a',  'm',
     'e',  0x05, 'v',  'a',
     'l',  'u',  'e',
   };
   // frame-format on
 
-  SpdyFramer framer(spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SpdyFramer framer;
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, visitor.last_push_promise_stream_);
   EXPECT_EQ(42u, visitor.last_push_promise_promised_stream_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
 
   EXPECT_THAT(
@@ skipping 19 matching lines @@
       0xa9,                    //   Type: UnknownFrameType(169)
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // Payload
       0x6f, 0x6b, 0x69, 0x65,  //
       0x08, 0x62, 0x61, 0x7a,  //
       0x3d, 0x62, 0x69, 0x6e,  //
       0x67, 0x00, 0x06, 0x63,  //
   };
 
-  SpdyFramer framer(spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SpdyFramer framer;
+  TestSpdyVisitor visitor;
   // Assume the unknown frame is allowed
   visitor.on_unknown_frame_result_ = true;
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
@@ skipping 15 matching lines @@
       0x09,                    //   Type: CONTINUATION
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x02,  // Stream: 2
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x08, 0x62, 0x61, 0x7a,  //
       0x3d, 0x62, 0x69, 0x6e,  //
       0x67, 0x00, 0x06, 0x63,  //
   };
 
-  SpdyFramer framer(spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SpdyFramer framer;
+  TestSpdyVisitor visitor;
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_F(SpdyFramerTest, ReadContinuationOutOfOrder) {
   const unsigned char kInput[] = {
       0x00, 0x00, 0x18,        // Length: 24
       0x09,                    //   Type: CONTINUATION
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
   };
 
-  SpdyFramer framer(spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SpdyFramer framer;
+  TestSpdyVisitor visitor;
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_F(SpdyFramerTest, ExpectContinuationReceiveData) {
   const unsigned char kInput[] = {
       0x00, 0x00, 0x10,        // Length: 16
       0x01,                    //   Type: HEADERS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
 
       0x00, 0x00, 0x00,        // Length: 0
       0x00,                    //   Type: DATA
       0x01,                    //  Flags: END_STREAM
       0x00, 0x00, 0x00, 0x04,  // Stream: 4
 
       0xde, 0xad, 0xbe, 0xef,  // Truncated Frame Header
   };
 
-  SpdyFramer framer(spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SpdyFramer framer;
+  TestSpdyVisitor visitor;
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
@@ skipping 13 matching lines @@
       0x00, 0x00, 0x10,        // Length: 16
       0x01,                    //   Type: HEADERS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
   };
 
-  SpdyFramer framer(spdy_version_);
-  TestSpdyVisitor visitor(spdy_version_);
+  SpdyFramer framer;
+  TestSpdyVisitor visitor;
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 TEST_F(SpdyFramerTest, ReadGarbage) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   unsigned char garbage_frame[256];
   memset(garbage_frame, ~0, sizeof(garbage_frame));
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(garbage_frame, sizeof(garbage_frame));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_F(SpdyFramerTest, ReadUnknownExtensionFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
 
   // The unrecognized frame type should still have a valid length.
   const unsigned char unknown_frame[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0xff,                    //   Type: UnknownFrameType(255)
       0xff,                    //  Flags: 0xff
       0xff, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff (R-bit set)
       0xff, 0xff, 0xff, 0xff,  // Payload
       0xff, 0xff, 0xff, 0xff,  //
   };
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
 
   // Simulate the case where the stream id validation checks out.
   visitor.on_unknown_frame_result_ = true;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(unknown_frame, arraysize(unknown_frame));
   EXPECT_EQ(0, visitor.error_count_);
 
   // Follow it up with a valid control frame to make sure we handle
   // subsequent frames correctly.
   SpdySettingsIR settings_ir;
-  settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
+  settings_ir.AddSetting(SpdyConstants::ParseSettingId(1),
                          false,  // persist
                          false,  // persisted
                          10);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, static_cast<unsigned>(visitor.setting_count_));
   EXPECT_EQ(1u, static_cast<unsigned>(visitor.settings_ack_sent_));
 }
 
 TEST_F(SpdyFramerTest, ReadGarbageWithValidLength) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0xff,                    //   Type: UnknownFrameType(255)
       0xff,                    //  Flags: 0xff
       0xff, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff (R-bit set)
       0xff, 0xff, 0xff, 0xff,  // Payload
       0xff, 0xff, 0xff, 0xff,  //
   };
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, arraysize(kFrameData));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_F(SpdyFramerTest, ReadGarbageHPACKEncoding) {
   const unsigned char kInput[] = {
       0x00, 0x12, 0x01,        // Length: 4609
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x01, 0xef,  // Stream: 495
       0xef, 0xff,              //  Param: 61439
       0xff, 0xff, 0xff, 0xff,  //  Value: 4294967295
       0xff, 0xff,              //  Param: 0xffff
       0xff, 0xff, 0xff, 0xff,  //  Value: 4294967295
       0xff, 0xff, 0xff, 0xff,  // Settings (Truncated)
       0xff,                    //
   };
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kInput, arraysize(kInput));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_F(SpdyFramerTest, SizesTest) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   EXPECT_EQ(9u, framer.GetDataFrameMinimumSize());
   EXPECT_EQ(9u, framer.GetFrameHeaderSize());
   EXPECT_EQ(13u, framer.GetRstStreamMinimumSize());
   EXPECT_EQ(9u, framer.GetSettingsMinimumSize());
   EXPECT_EQ(17u, framer.GetPingSize());
   EXPECT_EQ(17u, framer.GetGoAwayMinimumSize());
   EXPECT_EQ(9u, framer.GetHeadersMinimumSize());
   EXPECT_EQ(13u, framer.GetWindowUpdateSize());
   EXPECT_EQ(9u, framer.GetBlockedSize());
   EXPECT_EQ(13u, framer.GetPushPromiseMinimumSize());
@@ skipping 104 matching lines @@
 
 TEST_F(SpdyFramerTest, DataFrameFlagsV4) {
   uint8_t valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_PADDED;
 
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdyDataIR data_ir(1, "hello");
     SpdySerializedFrame frame(framer.SerializeData(data_ir));
-    SetFrameFlags(&frame, flags, spdy_version_);
+    SetFrameFlags(&frame, flags);
 
     if (flags & ~valid_data_flags) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
       if (flags & DATA_FLAG_PADDED) {
         // The first byte of payload is parsed as padding length, but 'h'
         // (0x68) is too large a padding length for a 5 byte payload.
         EXPECT_CALL(visitor, OnStreamPadding(_, 1));
         // Expect Error since the frame ends prematurely.
@@ skipping 23 matching lines @@
   } while (++flags != 0);
 }
 
 TEST_F(SpdyFramerTest, RstStreamFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdyRstStreamIR rst_stream(13, RST_STREAM_CANCEL);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
-    SetFrameFlags(&frame, flags, spdy_version_);
+    SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(visitor, OnRstStream(13, RST_STREAM_CANCEL));
 
     framer.ProcessInput(frame.data(), frame.size());
 
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_F(SpdyFramerTest, SettingsFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdySettingsIR settings_ir;
     settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0, 0, 16);
     SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
-    SetFrameFlags(&frame, flags, spdy_version_);
+    SetFrameFlags(&frame, flags);
 
     if (flags & SETTINGS_FLAG_ACK) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnSettings(flags & SETTINGS_FLAG_ACK));
       EXPECT_CALL(visitor, OnSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0, 16));
       EXPECT_CALL(visitor, OnSettingsEnd());
     }
 
     framer.ProcessInput(frame.data(), frame.size());
@@ skipping 11 matching lines @@
   } while (++flags != 0);
 }
 
 TEST_F(SpdyFramerTest, GoawayFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdyGoAwayIR goaway_ir(97, GOAWAY_OK, "test");
     SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
-    SetFrameFlags(&frame, flags, spdy_version_);
+    SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(visitor, OnGoAway(97, GOAWAY_OK));
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_F(SpdyFramerTest, HeadersFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdyHeadersIR headers_ir(57);
     if (flags & HEADERS_FLAG_PRIORITY) {
       headers_ir.set_weight(3);
       headers_ir.set_has_priority(true);
       headers_ir.set_parent_stream_id(5);
       headers_ir.set_exclusive(true);
     }
     headers_ir.SetHeader("foo", "bar");
     SpdySerializedFrame frame(
         SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
     uint8_t set_flags = flags & ~HEADERS_FLAG_PADDED;
-    SetFrameFlags(&frame, set_flags, spdy_version_);
+    SetFrameFlags(&frame, set_flags);
 
     // Expected callback values
     SpdyStreamId stream_id = 57;
     bool has_priority = false;
     SpdyPriority priority = 0;
     SpdyStreamId parent_stream_id = 0;
     bool exclusive = false;
     bool fin = flags & CONTROL_FLAG_FIN;
     bool end = flags & HEADERS_FLAG_END_HEADERS;
     if (flags & HEADERS_FLAG_PRIORITY) {
@@ skipping 22 matching lines @@
   } while (++flags != 0);
 }
 
 TEST_F(SpdyFramerTest, PingFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdySerializedFrame frame(framer.SerializePing(SpdyPingIR(42)));
-    SetFrameFlags(&frame, flags, spdy_version_);
+    SetFrameFlags(&frame, flags);
 
     if (flags & PING_FLAG_ACK) {
       EXPECT_CALL(visitor, OnPing(42, true));
     } else {
       EXPECT_CALL(visitor, OnPing(42, false));
     }
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_F(SpdyFramerTest, WindowUpdateFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdySerializedFrame frame(
         framer.SerializeWindowUpdate(SpdyWindowUpdateIR(4, 1024)));
-    SetFrameFlags(&frame, flags, spdy_version_);
+    SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(visitor, OnWindowUpdate(4, 1024));
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_F(SpdyFramerTest, PushPromiseFrameFlags) {
   const SpdyStreamId client_id = 123;   // Must be odd.
   const SpdyStreamId promised_id = 22;  // Must be even.
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor,
                 OnSendCompressedFrame(client_id, PUSH_PROMISE, _, _));
 
     SpdyPushPromiseIR push_promise(client_id, promised_id);
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     // TODO(jgraettinger): Add padding to SpdyPushPromiseIR,
     // and implement framing.
-    SetFrameFlags(&frame, flags & ~HEADERS_FLAG_PADDED, spdy_version_);
+    SetFrameFlags(&frame, flags & ~HEADERS_FLAG_PADDED);
 
     bool end = flags & PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
     EXPECT_CALL(debug_visitor,
                 OnReceiveCompressedFrame(client_id, PUSH_PROMISE, _));
     EXPECT_CALL(visitor, OnPushPromise(client_id, promised_id, end));
     EXPECT_CALL(visitor, OnHeaderFrameStart(client_id)).Times(1);
     if (end) {
       EXPECT_CALL(visitor, OnHeaderFrameEnd(client_id, _)).Times(1);
     }
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 TEST_F(SpdyFramerTest, ContinuationFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
-    SpdyFramer framer(spdy_version_);
+    SpdyFramer framer;
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, HEADERS, _, _));
     EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, HEADERS, _));
     EXPECT_CALL(visitor, OnHeaders(42, false, 0, 0, false, false, false));
     EXPECT_CALL(visitor, OnHeaderFrameStart(42)).Times(1);
 
     SpdyHeadersIR headers_ir(42);
     headers_ir.SetHeader("foo", "bar");
     SpdySerializedFrame frame0(
         SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
-    SetFrameFlags(&frame0, 0, spdy_version_);
+    SetFrameFlags(&frame0, 0);
 
     SpdyContinuationIR continuation(42);
     SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
-    SetFrameFlags(&frame, flags, spdy_version_);
+    SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, CONTINUATION, _));
     EXPECT_CALL(visitor, OnContinuation(42, flags & HEADERS_FLAG_END_HEADERS));
     bool end = flags & HEADERS_FLAG_END_HEADERS;
     if (end) {
       EXPECT_CALL(visitor, OnHeaderFrameEnd(42, _)).Times(1);
     }
 
     framer.ProcessInput(frame0.data(), frame0.size());
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
         << SpdyFramer::ErrorCodeToString(framer.error_code());
   } while (++flags != 0);
 }
 
 // TODO(mlavan): Add TEST_F(SpdyFramerTest, AltSvcFrameFlags)
 
 // TODO(hkhalil): Add TEST_F(SpdyFramerTest, BlockedFrameFlags)
 
 TEST_F(SpdyFramerTest, SettingsFlagsAndId) {
   const uint32_t kId = 0x020304;
   const uint32_t kFlags = 0x01;
   const uint32_t kWireFormat = base::HostToNet32(0x01020304);
 
   SettingsFlagsAndId id_and_flags =
-      SettingsFlagsAndId::FromWireFormat(spdy_version_, kWireFormat);
+      SettingsFlagsAndId::FromWireFormat(kWireFormat);
   EXPECT_EQ(kId, id_and_flags.id());
   EXPECT_EQ(kFlags, id_and_flags.flags());
-  EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat(spdy_version_));
+  EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat());
 }
 
 // Test handling of a RST_STREAM with out-of-bounds status codes.
 TEST_F(SpdyFramerTest, RstStreamStatusBounds) {
   const unsigned char kH2RstStreamInvalid[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
   };
   const unsigned char kH2RstStreamNumStatusCodes[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0xff,  //  Error: 255
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_NO_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2RstStreamInvalid),
                       arraysize(kH2RstStreamInvalid));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 
   framer.Reset();
 
   EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INTERNAL_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2RstStreamNumStatusCodes),
                       arraysize(kH2RstStreamNumStatusCodes));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test handling of GOAWAY frames with out-of-bounds status code.
 TEST_F(SpdyFramerTest, GoAwayStatusBounds) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x0a,        // Length: 10
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x00, 0x00, 0x01,  //   Last: 1
       0xff, 0xff, 0xff, 0xff,  //  Error: 0xffffffff
       0x47, 0x41,              // Description
   };
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
@@ skipping 12 matching lines @@
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0xff, 0xff, 0xff, 0xff,  //   Last: 0x7fffffff (R-bit set)
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnGoAway(0x7fffffff, GOAWAY_OK));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2FrameData),
                       arraysize(kH2FrameData));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_F(SpdyFramerTest, OnBlocked) {
   const SpdyStreamId kStreamId = 0;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnBlocked(kStreamId));
 
   SpdyBlockedIR blocked_ir(0);
   SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir));
   framer.ProcessInput(frame.data(), framer.GetBlockedSize());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_F(SpdyFramerTest, OnAltSvc) {
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24});
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc1);
   altsvc_vector.push_back(altsvc2);
   EXPECT_CALL(visitor,
               OnAltSvc(kStreamId, StringPiece("o_r|g!n"), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_origin("o_r|g!n");
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_F(SpdyFramerTest, OnAltSvcNoOrigin) {
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24});
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc1);
   altsvc_vector.push_back(altsvc2);
   EXPECT_CALL(visitor, OnAltSvc(kStreamId, StringPiece(""), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_F(SpdyFramerTest, OnAltSvcEmptyProtocolId) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_origin("o1");
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector()));
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "", "h1", 443, 10, SpdyAltSvcWireFormat::VersionVector()));
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_F(SpdyFramerTest, OnAltSvcBadLengths) {
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc(
       "pid", "h1", 443, 10, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc);
   EXPECT_CALL(visitor, OnAltSvc(kStreamId, StringPiece("o1"), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_origin("o1");
   altsvc_ir.add_altsvc(altsvc);
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Tests handling of ALTSVC frames delivered in small chunks.
 TEST_F(SpdyFramerTest, ReadChunkedAltSvcFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdyAltSvcIR altsvc_ir(1);
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24});
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
 
   SpdySerializedFrame control_frame(framer.SerializeAltSvc(altsvc_ir));
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
 
   // Read data in small chunks.
   size_t framed_data = 0;
   size_t unframed_data = control_frame.size();
   size_t kReadChunkSize = 5;  // Read five bytes at a time.
   while (unframed_data > 0) {
     size_t to_read = std::min(kReadChunkSize, unframed_data);
     visitor.SimulateInFramer(
         reinterpret_cast<unsigned char*>(control_frame.data() + framed_data),
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.altsvc_count_);
   ASSERT_EQ(2u, visitor.test_altsvc_ir_.altsvc_vector().size());
   EXPECT_TRUE(visitor.test_altsvc_ir_.altsvc_vector()[0] == altsvc1);
   EXPECT_TRUE(visitor.test_altsvc_ir_.altsvc_vector()[1] == altsvc2);
 }
 
 // Tests handling of PRIORITY frames.
 TEST_F(SpdyFramerTest, ReadPriority) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   SpdyPriorityIR priority(3, 1, 256, false);
   SpdySerializedFrame frame(framer.SerializePriority(priority));
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   framer.set_visitor(&visitor);
   EXPECT_CALL(visitor, OnPriority(3, 1, 256, false));
   framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   // TODO(mlavan): once we actually maintain a priority tree,
   // check that state is adjusted correctly.
 }
 
 // Tests handling of PRIORITY frame with incorrect size.
 TEST_F(SpdyFramerTest, ReadIncorrectlySizedPriority) {
   // PRIORITY frame of size 4, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x02,                    //   Type: PRIORITY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x00, 0x01,  // Priority (Truncated)
   };
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of PING frame with incorrect size.
 TEST_F(SpdyFramerTest, ReadIncorrectlySizedPing) {
   // PING frame of size 4, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x06,                    //   Type: PING
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x00, 0x00, 0x01,  // Ping (Truncated)
   };
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of WINDOW_UPDATE frame with incorrect size.
 TEST_F(SpdyFramerTest, ReadIncorrectlySizedWindowUpdate) {
   // WINDOW_UPDATE frame of size 3, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x03,        // Length: 3
       0x08,                    //   Type: WINDOW_UPDATE
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x01,        // WindowUpdate (Truncated)
   };
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of RST_STREAM frame with incorrect size.
 TEST_F(SpdyFramerTest, ReadIncorrectlySizedRstStream) {
   // RST_STREAM frame of size 3, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x03,        // Length: 3
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x01,        // RstStream (Truncated)
   };
 
-  TestSpdyVisitor visitor(spdy_version_);
+  TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Test that SpdyFramer processes, by default, all passed input in one call
 // to ProcessInput (i.e. will not be calling set_process_single_input_frame()).
 TEST_F(SpdyFramerTest, ProcessAllInput) {
-  SpdyFramer framer(spdy_version_);
-  std::unique_ptr<TestSpdyVisitor> visitor(new TestSpdyVisitor(spdy_version_));
+  SpdyFramer framer;
+  std::unique_ptr<TestSpdyVisitor> visitor(new TestSpdyVisitor);
   framer.set_visitor(visitor.get());
 
   // Create two input frames.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
   SpdySerializedFrame headers_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
@@ skipping 27 matching lines @@
   EXPECT_EQ(1, visitor->headers_frame_count_);
   EXPECT_EQ(1, visitor->data_frame_count_);
   EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
 }
 
 // Test that SpdyFramer stops after processing a full frame if
 // process_single_input_frame is set. Input to ProcessInput has two frames, but
 // only processes the first when we give it the first frame split at any point,
 // or give it more than one frame in the input buffer.
 TEST_F(SpdyFramerTest, ProcessAtMostOneFrame) {
-  SpdyFramer framer(spdy_version_);
+  SpdyFramer framer;
   framer.set_process_single_input_frame(true);
   std::unique_ptr<TestSpdyVisitor> visitor;
 
   // Create two input frames.
   const char four_score[] = "Four score and ...";
   SpdyDataIR four_score_ir(1, four_score);
   SpdySerializedFrame four_score_frame(framer.SerializeData(four_score_ir));
 
   SpdyHeadersIR headers(2);
   headers.SetHeader("alpha", "beta");
@@ skipping 17 matching lines @@
   input_buffer.append(frame1.data(), frame1_size);
   input_buffer.append(frame2.data(), frame2_size);
 
   const char* buf = input_buffer.data();
   const size_t buf_size = input_buffer.size();
 
   VLOG(1) << "buf_size = " << buf_size;
 
   for (size_t first_size = 0; first_size <= buf_size; ++first_size) {
     VLOG(1) << "first_size = " << first_size;
-    visitor.reset(new TestSpdyVisitor(spdy_version_));
+    visitor.reset(new TestSpdyVisitor);
     framer.set_visitor(visitor.get());
 
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
 
     size_t processed_first = framer.ProcessInput(buf, first_size);
     if (first_size < frame1_size) {
       EXPECT_EQ(first_size, processed_first);
 
       if (first_size == 0) {
         EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
@@ skipping 22 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net