Removing QUIC's VERSION_6, now that QUIC no longer needs to support the

net/quic/quic_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 <map>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 25 matching lines @@
 const QuicPacketSequenceNumber kEpoch = GG_UINT64_C(1) << 48;
 const QuicPacketSequenceNumber kMask = kEpoch - 1;
 
 // Index into the flags offset in the header.
 const size_t kPublicFlagsOffset = 0;
 // Index into the guid offset in the header.
 const size_t kGuidOffset = kPublicFlagsSize;
 // Index into the version string in the header. (if present).
 const size_t kVersionOffset = kGuidOffset + PACKET_8BYTE_GUID;
 
-// Size in bytes of the stream frame fields for an arbitrary StreamID and
-// offset and the last frame in a packet.
 // Index into the sequence number offset in the header.
 size_t GetSequenceNumberOffset(QuicGuidLength guid_length,
                                bool include_version) {
   return kGuidOffset + guid_length +
       (include_version ? kQuicVersionSize : 0);
 }
 
 size_t GetSequenceNumberOffset(bool include_version) {
   return GetSequenceNumberOffset(PACKET_8BYTE_GUID, include_version);
 }
@@ skipping 356 matching lines @@
 
   test::TestEncrypter* encrypter_;
   test::TestDecrypter* decrypter_;
   QuicVersion version_;
   QuicTime start_;
   QuicFramer framer_;
   test::TestQuicVisitor visitor_;
   test::TestEntropyCalculator entropy_calculator_;
 };
 
-// Run all framer tests with QUIC version 6 and 7.
+// Run all framer tests with all supported versions of QUIC.
 INSTANTIATE_TEST_CASE_P(QuicFramerTests,
                         QuicFramerTest,
-                        ::testing::Values(QUIC_VERSION_6, QUIC_VERSION_7));
+                        ::testing::ValuesIn(kSupportedQuicVersions));
 
 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearEpochStart) {
   // A few quick manual sanity checks
   CheckCalculatePacketSequenceNumber(GG_UINT64_C(1), GG_UINT64_C(0));
   CheckCalculatePacketSequenceNumber(kEpoch + 1, kMask);
   CheckCalculatePacketSequenceNumber(kEpoch, kMask);
 
   // Cases where the last number was close to the start of the range
   for (uint64 last = 0; last < 10; last++) {
     // Small numbers should not wrap (even if they're out of order).
@@ skipping 653 matching lines @@
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
     'Q', '0', '0', '0',
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (padding frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x00 : 0x07),
+    0x07,
   };
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(0, visitor_.frame_count_);
   EXPECT_EQ(1, visitor_.version_mismatch_);
 };
 
 TEST_P(QuicFramerTest, InvalidPrivateFlag) {
@@ skipping 62 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (padding frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x00 : 0x07),
+    0x07,
     // Ignored data (which in this case is a stream frame)
     0x01,
     0x04, 0x03, 0x02, 0x01,
     0x01,
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     0x0c, 0x00,
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
 
   ASSERT_EQ(0u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   // A packet with no frames is not acceptable.
   CheckProcessingFails(
       packet,
       GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
                           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
       "Unable to read frame type.", QUIC_INVALID_FRAME_DATA);
 }
 
-TEST_P(QuicFramerTest, StreamFrameVersion6) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_6);
-
+TEST_P(QuicFramerTest, StreamFrame) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
     0x3C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // private flags
-    0x00,
-
-    // frame type (stream frame)
-    0x01,
-    // stream id
-    0x04, 0x03, 0x02, 0x01,
-    // fin
-    0x01,
-    // offset
-    0x54, 0x76, 0x10, 0x32,
-    0xDC, 0xFE, 0x98, 0xBA,
-    // data length
-    0x0c, 0x00,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-  };
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
-
-  ASSERT_EQ(1u, visitor_.stream_frames_.size());
-  EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(static_cast<uint64>(0x01020304),
-            visitor_.stream_frames_[0]->stream_id);
-  EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
-            visitor_.stream_frames_[0]->offset);
-  EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data);
-
-  // Now test framing boundaries
-  for (size_t i = 0; i < GetMinStreamFrameSize(framer_.version()); ++i) {
-    string expected_error;
-    if (i < kQuicFrameTypeSize) {
-      expected_error = "Unable to read frame type.";
-    } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
-      expected_error = "Unable to read stream_id.";
-    } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
-               kQuicStreamFinSize) {
-      expected_error = "Unable to read fin.";
-    } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
-               kQuicStreamFinSize + kQuicMaxStreamOffsetSize) {
-      expected_error = "Unable to read offset.";
-    } else {
-      expected_error = "Unable to read frame data.";
-    }
-    CheckProcessingFails(
-        packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
-        expected_error, QUIC_INVALID_FRAME_DATA);
-  }
-}
-
-TEST_P(QuicFramerTest, StreamFrame) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_7);
-
-  unsigned char packet[] = {
-    // public flags (8 byte guid)
-    0x3C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (stream frame with fin)
@@ skipping 44 matching lines @@
     }
     CheckProcessingFails(
         packet,
         i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
                                 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
         expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_7);
-
   unsigned char packet[] = {
     // public flags (8 byte guid)
     0x3C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
@@ skipping 48 matching lines @@
     }
     CheckProcessingFails(
         packet,
         i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
                                 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
                                 expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_7);
-
   unsigned char packet[] = {
     // public flags (8 byte guid)
     0x3C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
@@ skipping 48 matching lines @@
     }
     CheckProcessingFails(
         packet,
         i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
                                 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
                                 expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
 
 TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_7);
-
   unsigned char packet[] = {
     // public flags (8 byte guid)
     0x3C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
@@ skipping 47 matching lines @@
       expected_error = "Unable to read frame data.";
     }
     CheckProcessingFails(
         packet,
         i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
                                 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
                                 expected_error, QUIC_INVALID_FRAME_DATA);
   }
 }
 
-TEST_P(QuicFramerTest, StreamFrameWithVersion6) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_6);
-
-  unsigned char packet[] = {
-    // public flags (version, 8 byte guid)
-    0x3D,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // version tag
-    'Q', '0', '0', '6',
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // private flags
-    0x00,
-
-    // frame type (stream frame)
-    0x01,
-    // stream id
-    0x04, 0x03, 0x02, 0x01,
-    // fin
-    0x01,
-    // offset
-    0x54, 0x76, 0x10, 0x32,
-    0xDC, 0xFE, 0x98, 0xBA,
-    // data length
-    0x0c, 0x00,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-  };
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(visitor_.header_.get()->public_header.version_flag);
-  EXPECT_EQ(QUIC_VERSION_6, visitor_.header_.get()->public_header.versions[0]);
-  EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion));
-
-  ASSERT_EQ(1u, visitor_.stream_frames_.size());
-  EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(static_cast<uint64>(0x01020304),
-            visitor_.stream_frames_[0]->stream_id);
-  EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
-            visitor_.stream_frames_[0]->offset);
-  EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data);
-
-  // Now test framing boundaries
-  for (size_t i = 0; i < GetMinStreamFrameSize(framer_.version()); ++i) {
-    string expected_error;
-    if (i < kQuicFrameTypeSize) {
-      expected_error = "Unable to read frame type.";
-    } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
-      expected_error = "Unable to read stream_id.";
-    } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
-               kQuicStreamFinSize) {
-      expected_error = "Unable to read fin.";
-    } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
-               kQuicStreamFinSize + kQuicMaxStreamOffsetSize) {
-      expected_error = "Unable to read offset.";
-    } else {
-      expected_error = "Unable to read frame data.";
-    }
-    CheckProcessingFails(
-        packet,
-        i + GetPacketHeaderSize(PACKET_8BYTE_GUID, kIncludeVersion,
-                                PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
-        expected_error, QUIC_INVALID_FRAME_DATA);
-  }
-}
-
 TEST_P(QuicFramerTest, StreamFrameWithVersion) {
   // Set a specific version.
   framer_.set_version(QUIC_VERSION_7);
 
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
     0x3D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ skipping 94 matching lines @@
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
 
   ASSERT_EQ(0u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
 }
 
 TEST_P(QuicFramerTest, RevivedStreamFrame) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_7);
-
   unsigned char payload[] = {
     // frame type (stream frame with fin)
     0xFE,
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
@@ skipping 34 matching lines @@
   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
   EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
   EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
             visitor_.stream_frames_[0]->offset);
   EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data);
 }
-TEST_P(QuicFramerTest, StreamFrameInFecGroupVersion6) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_6);
-
-  unsigned char packet[] = {
-    // public flags (8 byte guid)
-    0x3C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x12, 0x34,
-    // private flags (fec group)
-    0x02,
-    // first fec protected packet offset
-    0x02,
-
-    // frame type (stream frame)
-    0x01,
-    // stream id
-    0x04, 0x03, 0x02, 0x01,
-    // fin
-    0x01,
-    // offset
-    0x54, 0x76, 0x10, 0x32,
-    0xDC, 0xFE, 0x98, 0xBA,
-    // data length
-    0x0c, 0x00,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-  };
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
-  EXPECT_EQ(IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(GG_UINT64_C(0x341256789ABA),
-            visitor_.header_->fec_group);
-  const size_t fec_offset = GetStartOfFecProtectedData(
-      PACKET_8BYTE_GUID, !kIncludeVersion, PACKET_6BYTE_SEQUENCE_NUMBER);
-  EXPECT_EQ(
-      string(AsChars(packet) + fec_offset, arraysize(packet) - fec_offset),
-      visitor_.fec_protected_payload_);
-
-  ASSERT_EQ(1u, visitor_.stream_frames_.size());
-  EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id);
-  EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
-            visitor_.stream_frames_[0]->offset);
-  EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data);
-}
 
 TEST_P(QuicFramerTest, StreamFrameInFecGroup) {
   // Set a specific version.
   framer_.set_version(QUIC_VERSION_7);
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
     0x3C,
     // guid
     0x10, 0x32, 0x54, 0x76,
@@ skipping 52 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (ack frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x02 : 0x01),
+    static_cast<unsigned char>(0x01),
     // entropy hash of sent packets till least awaiting - 1.
     0xAB,
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // entropy hash of all received packets.
     0xBA,
     // largest observed packet sequence number
     0xBF, 0x9A, 0x78, 0x56,
     0x34, 0x12,
@@ skipping 311 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (rst stream frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x04 : 0x27),
+    static_cast<unsigned char>(0x27),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // error code
     0x01, 0x00, 0x00, 0x00,
 
     // error details length
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
@@ skipping 38 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (connection close frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x05 : 0x2F),
+    static_cast<unsigned char>(0x2F),
     // error code
     0x11, 0x00, 0x00, 0x00,
 
     // error details length
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
     'n',
@@ skipping 66 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (go away frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x06 : 0x37),
+    static_cast<unsigned char>(0x37),
     // error code
     0x09, 0x00, 0x00, 0x00,
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // error details length
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
@@ skipping 183 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (padding frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x00 : 0x07),
+    static_cast<unsigned char>(0x07),
   };
 
   uint64 header_size =
       GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
                           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
 
   scoped_ptr<QuicPacket> data(
       framer_.BuildUnsizedDataPacket(header, frames).packet);
   ASSERT_TRUE(data != NULL);
@@ skipping 24 matching lines @@
     0x2C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     // private flags
     0x00,
 
     // frame type (padding frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x00 : 0x07),
+    static_cast<unsigned char>(0x07),
   };
 
   uint64 header_size =
       GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
                           PACKET_4BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
 
   scoped_ptr<QuicPacket> data(
       framer_.BuildUnsizedDataPacket(header, frames).packet);
   ASSERT_TRUE(data != NULL);
@@ skipping 24 matching lines @@
     0x1C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A,
     // private flags
     0x00,
 
     // frame type (padding frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x00 : 0x07),
+    static_cast<unsigned char>(0x07),
   };
 
   uint64 header_size =
       GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
                           PACKET_2BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
 
   scoped_ptr<QuicPacket> data(
       framer_.BuildUnsizedDataPacket(header, frames).packet);
   ASSERT_TRUE(data != NULL);
@@ skipping 24 matching lines @@
     0x0C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC,
     // private flags
     0x00,
 
     // frame type (padding frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x00 : 0x07),
+    static_cast<unsigned char>(0x07),
   };
 
   uint64 header_size =
       GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
                           PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
 
   scoped_ptr<QuicPacket> data(
       framer_.BuildUnsizedDataPacket(header, frames).packet);
   ASSERT_TRUE(data != NULL);
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 }
 
-TEST_P(QuicFramerTest, BuildStreamFramePacketVersion6) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_6);
-
-  QuicPacketHeader header;
-  header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
-  header.public_header.reset_flag = false;
-  header.public_header.version_flag = false;
-  header.fec_flag = false;
-  header.entropy_flag = true;
-  header.packet_sequence_number = GG_UINT64_C(0x77123456789ABC);
-  header.fec_group = 0;
-
-  QuicStreamFrame stream_frame;
-  stream_frame.stream_id = 0x01020304;
-  stream_frame.fin = true;
-  stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654);
-  stream_frame.data = "hello world!";
-
-  QuicFrames frames;
-  frames.push_back(QuicFrame(&stream_frame));
-
-  unsigned char packet[] = {
-    // public flags (8 byte guid)
-    0x3C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // private flags (entropy)
-    0x01,
-
-    // frame type (stream frame)
-    0x01,
-    // stream id
-    0x04, 0x03, 0x02, 0x01,
-    // fin
-    0x01,
-    // offset
-    0x54, 0x76, 0x10, 0x32,
-    0xDC, 0xFE, 0x98, 0xBA,
-    // data length
-    0x0c, 0x00,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-  };
-
-  scoped_ptr<QuicPacket> data(
-      framer_.BuildUnsizedDataPacket(header, frames).packet);
-  ASSERT_TRUE(data != NULL);
-
-  test::CompareCharArraysWithHexError("constructed packet",
-                                      data->data(), data->length(),
-                                      AsChars(packet), arraysize(packet));
-}
-
 TEST_P(QuicFramerTest, BuildStreamFramePacket) {
   // Set a specific version.
   framer_.set_version(QUIC_VERSION_7);
 
   QuicPacketHeader header;
   header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
@@ skipping 107 matching lines @@
   header.reset_flag = false;
   header.version_flag = true;
 
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
     0x3D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', '6',
     'Q', '0', '0', '7',
   };
 
   QuicVersionVector versions;
-  versions.push_back(QUIC_VERSION_6);
   versions.push_back(QUIC_VERSION_7);
   scoped_ptr<QuicEncryptedPacket> data(
       framer_.BuildVersionNegotiationPacket(header, versions));
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildAckFramePacket) {
@@ skipping 24 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags (entropy)
     0x01,
 
     // frame type (ack frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x02 : 0x01),
+    static_cast<unsigned char>(0x01),
     // entropy hash of sent packets till least awaiting - 1.
     0x14,
     // least packet sequence number awaiting an ack
     0xA0, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // entropy hash of all received packets.
     0x43,
     // largest observed packet sequence number
     0xBF, 0x9A, 0x78, 0x56,
     0x34, 0x12,
@@ skipping 227 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (rst stream frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x04 : 0x27),
+    static_cast<unsigned char>(0x27),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // error code
     0x08, 0x07, 0x06, 0x05,
     // error details length
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
@@ skipping 42 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags (entropy)
     0x01,
 
     // frame type (connection close frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x05 : 0x2F),
+    static_cast<unsigned char>(0x2F),
     // error code
     0x08, 0x07, 0x06, 0x05,
     // error details length
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
     'n',
 
@@ skipping 50 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags(entropy)
     0x01,
 
     // frame type (go away frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x06 : 0x37),
+    static_cast<unsigned char>(0x37),
     // error code
     0x08, 0x07, 0x06, 0x05,
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // error details length
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
@@ skipping 306 matching lines @@
   frame.connection_close_frame = &visitor_.connection_close_frame_;
   frames.push_back(frame);
 
   original_raw_length = raw_close_packet->length();
   raw_close_packet.reset(
       framer_.BuildUnsizedDataPacket(header, frames).packet);
   ASSERT_TRUE(raw_ack_packet != NULL);
   EXPECT_EQ(original_raw_length, raw_close_packet->length());
 }
 
-TEST_P(QuicFramerTest, EntropyFlagTestVersion6) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_6);
-
-  unsigned char packet[] = {
-    // public flags (8 byte guid)
-    0x3C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // private flags (Entropy)
-    0x01,
-
-    // frame type (stream frame)
-    0x01,
-    // stream id
-    0x04, 0x03, 0x02, 0x01,
-    // fin
-    0x01,
-    // offset
-    0x54, 0x76, 0x10, 0x32,
-    0xDC, 0xFE, 0x98, 0xBA,
-    // data length
-    0x0c, 0x00,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-  };
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(visitor_.header_->entropy_flag);
-  EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
-};
-
 TEST_P(QuicFramerTest, EntropyFlagTest) {
   // Set a specific version.
   framer_.set_version(QUIC_VERSION_7);
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
     0x3C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ skipping 18 matching lines @@
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(visitor_.header_->entropy_flag);
   EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
   EXPECT_FALSE(visitor_.header_->fec_flag);
 };
 
-TEST_P(QuicFramerTest, FecEntropyTestVersion6) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_6);
-
-  unsigned char packet[] = {
-    // public flags (8 byte guid)
-    0x3C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // private flags (Entropy & fec group & FEC)
-    0x07,
-    // first fec protected packet offset
-    0xFF,
-
-    // frame type (stream frame)
-    0x01,
-    // stream id
-    0x04, 0x03, 0x02, 0x01,
-    // fin
-    0x01,
-    // offset
-    0x54, 0x76, 0x10, 0x32,
-    0xDC, 0xFE, 0x98, 0xBA,
-    // data length
-    0x0c, 0x00,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-  };
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(visitor_.header_->fec_flag);
-  EXPECT_TRUE(visitor_.header_->entropy_flag);
-  EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
-};
-
 TEST_P(QuicFramerTest, FecEntropyTest) {
   // Set a specific version.
   framer_.set_version(QUIC_VERSION_7);
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
     0x3C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ skipping 20 matching lines @@
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(visitor_.header_->fec_flag);
   EXPECT_TRUE(visitor_.header_->entropy_flag);
   EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
 };
 
-TEST_P(QuicFramerTest, StopPacketProcessingVersion6) {
-  // Set a specific version.
-  framer_.set_version(QUIC_VERSION_6);
-
-  unsigned char packet[] = {
-    // public flags (8 byte guid)
-    0x3C,
-    // guid
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet sequence number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // Entropy
-    0x01,
-
-    // frame type (stream frame)
-    0x01,
-    // stream id
-    0x04, 0x03, 0x02, 0x01,
-    // fin
-    0x01,
-    // offset
-    0x54, 0x76, 0x10, 0x32,
-    0xDC, 0xFE, 0x98, 0xBA,
-    // data length
-    0x0c, 0x00,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-
-    // frame type (ack frame)
-    0x02,
-    // entropy hash of sent packets till least awaiting - 1.
-    0x14,
-    // least packet sequence number awaiting an ack
-    0xA0, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // entropy hash of all received packets.
-    0x43,
-    // largest observed packet sequence number
-    0xBF, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // num missing packets
-    0x01,
-    // missing packet
-    0xBE, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-  };
-
-  MockFramerVisitor visitor;
-  framer_.set_visitor(&visitor);
-  EXPECT_CALL(visitor, OnPacket());
-  EXPECT_CALL(visitor, OnPacketHeader(_));
-  EXPECT_CALL(visitor, OnStreamFrame(_)).WillOnce(Return(false));
-  EXPECT_CALL(visitor, OnAckFrame(_)).Times(0);
-  EXPECT_CALL(visitor, OnPacketComplete());
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-}
-
 TEST_P(QuicFramerTest, StopPacketProcessing) {
   // Set a specific version.
   framer_.set_version(QUIC_VERSION_7);
 
   unsigned char packet[] = {
     // public flags (8 byte guid)
     0x3C,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ skipping 56 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (connection close frame)
-    static_cast<unsigned char>((version_ == QUIC_VERSION_6) ? 0x05 : 0x2F),
+    static_cast<unsigned char>(0x2F),
     // error code
     0x11, 0x00, 0x00, 0x00,
     // error details length
     0x0d, 0x00,
     // error details
     'b',  'e',  'c',  'a',
     'u',  's',  'e',  ' ',
     'I',  ' ',  'c',  'a',
     'n',
 
@@ skipping 25 matching lines @@
   EXPECT_CALL(visitor, OnConnectionCloseFrame(_)).Times(0);
   EXPECT_CALL(visitor, OnPacketComplete());
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
 }
 
 }  // namespace test
 }  // namespace net