Remove SPDY2 and SPDY/3.0 from tests.

net/spdy/spdy_framer_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 652 matching lines @@
         LOG(ERROR) << "Expected header named '" << it->first
                    << "' to have a value of '" << it->second
                    << "'. The actual value received was '" << it2->second
                    << "'.";
         return false;
       }
     }
     return true;
   }
 
-  bool IsSpdy2() { return spdy_version_ == SPDY2; }

[Ryan Hamilton, 2014/11/10 23:08:27]

Have these changes been made server side too?

   bool IsSpdy3() { return spdy_version_ == SPDY3; }
   bool IsSpdy4() { return spdy_version_ == SPDY4; }
   bool IsSpdy5() { return spdy_version_ == SPDY5; }
 
   // Version of SPDY protocol to be used.
   SpdyMajorVersion spdy_version_;
   unsigned char spdy_version_ch_;
 };
 
-// All tests are run with 3 different SPDY versions: SPDY/2, SPDY/3, SPDY/4.
 INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
                         SpdyFramerTest,
-                        ::testing::Values(SPDY2, SPDY3, SPDY4));
+                        ::testing::Values(SPDY3, SPDY4));
 
 // Test that we ignore cookie where both name and value are empty.
 TEST_P(SpdyFramerTest, HeaderBlockWithEmptyCookie) {
   if (spdy_version_ > SPDY3) {
     // Not implemented for hpack.
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
@@ skipping 171 matching lines @@
   if (spdy_version_ <= SPDY3) {
     frame.WriteControlFrameHeader(framer, SYN_STREAM, CONTROL_FLAG_NONE);
     frame.WriteUInt32(3);  // stream_id
     frame.WriteUInt32(0);  // associated stream id
     frame.WriteUInt16(0);  // Priority.
   } else {
     frame.BeginNewFrame(framer, HEADERS, HEADERS_FLAG_PRIORITY, 3);
     frame.WriteUInt32(framer.GetHighestPriority());
   }
 
-  if (IsSpdy2()) {
-    frame.WriteUInt16(2);  // Number of headers.
-    frame.WriteString("name");
-    frame.WriteString("value1");
-    frame.WriteString("name");
-    frame.WriteString("value2");
-  } else {
-    frame.WriteUInt32(2);  // Number of headers.
-    frame.WriteStringPiece32("name");
-    frame.WriteStringPiece32("value1");
-    frame.WriteStringPiece32("name");
-    frame.WriteStringPiece32("value2");
-  }
+  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);
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   base::StringPiece serialized_headers =
       GetSerializedHeaders(control_frame.get(), framer);
   // This should fail because duplicate headers are verboten by the spec.
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
@@ skipping 13 matching lines @@
   } else {
     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);
-  if (IsSpdy2()) {
-    frame.WriteUInt16(1);  // Number of headers.
-    frame.WriteString("name");
-    frame.WriteString(value);
-  } else if (spdy_version_ > SPDY3) {
+  if (spdy_version_ > SPDY3) {
     // TODO(jgraettinger): If this pattern appears again, move to test class.
     std::map<string, string> header_set;
     header_set["name"] = value;
     string buffer;
     HpackEncoder encoder(ObtainHpackHuffmanTable());
     encoder.EncodeHeaderSetWithoutCompression(header_set, &buffer);
     frame.WriteBytes(&buffer[0], buffer.size());
   } else {
     frame.WriteUInt32(1);  // Number of headers.
     frame.WriteStringPiece32("name");
@@ skipping 28 matching lines @@
   syn_stream.SetHeader("server", "SpdyServer 1.0");
   syn_stream.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
   syn_stream.SetHeader("status", "200");
   syn_stream.SetHeader("version", "HTTP/1.1");
   syn_stream.SetHeader("content-type", "text/html");
   syn_stream.SetHeader("content-length", "12");
   scoped_ptr<SpdyFrame> frame1(framer.SerializeSynStream(syn_stream));
   size_t uncompressed_size1 = visitor->last_payload_len_;
   size_t compressed_size1 =
       visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
-  if (IsSpdy2()) {
-    EXPECT_EQ(139u, uncompressed_size1);
+  EXPECT_EQ(165u, uncompressed_size1);
 #if defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(155u, compressed_size1);
+  EXPECT_EQ(181u, compressed_size1);
 #else  // !defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(135u, compressed_size1);
+  EXPECT_EQ(117u, compressed_size1);
 #endif  // !defined(USE_SYSTEM_ZLIB)
-  } else {
-    EXPECT_EQ(165u, uncompressed_size1);
-#if defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(181u, compressed_size1);
-#else  // !defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(117u, compressed_size1);
-#endif  // !defined(USE_SYSTEM_ZLIB)
-  }
   scoped_ptr<SpdyFrame> frame2(framer.SerializeSynStream(syn_stream));
   size_t uncompressed_size2 = visitor->last_payload_len_;
   size_t compressed_size2 =
       visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
 
   // Expect the second frame to be more compact than the first.
   EXPECT_LE(frame2->size(), frame1->size());
 
   // Decompress the first frame
   scoped_ptr<SpdyFrame> frame3(
       SpdyFramerTestUtil::DecompressFrame(&framer, *frame1));
 
   // Decompress the second frame
   visitor.reset(new TestSpdyVisitor(spdy_version_));
   framer.set_debug_visitor(visitor.get());
   scoped_ptr<SpdyFrame> frame4(
       SpdyFramerTestUtil::DecompressFrame(&framer, *frame2));
   size_t uncompressed_size4 =
       frame4->size() - framer.GetSynStreamMinimumSize();
   size_t compressed_size4 =
       visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
-  if (IsSpdy2()) {
-    EXPECT_EQ(139u, uncompressed_size4);
+  EXPECT_EQ(165u, uncompressed_size4);
 #if defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(149u, compressed_size4);
+  EXPECT_EQ(175u, compressed_size4);
 #else  // !defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(101u, compressed_size4);
+  EXPECT_EQ(102u, compressed_size4);
 #endif  // !defined(USE_SYSTEM_ZLIB)
-  } else {
-    EXPECT_EQ(165u, uncompressed_size4);
-#if defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(175u, compressed_size4);
-#else  // !defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(102u, compressed_size4);
-#endif  // !defined(USE_SYSTEM_ZLIB)
-  }
 
   EXPECT_EQ(uncompressed_size1, uncompressed_size2);
   EXPECT_EQ(uncompressed_size1, uncompressed_size4);
   EXPECT_EQ(compressed_size2, compressed_size4);
 
   // Expect frames 3 & 4 to be the same.
   CompareFrames("Uncompressed SYN_STREAM", *frame3, *frame4);
 
   // Expect frames 3 to be the same as a uncompressed frame created
   // from scratch.
@@ skipping 13 matching lines @@
   headers.SetHeader("content-type", "text/html");
   headers.SetHeader("content-length", "12");
   headers.SetHeader("x-empty-header", "");
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
   scoped_ptr<SpdyFrame> frame1(framer.SerializeHeaders(headers));
 }
 
 TEST_P(SpdyFramerTest, Basic) {
-  const unsigned char kV2Input[] = {
-    0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #1
-    0x00, 0x00, 0x00, 0x14,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x02, 'h', 'h',
-    0x00, 0x02, 'v', 'v',
-
-    0x80, spdy_version_ch_, 0x00, 0x08,  // HEADERS on Stream #1
-    0x00, 0x00, 0x00, 0x18,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x02,
-    0x00, 0x02, 'h', '2',
-    0x00, 0x02, 'v', '2',
-    0x00, 0x02, 'h', '3',
-    0x00, 0x02, 'v', '3',
-
-    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
-    0x00, 0x00, 0x00, 0x0c,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
-
-    0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #3
-    0x00, 0x00, 0x00, 0x0c,
-    0x00, 0x00, 0x00, 0x03,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-
-    0x00, 0x00, 0x00, 0x03,           // DATA on Stream #3
-    0x00, 0x00, 0x00, 0x08,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
-
-    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
-    0x00, 0x00, 0x00, 0x04,
-    0xde, 0xad, 0xbe, 0xef,
-
-    0x80, spdy_version_ch_, 0x00, 0x03,  // RST_STREAM on Stream #1
-    0x00, 0x00, 0x00, 0x08,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x05,           // RST_STREAM_CANCEL
-
-    0x00, 0x00, 0x00, 0x03,           // DATA on Stream #3
-    0x00, 0x00, 0x00, 0x00,
-
-    0x80, spdy_version_ch_, 0x00, 0x03,  // RST_STREAM on Stream #3
-    0x00, 0x00, 0x00, 0x08,
-    0x00, 0x00, 0x00, 0x03,
-    0x00, 0x00, 0x00, 0x05,           // RST_STREAM_CANCEL
-  };
-
   const unsigned char kV3Input[] = {
     0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x1a,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
     0x00, 0x02, 'h', 'h',
     0x00, 0x00, 0x00, 0x02,
     'v', 'v',
@@ skipping 92 matching lines @@
 
     0x00, 0x00, 0x0f, 0x03,           // RST_STREAM on Stream #3
     0x00, 0x00, 0x00, 0x00,
     0x03, 0x00, 0x00, 0x00,           // RST_STREAM_CANCEL
     0x08, 0x52, 0x45, 0x53,           // opaque data
     0x45, 0x54, 0x53, 0x54,
     0x52, 0x45, 0x41, 0x4d,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
-  if (IsSpdy2()) {
-    visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
-  } else if (IsSpdy3()) {
+  if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   } else {
     visitor.SimulateInFramer(kV4Input, sizeof(kV4Input));
   }
 
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(24, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.fin_frame_count_);
 
   if (IsSpdy4()) {
     EXPECT_EQ(3, visitor.headers_frame_count_);
     EXPECT_EQ(0, visitor.syn_frame_count_);
     base::StringPiece reset_stream = "RESETSTREAM";
     EXPECT_EQ(reset_stream, visitor.fin_opaque_data_);
   } else {
     EXPECT_EQ(1, visitor.headers_frame_count_);
     EXPECT_EQ(2, visitor.syn_frame_count_);
     EXPECT_TRUE(visitor.fin_opaque_data_.empty());
   }
 
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(4, visitor.data_frame_count_);
   visitor.fin_opaque_data_.clear();
 }
 
 // Test that the FIN flag on a data frame signifies EOF.
 TEST_P(SpdyFramerTest, FinOnDataFrame) {
-  const unsigned char kV2Input[] = {
-    0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #1
-    0x00, 0x00, 0x00, 0x14,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x02, 'h', 'h',
-    0x00, 0x02, 'v', 'v',
-
-    0x80, spdy_version_ch_, 0x00, 0x02,  // SYN REPLY Stream #1
-    0x00, 0x00, 0x00, 0x10,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x00, 0x00, 0x01,
-    0x00, 0x02, 'a', 'a',
-    0x00, 0x02, 'b', 'b',
-
-    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1
-    0x00, 0x00, 0x00, 0x0c,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef,
-
-    0x00, 0x00, 0x00, 0x01,           // DATA on Stream #1, with EOF
-    0x01, 0x00, 0x00, 0x04,
-    0xde, 0xad, 0xbe, 0xef,
-  };
   const unsigned char kV3Input[] = {
     0x80, spdy_version_ch_, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x1a,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
     0x00, 0x02, 'h', 'h',
     0x00, 0x00, 0x00, 0x02,
     'v',  'v',
@@ skipping 36 matching lines @@
     0xef, 0xde, 0xad, 0xbe,
     0xef,
 
     0x00, 0x00, 0x04, 0x00,           // DATA on Stream #1, with FIN
     0x01, 0x00, 0x00, 0x00,
     0x01, 0xde, 0xad, 0xbe,
     0xef,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
-  if (IsSpdy2()) {
-    visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
-  } else if (IsSpdy3()) {
+  if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   } else {
     visitor.SimulateInFramer(kV4Input, sizeof(kV4Input));
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   if (IsSpdy4()) {
     EXPECT_EQ(0, visitor.syn_frame_count_);
     EXPECT_EQ(0, visitor.syn_reply_frame_count_);
     EXPECT_EQ(2, visitor.headers_frame_count_);
   } else {
     EXPECT_EQ(1, visitor.syn_frame_count_);
     EXPECT_EQ(1, visitor.syn_reply_frame_count_);
     EXPECT_EQ(0, visitor.headers_frame_count_);
   }
   EXPECT_EQ(16, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(2, visitor.data_frame_count_);
 }
 
 // Test that the FIN flag on a SYN reply frame signifies EOF.
 TEST_P(SpdyFramerTest, FinOnSynReplyFrame) {
-  const unsigned char kV2Input[] = {
-    0x80, spdy_version_ch_, 0x00,  // SYN Stream #1
-    0x01, 0x00, 0x00, 0x00,
-    0x14, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x02, 'h',
-    'h',  0x00, 0x02, 'v',
-    'v',
-
-    0x80, spdy_version_ch_, 0x00,  // SYN REPLY Stream #1
-    0x02, 0x01, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x00, 0x00,
-    0x01, 0x00, 0x02, 'a',
-    'a',  0x00, 0x02, 'b',
-    'b',
-  };
   const unsigned char kV3Input[] = {
     0x80, spdy_version_ch_, 0x00,  // SYN Stream #1
     0x01, 0x00, 0x00, 0x00,
     0x1a, 0x00, 0x00, 0x00,
     0x01, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x01, 0x00,
     0x00, 0x00, 0x02, 'h',
     'h',  0x00, 0x00, 0x00,
     0x02, 'v', 'v',
@@ skipping 15 matching lines @@
     0x24, 0x00, 0x00, 0x00,
     0x01, 0x00, 0x00, 0x00,           // Stream 1, Priority 0
     0x00, 0x82,                       // :method: GET
 
     0x00, 0x00, 0x01, 0x01,           // HEADERS: FIN | END_HEADERS
     0x05, 0x00, 0x00, 0x00,
     0x01, 0x8c,                       // Stream 1, :status: 200
   };
 
   TestSpdyVisitor visitor(spdy_version_);
-  if (IsSpdy2()) {
-    visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
-  } else if (IsSpdy3()) {
+  if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
   } else {
     visitor.SimulateInFramer(kV4Input, sizeof(kV4Input));
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   if (IsSpdy4()) {
     EXPECT_EQ(0, visitor.syn_frame_count_);
     EXPECT_EQ(0, visitor.syn_reply_frame_count_);
     EXPECT_EQ(2, visitor.headers_frame_count_);
@@ skipping 452 matching lines @@
     memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
 
     SpdyDataIR data_ir(1, StringPiece(kData.data(), kData.size()));
     data_ir.set_fin(true);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     CompareFrame(kDescription, *frame, expected_frame_data.get(), kFrameSize);
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) {
-  if (!IsSpdy2() && !IsSpdy3()) {
+  if (spdy_version_ > SPDY3) {
     // SYN_STREAM unsupported in SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_STREAM frame, lowest pri, no FIN";
-
-    const unsigned char kPri = IsSpdy2() ? 0xC0 : 0xE0;
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x20,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x00,
-      kPri, 0x00, 0x00, 0x02,
-      0x00, 0x03, 'b',  'a',
-      'r',  0x00, 0x03, 'f',
-      'o',  'o',  0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x03, 'b',  'a',  'r'
-    };
+    const unsigned char kPri = 0xE0;
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x2a,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
       kPri, 0x00, 0x00, 0x00,
       0x00, 0x02, 0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r',  0x00, 0x00, 0x00,
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'b',
       'a',  'r'
     };
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(framer.GetLowestPriority());
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
-    } else {
-      LOG(FATAL) << "Unsupported version in test.";
-    }
+    CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header name, highest pri, FIN, "
         "max stream ID";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      0x01, 0x00, 0x00, 0x1D,
-      0x7f, 0xff, 0xff, 0xff,
-      0x7f, 0xff, 0xff, 0xff,
-      0x00, 0x00, 0x00, 0x02,
-      0x00, 0x00, 0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x03, 'f',  'o',  'o',
-      0x00, 0x03, 'b',  'a',
-      'r'
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x27,
       0x7f, 0xff, 0xff, 0xff,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x02, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r'
     };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(framer.GetHighestPriority());
     syn_stream.set_fin(true);
     syn_stream.SetHeader("", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
-    } else {
-      LOG(FATAL) << "Unsupported version in test.";
-    }
+    CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header val, high pri, FIN, "
         "max stream ID";
-
-    const unsigned char kPri = IsSpdy2() ? 0x40 : 0x20;
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      0x01, 0x00, 0x00, 0x1D,
-      0x7f, 0xff, 0xff, 0xff,
-      0x7f, 0xff, 0xff, 0xff,
-      kPri, 0x00, 0x00, 0x02,
-      0x00, 0x03, 'b',  'a',
-      'r',  0x00, 0x03, 'f',
-      'o',  'o',  0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x00
-    };
+    const unsigned char kPri = 0x20;
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x27,
       0x7f, 0xff, 0xff, 0xff,
       0x7f, 0xff, 0xff, 0xff,
       kPri, 0x00, 0x00, 0x00,
       0x00, 0x02, 0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r',  0x00, 0x00, 0x00,
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x00
     };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(1);
     syn_stream.set_fin(true);
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
-    } else {
-      LOG(FATAL) << "Unsupported version in test.";
-    }
+    CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynStreamCompressed) {
-  if (!IsSpdy2() && !IsSpdy3()) {
+  if (spdy_version_ > SPDY3) {
     // SYN_STREAM not supported for SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] =
         "SYN_STREAM frame, low pri, no FIN";
-    const SpdyPriority priority = IsSpdy2() ? 2 : 4;
+    const SpdyPriority priority = 4;
 
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x36,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x00,
-      0x80, 0x00, 0x38, 0xea,
-      0xdf, 0xa2, 0x51, 0xb2,
-      0x62, 0x60, 0x62, 0x60,
-      0x4e, 0x4a, 0x2c, 0x62,
-      0x60, 0x06, 0x08, 0xa0,
-      0xb4, 0xfc, 0x7c, 0x80,
-      0x00, 0x62, 0x60, 0x4e,
-      0xcb, 0xcf, 0x67, 0x60,
-      0x06, 0x08, 0xa0, 0xa4,
-      0xc4, 0x22, 0x80, 0x00,
-      0x02, 0x00, 0x00, 0x00,
-      0xff, 0xff,
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x37,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
       0x80, 0x00, 0x38, 0xEA,
       0xE3, 0xC6, 0xA7, 0xC2,
       0x02, 0xE5, 0x0E, 0x50,
       0xC2, 0x4B, 0x4A, 0x04,
       0xE5, 0x0B, 0x66, 0x80,
       0x00, 0x4A, 0xCB, 0xCF,
       0x07, 0x08, 0x20, 0x10,
       0x95, 0x96, 0x9F, 0x0F,
       0xA2, 0x00, 0x02, 0x28,
       0x29, 0xB1, 0x08, 0x20,
       0x80, 0x00, 0x00, 0x00,
       0x00, 0xFF, 0xFF,
     };
-    const unsigned char kV2SIMDFrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x33,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x00,
-      0x80, 0x00, 0x38, 0xea,
-      0xdf, 0xa2, 0x51, 0xb2,
-      0x62, 0x60, 0x62, 0x60,
-      0x4e, 0x4a, 0x2c, 0x62,
-      0x60, 0x06, 0x08, 0xa0,
-      0xb4, 0xfc, 0x7c, 0x80,
-      0x00, 0x62, 0x60, 0x06,
-      0x13, 0x00, 0x01, 0x94,
-      0x94, 0x58, 0x04, 0x10,
-      0x40, 0x00, 0x00, 0x00,
-      0x00, 0xff, 0xff,
-    };
     const unsigned char kV3SIMDFrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x32,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
       0x80, 0x00, 0x38, 0xea,
       0xe3, 0xc6, 0xa7, 0xc2,
       0x02, 0xe5, 0x0e, 0x50,
       0xc2, 0x4b, 0x4a, 0x04,
       0xe5, 0x0b, 0x66, 0x80,
       0x00, 0x4a, 0xcb, 0xcf,
       0x07, 0x08, 0x20, 0x24,
       0x0a, 0x20, 0x80, 0x92,
       0x12, 0x8b, 0x00, 0x02,
       0x08, 0x00, 0x00, 0x00,
       0xff, 0xff,
     };
 
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(priority);
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
     const unsigned char* frame_data =
         reinterpret_cast<const unsigned char*>(frame->data());
-    if (IsSpdy2()) {
-      // Try comparing with SIMD version, if that fails, do a failing check
-      // with pretty printing against non-SIMD version
-      if (memcmp(frame_data,
-                 kV2SIMDFrameData,
-                 std::min(arraysize(kV2SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV2FrameData,
-                                      arraysize(kV2FrameData));
-      }
-    } else if (IsSpdy3()) {
-      if (memcmp(frame_data,
-                 kV3SIMDFrameData,
-                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV3FrameData,
-                                      arraysize(kV3FrameData));
-      }
-    } else {
-      LOG(FATAL) << "Unsupported version in test.";
+    if (memcmp(frame_data,
+               kV3SIMDFrameData,
+               std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
+      CompareCharArraysWithHexError(kDescription,
+                                    frame_data,
+                                    frame->size(),
+                                    kV3FrameData,
+                                    arraysize(kV3FrameData));
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) {
   if (spdy_version_ > SPDY3) {
     // SYN_REPLY unsupported in SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      0x00, 0x00, 0x00, 0x1C,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x02,
-      0x00, 0x03, 'b',  'a',
-      'r',  0x00, 0x03, 'f',
-      'o',  'o',  0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x03, 'b',  'a',  'r'
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x24,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x03, 'b',  'a',  'r'
     };
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
-    } else {
-      LOG(FATAL) << "Unsupported version in test.";
-    }
+    CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header name, FIN, max stream ID";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      0x01, 0x00, 0x00, 0x19,
-      0x7f, 0xff, 0xff, 0xff,
-      0x00, 0x00, 0x00, 0x02,
-      0x00, 0x00, 0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x03, 'f',  'o',  'o',
-      0x00, 0x03, 'b',  'a',
-      'r'
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x01, 0x00, 0x00, 0x21,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r'
     };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
-    } else {
-      LOG(FATAL) << "Unsupported version in test.";
-    }
+    CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header val, FIN, max stream ID";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      0x01, 0x00, 0x00, 0x19,
-      0x7f, 0xff, 0xff, 0xff,
-      0x00, 0x00, 0x00, 0x02,
-      0x00, 0x03, 'b',  'a',
-      'r',  0x00, 0x03, 'f',
-      'o',  'o',  0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x00
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x01, 0x00, 0x00, 0x21,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x00
     };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
-    } else {
-      LOG(FATAL) << "Unsupported version in test.";
-    }
+    CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynReplyCompressed) {
   if (spdy_version_ > SPDY3) {
     // SYN_REPLY unsupported in SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      0x00, 0x00, 0x00, 0x32,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x38, 0xea,
-      0xdf, 0xa2, 0x51, 0xb2,
-      0x62, 0x60, 0x62, 0x60,
-      0x4e, 0x4a, 0x2c, 0x62,
-      0x60, 0x06, 0x08, 0xa0,
-      0xb4, 0xfc, 0x7c, 0x80,
-      0x00, 0x62, 0x60, 0x4e,
-      0xcb, 0xcf, 0x67, 0x60,
-      0x06, 0x08, 0xa0, 0xa4,
-      0xc4, 0x22, 0x80, 0x00,
-      0x02, 0x00, 0x00, 0x00,
-      0xff, 0xff,
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x31,
       0x00, 0x00, 0x00, 0x01,
       0x38, 0xea, 0xe3, 0xc6,
       0xa7, 0xc2, 0x02, 0xe5,
       0x0e, 0x50, 0xc2, 0x4b,
       0x4a, 0x04, 0xe5, 0x0b,
       0x66, 0x80, 0x00, 0x4a,
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x10, 0x95, 0x96,
       0x9f, 0x0f, 0xa2, 0x00,
       0x02, 0x28, 0x29, 0xb1,
       0x08, 0x20, 0x80, 0x00,
       0x00, 0x00, 0x00, 0xff,
       0xff,
     };
-    const unsigned char kV2SIMDFrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      0x00, 0x00, 0x00, 0x2f,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x38, 0xea,
-      0xdf, 0xa2, 0x51, 0xb2,
-      0x62, 0x60, 0x62, 0x60,
-      0x4e, 0x4a, 0x2c, 0x62,
-      0x60, 0x06, 0x08, 0xa0,
-      0xb4, 0xfc, 0x7c, 0x80,
-      0x00, 0x62, 0x60, 0x06,
-      0x13, 0x00, 0x01, 0x94,
-      0x94, 0x58, 0x04, 0x10,
-      0x40, 0x00, 0x00, 0x00,
-      0x00, 0xff, 0xff,
-    };
     const unsigned char kV3SIMDFrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x2c,
       0x00, 0x00, 0x00, 0x01,
       0x38, 0xea, 0xe3, 0xc6,
       0xa7, 0xc2, 0x02, 0xe5,
       0x0e, 0x50, 0xc2, 0x4b,
       0x4a, 0x04, 0xe5, 0x0b,
       0x66, 0x80, 0x00, 0x4a,
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x24, 0x0a, 0x20,
       0x80, 0x92, 0x12, 0x8b,
       0x00, 0x02, 0x08, 0x00,
       0x00, 0x00, 0xff, 0xff,
     };
 
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
     const unsigned char* frame_data =
         reinterpret_cast<const unsigned char*>(frame->data());
-    if (IsSpdy2()) {
-      // Try comparing with SIMD version, if that fails, do a failing check
-      // with pretty printing against non-SIMD version
-      if (memcmp(frame_data,
-                 kV2SIMDFrameData,
-                 std::min(arraysize(kV2SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV2FrameData,
-                                      arraysize(kV2FrameData));
-      }
-    } else if (IsSpdy3()) {
-      if (memcmp(frame_data,
-                 kV3SIMDFrameData,
-                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV3FrameData,
-                                      arraysize(kV3FrameData));
-      }
-    } else {
-      LOG(FATAL) << "Unsupported version in test.";
+    if (memcmp(frame_data,
+               kV3SIMDFrameData,
+               std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
+      CompareCharArraysWithHexError(kDescription,
+                                    frame_data,
+                                    frame->size(),
+                                    kV3FrameData,
+                                    arraysize(kV3FrameData));
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "RST_STREAM frame";
@@ skipping 67 matching lines @@
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSettings) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "Network byte order SETTINGS frame";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x04,
-      0x00, 0x00, 0x00, 0x0c,
-      0x00, 0x00, 0x00, 0x01,
-      0x07, 0x00, 0x00, 0x01,
-      0x0a, 0x0b, 0x0c, 0x0d,
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x0c,
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x07,
       0x0a, 0x0b, 0x0c, 0x0d,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x00, 0x06, 0x04,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x04, 0x0a,
       0x0b, 0x0c, 0x0d,
     };
 
     uint32 kValue = 0x0a0b0c0d;
     SpdySettingsIR settings_ir;
 
     SpdySettingsFlags kFlags = static_cast<SpdySettingsFlags>(0x01);
     SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE;
     SettingsMap settings;
     settings[kId] = SettingsFlagsAndValue(kFlags, kValue);
     EXPECT_EQ(kFlags, settings[kId].first);
     EXPECT_EQ(kValue, settings[kId].second);
     settings_ir.AddSetting(kId,
                            kFlags & SETTINGS_FLAG_PLEASE_PERSIST,
                            kFlags & SETTINGS_FLAG_PERSISTED,
                            kValue);
 
     scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 
   {
     const char kDescription[] = "Basic SETTINGS frame";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x04,
-      0x00, 0x00, 0x00, 0x24,
-      0x00, 0x00, 0x00, 0x04,
-      0x01, 0x00, 0x00, 0x00,  // 1st Setting
-      0x00, 0x00, 0x00, 0x05,
-      0x02, 0x00, 0x00, 0x00,  // 2nd Setting
-      0x00, 0x00, 0x00, 0x06,
-      0x03, 0x00, 0x00, 0x00,  // 3rd Setting
-      0x00, 0x00, 0x00, 0x07,
-      0x04, 0x00, 0x00, 0x00,  // 4th Setting
-      0x00, 0x00, 0x00, 0x08,
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x24,
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x01,  // 1st Setting
       0x00, 0x00, 0x00, 0x05,
       0x00, 0x00, 0x00, 0x02,  // 2nd Setting
       0x00, 0x00, 0x00, 0x06,
       0x00, 0x00, 0x00, 0x03,  // 3rd Setting
       0x00, 0x00, 0x00, 0x07,
@@ skipping 28 matching lines @@
     settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 3),
                            false,  // persist
                            false,  // persisted
                            7);
     settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 4),
                            false,  // persist
                            false,  // persisted
                            8);
     scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
 
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 
   {
     const char kDescription[] = "Empty SETTINGS frame";
-
     const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
       0x00,
     };
@@ skipping 51 matching lines @@
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreateGoAway) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "GOAWAY frame";
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x07,
-      0x00, 0x00, 0x00, 0x04,
-      0x00, 0x00, 0x00, 0x00,  // Stream Id
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x00,  // Stream Id
       0x00, 0x00, 0x00, 0x00,  // Status
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x00, 0x0a, 0x07,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00,  // Stream id
       0x00, 0x00, 0x00, 0x00,  // Status
       0x00, 0x47, 0x41,        // Opaque Description
     };
     SpdyGoAwayIR goaway_ir(0, GOAWAY_OK, "GA");
     scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 
   {
     const char kDescription[] = "GOAWAY frame with max stream ID, status";
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x07,
-      0x00, 0x00, 0x00, 0x04,
-      0x7f, 0xff, 0xff, 0xff,  // Stream Id
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,  // Stream Id
       0x00, 0x00, 0x00, 0x01,  // Status: PROTOCOL_ERROR.
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x00, 0x0a, 0x07,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x7f, 0xff, 0xff,  // Stream Id
       0xff, 0x00, 0x00, 0x00,  // Status: INTERNAL_ERROR.
       0x02, 0x47, 0x41,        // Opaque Description
     };
     SpdyGoAwayIR goaway_ir(0x7FFFFFFF, GOAWAY_INTERNAL_ERROR, "GA");
     scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x08,
-      0x00, 0x00, 0x00, 0x1C,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x02,
-      0x00, 0x03, 'b',  'a',
-      'r',  0x00, 0x03, 'f',
-      'o',  'o',  0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x03, 'b',  'a',  'r'
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x24,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x03, 'b',  'a',  'r'
     };
     const unsigned char kV4FrameData[] = {
        0x00, 0x00, 0x12, 0x01,  // Headers: END_HEADERS
        0x04, 0x00, 0x00, 0x00,  // Stream 1
        0x01, 0x00, 0x03, 0x62,  // @.ba
        0x61, 0x72, 0x03, 0x66,  // r.fo
        0x6f, 0x6f, 0x00, 0x03,  // o@.f
        0x66, 0x6f, 0x6f, 0x03,  // oo.b
        0x62, 0x61, 0x72,        // ar
     };
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header name, FIN, max stream ID";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x08,
-      0x01, 0x00, 0x00, 0x19,
-      0x7f, 0xff, 0xff, 0xff,
-      0x00, 0x00, 0x00, 0x02,
-      0x00, 0x00, 0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x03, 'f',  'o',  'o',
-      0x00, 0x03, 'b',  'a',
-      'r'
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x08,
       0x01, 0x00, 0x00, 0x21,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r'
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x00, 0x0f, 0x01,  // Headers: FIN | END_HEADERS
       0x05, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
       0xff, 0x00, 0x00, 0x03,  // @..
       0x66, 0x6f, 0x6f, 0x00,  // foo@
       0x03, 0x66, 0x6f, 0x6f,  // .foo
       0x03, 0x62, 0x61, 0x72,  // .bar
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.SetHeader("", "foo");
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x08,
-      0x01, 0x00, 0x00, 0x19,
-      0x7f, 0xff, 0xff, 0xff,
-      0x00, 0x00, 0x00, 0x02,
-      0x00, 0x03, 'b',  'a',
-      'r',  0x00, 0x03, 'f',
-      'o',  'o',  0x00, 0x03,
-      'f',  'o',  'o',  0x00,
-      0x00
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x08,
       0x01, 0x00, 0x00, 0x21,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x00
     };
     const unsigned char kV4FrameData[] = {
       0x00, 0x00, 0x0f, 0x01,  // Headers: FIN | END_HEADERS
       0x05, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
       0xff, 0x00, 0x03, 0x62,  // @.b
       0x61, 0x72, 0x03, 0x66,  // ar.f
       0x6f, 0x6f, 0x00, 0x03,  // oo@.
       0x66, 0x6f, 0x6f, 0x00,  // foo.
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
      headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
-    if (IsSpdy2()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
-    } else if (IsSpdy3()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID, pri";
-
     const unsigned char kV4FrameData[] = {
       0x00, 0x00, 0x14, 0x01,  // Headers: FIN | END_HEADERS | PRIORITY
       0x25, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
       0xff, 0x00, 0x00, 0x00,  // parent stream
       0x00, 0xdb,              // weight
       0x00, 0x03, 0x62, 0x61,  // @.ba
       0x72, 0x03, 0x66, 0x6f,  // r.fo
       0x6f, 0x00, 0x03, 0x66,  // o@.f
       0x6f, 0x6f, 0x00,        // oo.
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.set_priority(1);
     headers_ir.set_has_priority(true);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
-    if (IsSpdy2() || IsSpdy3()) {
-      // HEADERS with priority not supported.
-    } else {
+    if (spdy_version_ > SPDY3) {
+      // HEADERS with priority only supported in SPDY>3.
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header name, FIN, max stream ID, padded";
-
     const unsigned char kV4FrameData[] = {
         0x00, 0x00, 0x15, 0x01,  // Headers
         0x0d, 0x7f, 0xff, 0xff,  // FIN | END_HEADERS | PADDED, Stream
                                  // 0x7fffffff
         0xff, 0x05, 0x00, 0x00,  // Pad length field
         0x03, 0x66, 0x6f, 0x6f,  // .foo
         0x00, 0x03, 0x66, 0x6f,  // @.fo
         0x6f, 0x03, 0x62, 0x61,  // o.ba
         0x72,                    // r
         // Padding payload
         0x00, 0x00, 0x00, 0x00, 0x00,
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.SetHeader("", "foo");
     headers_ir.SetHeader("foo", "bar");
     headers_ir.set_padding_len(6);
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
-    if (IsSpdy2() || IsSpdy3()) {
-      // Padding is not supported.
-    } else {
+    if (spdy_version_ > SPDY3) {
+      // Padding only supported in SPDY>3.
       CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateHeadersCompressed) {
+  if (spdy_version_ > SPDY3) {
+    // Deflate compression doesn't apply to HPACK.
+    return;
+  }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
-
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x08,
-      0x00, 0x00, 0x00, 0x32,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x38, 0xea,
-      0xdf, 0xa2, 0x51, 0xb2,
-      0x62, 0x60, 0x62, 0x60,
-      0x4e, 0x4a, 0x2c, 0x62,
-      0x60, 0x06, 0x08, 0xa0,
-      0xb4, 0xfc, 0x7c, 0x80,
-      0x00, 0x62, 0x60, 0x4e,
-      0xcb, 0xcf, 0x67, 0x60,
-      0x06, 0x08, 0xa0, 0xa4,
-      0xc4, 0x22, 0x80, 0x00,
-      0x02, 0x00, 0x00, 0x00,
-      0xff, 0xff,
-    };
     const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x31,
       0x00, 0x00, 0x00, 0x01,
       0x38, 0xea, 0xe3, 0xc6,
       0xa7, 0xc2, 0x02, 0xe5,
       0x0e, 0x50, 0xc2, 0x4b,
       0x4a, 0x04, 0xe5, 0x0b,
       0x66, 0x80, 0x00, 0x4a,
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x10, 0x95, 0x96,
       0x9f, 0x0f, 0xa2, 0x00,
       0x02, 0x28, 0x29, 0xb1,
       0x08, 0x20, 0x80, 0x00,
       0x00, 0x00, 0x00, 0xff,
       0xff,
     };
-    const unsigned char kV2SIMDFrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x08,
-      0x00, 0x00, 0x00, 0x2f,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x38, 0xea,
-      0xdf, 0xa2, 0x51, 0xb2,
-      0x62, 0x60, 0x62, 0x60,
-      0x4e, 0x4a, 0x2c, 0x62,
-      0x60, 0x06, 0x08, 0xa0,
-      0xb4, 0xfc, 0x7c, 0x80,
-      0x00, 0x62, 0x60, 0x06,
-      0x13, 0x00, 0x01, 0x94,
-      0x94, 0x58, 0x04, 0x10,
-      0x40, 0x00, 0x00, 0x00,
-      0x00, 0xff, 0xff,
-    };
     const unsigned char kV3SIMDFrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x2c,
       0x00, 0x00, 0x00, 0x01,
       0x38, 0xea, 0xe3, 0xc6,
       0xa7, 0xc2, 0x02, 0xe5,
       0x0e, 0x50, 0xc2, 0x4b,
       0x4a, 0x04, 0xe5, 0x0b,
       0x66, 0x80, 0x00, 0x4a,
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x24, 0x0a, 0x20,
       0x80, 0x92, 0x12, 0x8b,
       0x00, 0x02, 0x08, 0x00,
       0x00, 0x00, 0xff, 0xff,
     };
 
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
     const unsigned char* frame_data =
         reinterpret_cast<const unsigned char*>(frame->data());
-    if (IsSpdy2()) {
-      // Try comparing with SIMD version, if that fails, do a failing check
-      // with pretty printing against non-SIMD version
-      if (memcmp(frame_data,
-                 kV2SIMDFrameData,
-                 std::min(arraysize(kV2SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV2FrameData,
-                                      arraysize(kV2FrameData));
-      }
-    } else if (IsSpdy3()) {
-      if (memcmp(frame_data,
-                 kV3SIMDFrameData,
-                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV3FrameData,
-                                      arraysize(kV3FrameData));
-      }
-    } else {
-      // Deflate compression doesn't apply to HPACK.
+    if (memcmp(frame_data,
+               kV3SIMDFrameData,
+               std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
+      CompareCharArraysWithHexError(kDescription,
+                                    frame_data,
+                                    frame->size(),
+                                    kV3FrameData,
+                                    arraysize(kV3FrameData));
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateWindowUpdate) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame";
@@ skipping 106 matching lines @@
 TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   {
     // Test framing PUSH_PROMISE without padding.
     SpdyFramer framer(spdy_version_);
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame without padding";
-
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0x16, 0x05,  // PUSH_PROMISE
         0x04, 0x00, 0x00, 0x00,  // END_HEADERS
         0x2a, 0x00, 0x00, 0x00,  // Stream 42
         0x39, 0x00, 0x03, 0x62,  // Promised stream 57, @.b
         0x61, 0x72, 0x03, 0x66,  // ar.f
         0x6f, 0x6f, 0x00, 0x03,  // oo@.
         0x66, 0x6f, 0x6f, 0x03,  // foo.
         0x62, 0x61, 0x72,        // bar
     };
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
     scoped_ptr<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_);
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame with one byte of padding";
-
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0x17, 0x05,  // PUSH_PROMISE
         0x0c, 0x00, 0x00, 0x00,  // END_HEADERS | PADDED
         0x2a, 0x00, 0x00, 0x00,  // Stream 42, Pad length field
         0x00, 0x39, 0x00, 0x03,  // Promised stream 57
         0x62, 0x61, 0x72, 0x03,  // bar.
         0x66, 0x6f, 0x6f, 0x00,  // foo@
         0x03, 0x66, 0x6f, 0x6f,  // .foo
         0x03, 0x62, 0x61, 0x72,  // .bar
     };
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.set_padding_len(1);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
     scoped_ptr<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_);
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame with 177 bytes of padding";
-
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0xc7, 0x05,  // PUSH_PROMISE
         0x0c, 0x00, 0x00, 0x00,  // END_HEADERS | PADDED
         0x2a, 0xb0, 0x00, 0x00,  // Stream 42, Pad length field
         0x00, 0x39, 0x00, 0x03,  // Promised stream 57
         0x62, 0x61, 0x72, 0x03,  // bar.
         0x66, 0x6f, 0x6f, 0x00,  // foo@
         0x03, 0x66, 0x6f, 0x6f,  // .foo
         0x03, 0x62, 0x61, 0x72,  // .bar
         // Padding of 176 0x00(s).
@@ skipping 25 matching lines @@
 }
 
 TEST_P(SpdyFramerTest, CreateContinuationUncompressed) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   const char kDescription[] = "CONTINUATION frame";
-
   const unsigned char kFrameData[] = {
      0x00, 0x00, 0x12, 0x09, 0x00,  // CONTINUATION
      0x00, 0x00, 0x00, 0x2a,  // Stream 42
      0x00, 0x03, 0x62, 0x61,  // @.ba
      0x72, 0x03, 0x66, 0x6f,  // r.fo
      0x6f, 0x00, 0x03, 0x66,  // o@.f
      0x6f, 0x6f, 0x03, 0x62,  // oo.b
      0x61, 0x72,              // ar
   };
 
@@ skipping 11 matching lines @@
   }
 
   {
     // 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_);
     framer.set_enable_compression(false);
     const char kDescription[] =
         "PUSH_PROMISE and CONTINUATION frames with one byte of padding";
-
     const unsigned char kPartialPushPromiseFrameData[] = {
         0x00, 0x03, 0xf7, 0x05,  // PUSH_PROMISE
         0x08, 0x00, 0x00, 0x00,  // PADDED
         0x2a, 0x00, 0x00, 0x00,  // Stream 42
         0x00, 0x39, 0x00, 0x03,  // Promised stream 57
         0x78, 0x78, 0x78, 0x7f,  // xxx.
         0x81, 0x07, 0x78, 0x78,  // ..xx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
@@ skipping 571 matching lines @@
   EXPECT_EQ(3 * 2, visitor.setting_count_);
   if (spdy_version_ > SPDY3) {
     EXPECT_EQ(2, visitor.settings_ack_sent_);
   }
 }
 
 // Tests handling of SETTINGS frame with duplicate entries.
 TEST_P(SpdyFramerTest, ReadDuplicateSettings) {
   SpdyFramer framer(spdy_version_);
 
-  const unsigned char kV2FrameData[] = {
-    0x80, spdy_version_ch_, 0x00, 0x04,
-    0x00, 0x00, 0x00, 0x1C,
-    0x00, 0x00, 0x00, 0x03,
-    0x01, 0x00, 0x00, 0x00,  // 1st Setting
-    0x00, 0x00, 0x00, 0x02,
-    0x01, 0x00, 0x00, 0x00,  // 2nd (duplicate) Setting
-    0x00, 0x00, 0x00, 0x03,
-    0x03, 0x00, 0x00, 0x00,  // 3rd (unprocessed) Setting
-    0x00, 0x00, 0x00, 0x03,
-  };
   const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x04,
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x01,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x01,  // 2nd (duplicate) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
   const unsigned char kV4FrameData[] = {
     0x00, 0x00, 0x12, 0x04,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x01,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x01,  // 2nd (duplicate) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
-  if (IsSpdy2()) {
-    visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
-  } else if (IsSpdy3()) {
+  if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
   } else {
     visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
   }
 
   if (!IsSpdy4()) {
     EXPECT_EQ(1, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In SPDY 4+, 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_P(SpdyFramerTest, ReadUnknownSettingsId) {
   SpdyFramer framer(spdy_version_);
 
-  const unsigned char kV2FrameData[] = {
-    0x80, spdy_version_ch_, 0x00, 0x04,
-    0x00, 0x00, 0x00, 0x1C,
-    0x00, 0x00, 0x00, 0x01,
-    0x10, 0x00, 0x00, 0x00,  // 1st Setting
-    0x00, 0x00, 0x00, 0x02,
-  };
   const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x04,
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x10,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
   };
   const unsigned char kV4FrameData[] = {
     0x00, 0x00, 0x06, 0x04,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x10,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
-  if (IsSpdy2()) {
-    visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
-  } else if (IsSpdy3()) {
+  if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
   } else {
     visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
   }
 
   if (!IsSpdy4()) {
     EXPECT_EQ(0, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In SPDY 4+, 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_P(SpdyFramerTest, ReadOutOfOrderSettings) {
   SpdyFramer framer(spdy_version_);
 
-  const unsigned char kV2FrameData[] = {
-    0x80, spdy_version_ch_, 0x00, 0x04,
-    0x00, 0x00, 0x00, 0x1C,
-    0x00, 0x00, 0x00, 0x03,
-    0x02, 0x00, 0x00, 0x00,  // 1st Setting
-    0x00, 0x00, 0x00, 0x02,
-    0x01, 0x00, 0x00, 0x00,  // 2nd (out of order) Setting
-    0x00, 0x00, 0x00, 0x03,
-    0x03, 0x00, 0x00, 0x00,  // 3rd (unprocessed) Setting
-    0x00, 0x00, 0x00, 0x03,
-  };
   const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x04,
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x00, 0x02,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x01,  // 2nd (out of order) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x00, 0x01, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
   const unsigned char kV4FrameData[] = {
     0x00, 0x00, 0x12, 0x04,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x02,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
     0x00, 0x01,  // 2nd (out of order) Setting
     0x00, 0x00, 0x00, 0x03,
     0x00, 0x03,  // 3rd (unprocessed) Setting
     0x00, 0x00, 0x00, 0x03,
   };
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
-  if (IsSpdy2()) {
-    visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
-  } else if (IsSpdy3()) {
+  if (IsSpdy3()) {
     visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
   } else {
     visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
   }
 
   if (!IsSpdy4()) {
     EXPECT_EQ(1, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In SPDY 4+, settings are allowed in any order.
@@ skipping 92 matching lines @@
       framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2)));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_EQ(1u, visitor.last_window_update_stream_);
   EXPECT_EQ(2u, visitor.last_window_update_delta_);
 }
 
 TEST_P(SpdyFramerTest, ReceiveCredentialFrame) {
-  if (!IsSpdy3()) {
+  if (spdy_version_ > SPDY3) {
     return;
   }
   SpdyFramer framer(spdy_version_);
   const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x0A,
       0x00, 0x00, 0x00, 0x33,
       0x00, 0x03, 0x00, 0x00,
       0x00, 0x05, 'p',  'r',
       'o',  'o',  'f',  0x00,
       0x00, 0x00, 0x06, 'a',
       ' ',  'c',  'e',  'r',
       't',  0x00, 0x00, 0x00,
       0x0C, 'a',  'n',  'o',
       't',  'h',  'e',  'r',
       ' ',  'c',  'e',  'r',
       't',  0x00, 0x00, 0x00,
       0x0A, 'f',  'i',  'n',
       'a',  'l',  ' ',  'c',
       'e',  'r',  't',
   };
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kV3FrameData, arraysize(kV3FrameData));
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, ReadCredentialFrameFollowedByAnotherFrame) {
-  if (!IsSpdy3()) {
+  if (spdy_version_ > SPDY3) {
     return;
   }
   SpdyFramer framer(spdy_version_);
   const unsigned char kV3FrameData[] = {  // Also applies for V2.
       0x80, spdy_version_ch_, 0x00, 0x0A,
       0x00, 0x00, 0x00, 0x33,
       0x00, 0x03, 0x00, 0x00,
       0x00, 0x05, 'p',  'r',
       'o',  'o',  'f',  0x00,
       0x00, 0x00, 0x06, 'a',
@@ skipping 482 matching lines @@
     EXPECT_EQ(9u, framer.GetBlockedSize());
     EXPECT_EQ(13u, framer.GetPushPromiseMinimumSize());
     EXPECT_EQ(18u, framer.GetAltSvcMinimumSize());
     EXPECT_EQ(9u, framer.GetFrameMinimumSize());
     EXPECT_EQ(16393u, framer.GetFrameMaximumSize());
     EXPECT_EQ(16384u, framer.GetDataFrameMaximumPayload());
   } else {
     EXPECT_EQ(8u, framer.GetDataFrameMinimumSize());
     EXPECT_EQ(8u, framer.GetControlFrameHeaderSize());
     EXPECT_EQ(18u, framer.GetSynStreamMinimumSize());
-    EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetSynReplyMinimumSize());
+    EXPECT_EQ(12u, framer.GetSynReplyMinimumSize());
     EXPECT_EQ(16u, framer.GetRstStreamMinimumSize());
     EXPECT_EQ(12u, framer.GetSettingsMinimumSize());
     EXPECT_EQ(12u, framer.GetPingSize());
-    EXPECT_EQ(IsSpdy2() ? 12u : 16u, framer.GetGoAwayMinimumSize());
-    EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetHeadersMinimumSize());
+    EXPECT_EQ(16u, framer.GetGoAwayMinimumSize());
+    EXPECT_EQ(12u, framer.GetHeadersMinimumSize());
     EXPECT_EQ(16u, framer.GetWindowUpdateSize());
     EXPECT_EQ(8u, framer.GetFrameMinimumSize());
     EXPECT_EQ(16777223u, framer.GetFrameMaximumSize());
     EXPECT_EQ(16777215u, framer.GetDataFrameMaximumPayload());
   }
 }
 
 TEST_P(SpdyFramerTest, StateToStringTest) {
   EXPECT_STREQ("ERROR",
                SpdyFramer::StateToString(SpdyFramer::SPDY_ERROR));
@@ skipping 222 matching lines @@
             << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 TEST_P(SpdyFramerTest, SynStreamFrameFlags) {
-  if (!IsSpdy2() && !IsSpdy3()) {
+  if (spdy_version_ > SPDY3) {
     // SYN_STREAM not supported in SPDY>3
     return;
   }
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
@@ skipping 33 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 TEST_P(SpdyFramerTest, SynReplyFrameFlags) {
-  if (!IsSpdy2() && !IsSpdy3()) {
+  if (spdy_version_ > SPDY3) {
     // SYN_REPLY not supported in SPDY>3
     return;
   }
   for (int flags = 0; flags < 256; ++flags) {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
@@ skipping 427 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   }
 }
 
 // TODO(mlavan): Add TEST_P(SpdyFramerTest, AltSvcFrameFlags)
 
 // TODO(hkhalil): Add TEST_P(SpdyFramerTest, BlockedFrameFlags)
 
 TEST_P(SpdyFramerTest, EmptySynStream) {
-  if (!IsSpdy2() && !IsSpdy3()) {
+  if (spdy_version_ > SPDY3) {
     // SYN_STREAM not supported in SPDY>3.
     return;
   }
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   testing::StrictMock<test::MockDebugVisitor> debug_visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
   framer.set_debug_visitor(&debug_visitor);
 
   EXPECT_CALL(debug_visitor, OnSendCompressedFrame(1, SYN_STREAM, _, _));
@@ skipping 13 matching lines @@
 
   framer.ProcessInput(frame->data(), framer.GetSynStreamMinimumSize());
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
   const uint32 kId = 0x020304;
   const uint32 kFlags = 0x01;
-  const uint32 kWireFormat = htonl(IsSpdy2() ? 0x04030201 : 0x01020304);
+  const uint32 kWireFormat = htonl(0x01020304);
 
   SettingsFlagsAndId id_and_flags =
       SettingsFlagsAndId::FromWireFormat(spdy_version_, kWireFormat);
   EXPECT_EQ(kId, id_and_flags.id());
   EXPECT_EQ(kFlags, id_and_flags.flags());
   EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat(spdy_version_));
 }
 
 // Test handling of a RST_STREAM with out-of-bounds status codes.
 TEST_P(SpdyFramerTest, RstStreamStatusBounds) {
@@ skipping 56 matching lines @@
         reinterpret_cast<const char*>(kV3RstStreamNumStatusCodes),
         arraysize(kV3RstStreamNumStatusCodes));
   }
   EXPECT_EQ(SpdyFramer::SPDY_RESET, 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_P(SpdyFramerTest, GoAwayStatusBounds) {
-  if (spdy_version_ <= SPDY2) {
-    return;
-  }
   SpdyFramer framer(spdy_version_);
 
   const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x07,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,  // Stream Id
     0xff, 0xff, 0xff, 0xff,  // Status
   };
   const unsigned char kV4FrameData[] = {
     0x00, 0x00, 0x0a, 0x07,
@@ skipping 14 matching lines @@
     framer.ProcessInput(reinterpret_cast<const char*>(kV4FrameData),
                         arraysize(kV4FrameData));
   }
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Tests handling of a GOAWAY frame with out-of-bounds stream ID.
 TEST_P(SpdyFramerTest, GoAwayStreamIdBounds) {
-  const unsigned char kV2FrameData[] = {
-    0x80, spdy_version_ch_, 0x00, 0x07,
-    0x00, 0x00, 0x00, 0x04,
-    0xff, 0xff, 0xff, 0xff,
-  };
   const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x07,
     0x00, 0x00, 0x00, 0x08,
     0xff, 0xff, 0xff, 0xff,
     0x00, 0x00, 0x00, 0x00,
   };
   const unsigned char kV4FrameData[] = {
     0x00, 0x00, 0x08, 0x07,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0xff, 0xff, 0xff,
     0xff, 0x00, 0x00, 0x00,
     0x00,
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnGoAway(0x7fffffff, GOAWAY_OK));
-  if (IsSpdy2()) {
-    framer.ProcessInput(reinterpret_cast<const char*>(kV2FrameData),
-                        arraysize(kV2FrameData));
-  } else if (IsSpdy3()) {
+  if (IsSpdy3()) {
     framer.ProcessInput(reinterpret_cast<const char*>(kV3FrameData),
                         arraysize(kV3FrameData));
   } else {
     framer.ProcessInput(reinterpret_cast<const char*>(kV4FrameData),
                         arraysize(kV4FrameData));
   }
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
@@ skipping 290 matching lines @@
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 }  // namespace net