Remove SPDY/2 code.

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 662 matching lines @@
                      const SpdyFrame& expected_frame,
                      const SpdyFrame& 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());
   }
 
-  bool IsSpdy2() { return spdy_version_ == SPDY2; }
   bool IsSpdy3() { return spdy_version_ == SPDY3; }
   bool IsHttp2() { return spdy_version_ == HTTP2; }
 
   // 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, HTTP/2.
+// All tests are run with SPDY/3 and HTTP/2.
 INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
                         SpdyFramerTest,
-                        ::testing::Values(SPDY2, SPDY3, HTTP2));
+                        ::testing::Values(SPDY3, HTTP2));
 
 // 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 201 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.WriteStringPiece16("name");
-    frame.WriteStringPiece16("value1");
-    frame.WriteStringPiece16("name");
-    frame.WriteStringPiece16("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());
   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.WriteStringPiece16("name");
-    frame.WriteStringPiece16(value);
-  } else if (spdy_version_ > SPDY3) {
+  if (spdy_version_ > SPDY3) {
     // 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());
   } 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(99u, compressed_size4);
+  EXPECT_EQ(99u, 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(99u, 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(kH2Input, sizeof(kH2Input));
   }
 
   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 (IsHttp2()) {
     EXPECT_EQ(3, visitor.headers_frame_count_);
     EXPECT_EQ(0, visitor.syn_frame_count_);
     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(kH2Input, sizeof(kH2Input));
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   if (IsHttp2()) {
     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(kH2Input, sizeof(kH2Input));
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   if (IsHttp2()) {
     EXPECT_EQ(0, visitor.syn_frame_count_);
     EXPECT_EQ(0, visitor.syn_reply_frame_count_);
     EXPECT_EQ(2, visitor.headers_frame_count_);
@@ skipping 125 matching lines @@
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   EXPECT_EQ(1, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrame) {
   SpdyFramer framer(spdy_version_);
   scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
       SpdyWindowUpdateIR(1, 0x12345678)));
 
   const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678";
-  const unsigned char kV3FrameData[] = {  // Also applies for V2.
+  const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x09,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x12, 0x34, 0x56, 0x78
   };
   const unsigned char kH2FrameData[] = {
     0x00, 0x00, 0x04, 0x08,
     0x00, 0x00, 0x00, 0x00,
     0x01, 0x12, 0x34, 0x56,
     0x78
   };
 
   if (IsHttp2()) {
     CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
   } else {
     CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateDataFrame) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "'hello' data frame, no FIN";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
     const unsigned char kH2FrameData[] = {0x00,
                                           0x00,
                                           0x05,
                                           0x00,
                                           0x00,
@@ skipping 23 matching lines @@
         data_header_ir));
     CompareCharArraysWithHexError(
         kDescription, reinterpret_cast<const unsigned char*>(frame->data()),
         framer.GetDataFrameMinimumSize(),
         IsHttp2() ? kH2FrameData : kV3FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "'hello' data frame with more padding, no FIN";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
 
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0xfd, 0x00,      // Length = 253.  PADDED set.
       0x08, 0x00, 0x00, 0x00,
       0x01, 0xf7,                  // Pad length field.
@@ skipping 39 matching lines @@
     frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
     CompareCharArraysWithHexError(
         kDescription, reinterpret_cast<const unsigned char*>(frame->data()),
         framer.GetDataFrameMinimumSize(),
         IsHttp2() ? kH2FrameData : kV3FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "'hello' data frame with few padding, no FIN";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
 
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x0d, 0x00,      // Length = 13.  PADDED set.
       0x08, 0x00, 0x00, 0x00,
       0x01, 0x07,                  // Pad length field.
@@ skipping 12 matching lines @@
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "'hello' data frame with 1 byte padding, no FIN";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
 
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x06, 0x00,      // Length = 6.  PADDED set.
       0x08, 0x00, 0x00, 0x00,
       0x01, 0x00,                  // Pad length field.
@@ skipping 17 matching lines @@
     frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
     CompareCharArraysWithHexError(
         kDescription, reinterpret_cast<const unsigned char*>(frame->data()),
         framer.GetDataFrameMinimumSize(),
         IsHttp2() ? kH2FrameData : kV3FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "Data frame with negative data byte, no FIN";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
       0xff
     };
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff};
     SpdyDataIR data_ir(1, "\xff");
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsHttp2()) {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "'hello' data frame, with FIN";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x05,
       'h', 'e', 'l', 'l',
       'o'
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05, 0x00,
       0x01, 0x00, 0x00, 0x00,
       0x01, 'h',  'e',  'l',
       'l',  'o'
     };
     SpdyDataIR data_ir(1, "hello");
     data_ir.set_fin(true);
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsHttp2()) {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "Empty data frame";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x00,
+    const unsigned char kV3FrameData[] = {
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00,
       0x01,
     };
     SpdyDataIR data_ir(1, "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
     if (IsHttp2()) {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
        CompareFrame(
            kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
 
     frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
     CompareCharArraysWithHexError(
         kDescription, reinterpret_cast<const unsigned char*>(frame->data()),
         framer.GetDataFrameMinimumSize(),
         IsHttp2() ? kH2FrameData : kV3FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "Data frame with max stream ID";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x7f, 0xff, 0xff, 0xff,
       0x01, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05, 0x00,
       0x01, 0x7f, 0xff, 0xff,
       0xff, 'h',  'e',  'l',
       'l',  'o'
@@ skipping 27 matching lines @@
     memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
 
     SpdyDataIR data_ir(1, kData);
     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 (!IsSpdy3()) {
     // SYN_STREAM unsupported in SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "SYN_STREAM frame, lowest pri, no FIN";
 
-    const unsigned char kPri = IsSpdy2() ? 0xC0 : 0xE0;
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x20,
-      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 kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x2a,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
-      kPri, 0x00, 0x00, 0x00,
+      0xE0, 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()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header name, highest pri, FIN, "
         "max stream ID";
 
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      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()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header val, high pri, FIN, "
         "max stream ID";
 
-    const unsigned char kPri = IsSpdy2() ? 0x40 : 0x20;
-    const unsigned char kV2FrameData[] = {
-      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 kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x27,
       0x7f, 0xff, 0xff, 0xff,
       0x7f, 0xff, 0xff, 0xff,
-      kPri, 0x00, 0x00, 0x00,
+      0x20, 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()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynStreamCompressed) {
-  if (!IsSpdy2() && !IsSpdy3()) {
+  if (!IsSpdy3()) {
     // SYN_STREAM not supported for SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] =
         "SYN_STREAM frame, low pri, no FIN";
-    const SpdyPriority priority = IsSpdy2() ? 2 : 4;
 
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      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.set_priority(4);
     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 (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.";
     }
   }
 }
 #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()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header name, FIN, max stream ID";
 
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      0x01, 0x00, 0x00, 0x19,
-      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()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header val, FIN, max stream ID";
 
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      0x01, 0x00, 0x00, 0x19,
-      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()) {
+    if (IsSpdy3()) {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynReplyCompressed) {
   if (spdy_version_ > SPDY3) {
     // SYN_REPLY unsupported in SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] = "SYN_REPLY frame, no FIN";
 
-    const unsigned char kV2FrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      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 (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.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "RST_STREAM frame";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0x00,
         0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
     };
     SpdyRstStreamIR rst_stream(1, RST_STREAM_PROTOCOL_ERROR);
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     if (IsHttp2()) {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max stream ID";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x03,
       0x00, 0x7f, 0xff, 0xff,
       0xff, 0x00, 0x00, 0x00,
       0x01,
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF, RST_STREAM_PROTOCOL_ERROR);
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     if (IsHttp2()) {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max status code";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x06,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x03,
       0x00, 0x7f, 0xff, 0xff,
       0xff, 0x00, 0x00, 0x00,
       0x02,
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF, RST_STREAM_INTERNAL_ERROR);
     scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
     if (IsHttp2()) {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
       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 kH2FrameData[] = {
       0x00, 0x00, 0x06, 0x04,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x04, 0x0a,
       0x0b, 0x0c, 0x0d,
     };
 
     uint32_t kValue = 0x0a0b0c0d;
     SpdySettingsIR settings_ir;
 
     SpdySettingsFlags kFlags = static_cast<SpdySettingsFlags>(0x01);
     SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE;
     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, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     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, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "Empty SETTINGS frame";
 
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
       0x00,
     };
     SpdySettingsIR settings_ir;
     scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
     if (IsHttp2()) {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreatePingFrame) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "PING frame";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x06,
       0x00, 0x00, 0x00, 0x04,
       0x12, 0x34, 0x56, 0x78,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x08, 0x06,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x12, 0x34, 0x56,
       0x78, 0x9a, 0xbc, 0xde,
       0xff,
@@ skipping 25 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 kH2FrameData[] = {
       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, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     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 kH2FrameData[] = {
       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, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 }
 
 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 kH2FrameData[] = {
        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, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     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 kH2FrameData[] = {
       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, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     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 kH2FrameData[] = {
       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, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID, pri";
 
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x14, 0x01,  // Headers: FIN | END_HEADERS | PRIORITY
         0x25, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
         0xff, 0x00, 0x00, 0x00,  // exclusive, 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()) {
+    if (IsSpdy3()) {
       // HEADERS with priority not supported.
     } else {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID, pri, "
         "exclusive=true, parent_stream=0";
@@ skipping 10 matching lines @@
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.set_priority(1);
     headers_ir.set_has_priority(true);
     headers_ir.set_exclusive(true);
     headers_ir.set_parent_stream_id(0);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
-    if (IsSpdy2() || IsSpdy3()) {
+    if (IsSpdy3()) {
       // HEADERS with priority not supported.
     } else {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID, pri, "
         "exclusive=false, parent_stream=max stream ID";
@@ skipping 10 matching lines @@
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.set_priority(1);
     headers_ir.set_has_priority(true);
     headers_ir.set_exclusive(false);
     headers_ir.set_parent_stream_id(0x7fffffff);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
-    if (IsSpdy2() || IsSpdy3()) {
+    if (IsSpdy3()) {
       // HEADERS with priority not supported.
     } else {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header name, FIN, max stream ID, padded";
 
     const unsigned char kH2FrameData[] = {
         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()) {
+    if (IsSpdy3()) {
       // Padding is not supported.
     } else {
       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_P(SpdyFramerTest, CreateHeadersCompressed) {
   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 (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.
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateWindowUpdate) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x08,
       0x00, 0x00, 0x00, 0x00,
       0x01, 0x00, 0x00, 0x00,
       0x01,
     };
     scoped_ptr<SpdyFrame> frame(
         framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 1)));
     if (IsHttp2()) {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame with max stream ID";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x08,
       0x00, 0x7f, 0xff, 0xff,
       0xff, 0x00, 0x00, 0x00,
       0x01,
     };
     scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
         SpdyWindowUpdateIR(0x7FFFFFFF, 1)));
     if (IsHttp2()) {
       CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
     } else {
       CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     }
   }
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame with max window delta";
-    const unsigned char kV3FrameData[] = {  // Also applies for V2.
+    const unsigned char kV3FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x7f, 0xff, 0xff, 0xff,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x08,
       0x00, 0x00, 0x00, 0x00,
       0x01, 0x7f, 0xff, 0xff,
       0xff,
@@ skipping 648 matching lines @@
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameSizesAreValidated) {
   SpdyFramer framer(spdy_version_);
   // 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;
-  const unsigned char kV3FrameData[] = {  // Also applies for V2.
+  const unsigned char kV3FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x07,
     0x00, 0x00, 0x00, static_cast<unsigned char>(length),
     0x00, 0x00, 0x00, 0x00,  // Stream ID
     0x00, 0x00, 0x00, 0x00,  // Status
   };
 
   // SPDY version 4 and up GOAWAY frames are only bound to a minimal length,
   // since it may carry opaque data. Verify that minimal length is tested.
   ASSERT_GT(framer.GetGoAwayMinimumSize(), framer.GetControlFrameHeaderSize());
   const size_t less_than_min_length =
@@ skipping 119 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 kH2FrameData[] = {
     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(kH2FrameData, sizeof(kH2FrameData));
   }
 
   if (!IsHttp2()) {
     EXPECT_EQ(1, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // 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_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 kH2FrameData[] = {
     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(kH2FrameData, sizeof(kH2FrameData));
   }
 
   if (!IsHttp2()) {
     EXPECT_EQ(0, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // 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_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 kH2FrameData[] = {
     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(kH2FrameData, sizeof(kH2FrameData));
   }
 
   if (!IsHttp2()) {
     EXPECT_EQ(1, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In HTTP/2, settings are allowed in any order.
@@ skipping 561 matching lines @@
     EXPECT_EQ(9u, framer.GetBlockedSize());
     EXPECT_EQ(13u, framer.GetPushPromiseMinimumSize());
     EXPECT_EQ(11u, 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 223 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       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_P(SpdyFramerTest, SynStreamFrameFlags) {
-  if (!IsSpdy2() && !IsSpdy3()) {
+  if (!IsSpdy3()) {
     // SYN_STREAM not supported in SPDY>3
     return;
   }
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer(spdy_version_);
@@ skipping 33 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       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_P(SpdyFramerTest, SynReplyFrameFlags) {
-  if (!IsSpdy2() && !IsSpdy3()) {
+  if (!IsSpdy3()) {
     // SYN_REPLY not supported in SPDY>3
     return;
   }
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
@@ skipping 441 matching lines @@
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 // TODO(mlavan): Add TEST_P(SpdyFramerTest, AltSvcFrameFlags)
 
 // TODO(hkhalil): Add TEST_P(SpdyFramerTest, BlockedFrameFlags)
 
 TEST_P(SpdyFramerTest, EmptySynStream) {
-  if (!IsSpdy2() && !IsSpdy3()) {
+  if (!IsSpdy3()) {
     // SYN_STREAM not supported in SPDY>3.
     return;
   }
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   testing::StrictMock<test::MockDebugVisitor> debug_visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
   framer.set_debug_visitor(&debug_visitor);
 
   EXPECT_CALL(debug_visitor, OnSendCompressedFrame(1, SYN_STREAM, _, _));
@@ skipping 13 matching lines @@
 
   framer.ProcessInput(frame->data(), framer.GetSynStreamMinimumSize());
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
   const uint32_t kId = 0x020304;
   const uint32_t kFlags = 0x01;
-  const uint32_t kWireFormat =
-      base::HostToNet32(IsSpdy2() ? 0x04030201 : 0x01020304);
+  const uint32_t kWireFormat = base::HostToNet32(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_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_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 kH2FrameData[] = {
     0x00, 0x00, 0x0a, 0x07,
@@ skipping 14 matching lines @@
     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());
 }
 
 // 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 kH2FrameData[] = {
     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*>(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());
 }
@@ skipping 377 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