Land Recent QUIC changes.

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 301 matching lines @@
         framer_(QuicVersionMax(), start_, true) {
     framer_.SetDecrypter(decrypter_);
     framer_.SetEncrypter(ENCRYPTION_NONE, encrypter_);
     framer_.set_visitor(&visitor_);
     framer_.set_received_entropy_calculator(&entropy_calculator_);
 
     version_ = GetParam();
     framer_.set_version(version_);
   }
 
+  // Helper function to get unsigned char representation of digit in the
+  // units place of the current QUIC version number.
+  unsigned char GetQuicVersionDigitOnes() {
+    return static_cast<unsigned char> ('0' + version_%10);
+  }
+
+  // Helper function to get unsigned char representation of digit in the
+  // tens place of the current QUIC version number.
+  unsigned char GetQuicVersionDigitTens() {
+    return static_cast<unsigned char> ('0' + (version_/10)%10);
+  }
+
   bool CheckEncryption(QuicPacketSequenceNumber sequence_number,
                        QuicPacket* packet) {
     if (sequence_number != encrypter_->sequence_number_) {
       LOG(ERROR) << "Encrypted incorrect packet sequence number.  expected "
                  << sequence_number << " actual: "
                  << encrypter_->sequence_number_;
       return false;
     }
     if (packet->AssociatedData() != encrypter_->associated_data_) {
       LOG(ERROR) << "Encrypted incorrect associated data.  expected "
@@ skipping 86 matching lines @@
     QuicPacketSequenceNumber wire_sequence_number =
         expected_sequence_number & kMask;
     QuicFramerPeer::SetLastSequenceNumber(&framer_, last_sequence_number);
     EXPECT_EQ(expected_sequence_number,
               QuicFramerPeer::CalculatePacketSequenceNumberFromWire(
                   &framer_, PACKET_6BYTE_SEQUENCE_NUMBER, wire_sequence_number))
         << "last_sequence_number: " << last_sequence_number
         << " wire_sequence_number: " << wire_sequence_number;
   }
 
-  char LastCharOfVersion() {
-    switch (GetParam()) {
-      case QUIC_VERSION_7:
-        return '7';
-      case QUIC_VERSION_8:
-        return '8';
-      case QUIC_VERSION_9:
-        return '9';
-      default:
-        CHECK(0) << "Invalid version";
-        return 0;
-    }
-  }
-
   test::TestEncrypter* encrypter_;
   test::TestDecrypter* decrypter_;
   QuicVersion version_;
   QuicTime start_;
   QuicFramer framer_;
   test::TestQuicVisitor visitor_;
   test::TestEntropyCalculator entropy_calculator_;
 };
 
 // Run all framer tests with all supported versions of QUIC.
@@ skipping 355 matching lines @@
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWithVersionFlag) {
   unsigned char packet[] = {
     // public flags (version)
     0x3D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', LastCharOfVersion(),
+    'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
@@ skipping 205 matching lines @@
     0x40,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
-    // frame count
-    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 (padding)
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x07 : 0x00),
+    0x00, 0x00, 0x00, 0x00
   };
   CheckProcessingFails(packet,
                        arraysize(packet),
                        "Illegal public flags value.",
                        QUIC_INVALID_PACKET_HEADER);
 };
 
 TEST_P(QuicFramerTest, InvalidPublicFlagWithMatchingVersions) {
   unsigned char packet[] = {
     // public flags (8 byte guid and version flag and an unknown flag)
     0x4D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', LastCharOfVersion(),
+    'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
-    // frame count
-    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 (padding)
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x07 : 0x00),
+    0x00, 0x00, 0x00, 0x00
   };
   CheckProcessingFails(packet,
                        arraysize(packet),
                        "Illegal public flags value.",
                        QUIC_INVALID_PACKET_HEADER);
 };
 
 TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) {
   unsigned char packet[] = {
     // public flags (8 byte guid, version flag and an unknown flag)
     0x7D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     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)
-    0x07,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x07 : 0x00),
+    0x00, 0x00, 0x00, 0x00
   };
   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) {
   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
     0x10,
 
-    // frame count
-    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 (padding)
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x07 : 0x00),
+    0x00, 0x00, 0x00, 0x00
   };
   CheckProcessingFails(packet,
                        arraysize(packet),
                        "Illegal private flags value.",
                        QUIC_INVALID_PACKET_HEADER);
 };
 
 TEST_P(QuicFramerTest, InvalidFECGroupOffset) {
   unsigned char packet[] = {
     // public flags (8 byte guid)
@@ skipping 23 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)
-    0x07,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x07 : 0x00),
     // Ignored data (which in this case is a stream frame)
-    0x01,
+    // frame type (stream frame with fin)
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xFE : 0xFF),
+    // stream id
     0x04, 0x03, 0x02, 0x01,
-    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));
@@ skipping 15 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 (stream frame with fin)
-    0xFE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xFE : 0xFF),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
@@ skipping 27 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 (stream frame with fin)
-    0xFC,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xFC : 0xFE),
     // stream id
     0x04, 0x03, 0x02,
     // 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>(0x00020304),
+  EXPECT_EQ(GG_UINT64_C(0x00020304),
             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
   const size_t stream_id_size = 3;
   CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion);
 }
 
 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) {
   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)
-    0xFA,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xFA : 0xFD),
     // stream id
     0x04, 0x03,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
@@ skipping 28 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 (stream frame with fin)
-    0xF8,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xF8 : 0xFC),
     // stream id
     0x04,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
@@ skipping 22 matching lines @@
 }
 
 TEST_P(QuicFramerTest, StreamFrameWithVersion) {
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
     0x3D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', LastCharOfVersion(),
+    'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
 
     // frame type (stream frame with fin)
-    0xFE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xFE : 0xFF),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
@@ skipping 31 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 (stream frame with fin)
-    0xFE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xFE : 0xFF),
     // stream id
     0x04, 0x03, 0x02, 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(0u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
 }
 
 TEST_P(QuicFramerTest, RevivedStreamFrame) {
   unsigned char payload[] = {
     // frame type (stream frame with fin)
-    0xFE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xFE : 0xFF),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
@@ skipping 48 matching lines @@
     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 with fin)
-    0xFE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xFE : 0xFF),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
     0x0c, 0x00,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
@@ skipping 31 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>(0x01),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x01 : 0x40),
     // 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 72 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 (congestion feedback frame)
-    0x03,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x03 : 0x20),
     // congestion feedback type (tcp)
     0x00,
     // ack_frame.feedback.tcp.accumulated_number_of_lost_packets
     0x01, 0x02,
     // ack_frame.feedback.tcp.receive_window
     0x03, 0x04,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ skipping 36 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 (congestion feedback frame)
-    0x03,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x03 : 0x20),
     // congestion feedback type (inter arrival)
     0x01,
     // accumulated_number_of_lost_packets
     0x02, 0x03,
     // num received packets
     0x03,
     // lowest sequence number
     0xBA, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // receive time
@@ skipping 75 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 (congestion feedback frame)
-    0x03,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x03 : 0x20),
     // congestion feedback type (fix rate)
     0x02,
     // bitrate_in_bytes_per_second;
     0x01, 0x02, 0x03, 0x04,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
@@ skipping 31 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 (congestion feedback frame)
-    0x03,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x03 : 0x20),
     // congestion feedback type (invalid)
     0x03,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
   EXPECT_EQ(QUIC_INVALID_CONGESTION_FEEDBACK_DATA, framer_.error());
 }
 
 TEST_P(QuicFramerTest, RstStreamFrame) {
   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 (rst stream frame)
-    static_cast<unsigned char>(0x27),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x27 : 0x01),
     // 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>(0x2F),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x2F : 0x02),
     // 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>(0x37),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x37 : 0x03),
     // 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 86 matching lines @@
 }
 
 TEST_P(QuicFramerTest, VersionNegotiationPacket) {
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
     0x3D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', LastCharOfVersion(),
+    'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
     'Q', '2', '.', '0',
   };
 
   QuicFramerPeer::SetIsServer(&framer_, false);
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
   EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size());
@@ skipping 72 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>(0x07),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x07 : 0x00),
+    0x00, 0x00, 0x00, 0x00
   };
 
   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>(0x07),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x07 : 0x00),
+    0x00, 0x00, 0x00, 0x00
   };
 
   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>(0x07),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x07 : 0x00),
+    0x00, 0x00, 0x00, 0x00
   };
 
   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>(0x07),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x07 : 0x00),
+    0x00, 0x00, 0x00, 0x00
   };
 
   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);
@@ skipping 28 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 (stream frame with fin and no length)
-    0xBE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xBE : 0xDF),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
@@ skipping 26 matching lines @@
   QuicFrames frames;
   frames.push_back(QuicFrame(&stream_frame));
 
   unsigned char packet[] = {
     // public flags (version, 8 byte guid)
     0x3D,
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // version tag
-    'Q', '0', '0', LastCharOfVersion(),
+    'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags (entropy)
     0x01,
 
     // frame type (stream frame with fin and no length)
-    0xBE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xBE : 0xDF),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
@@ skipping 14 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', LastCharOfVersion(),
+    'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
   };
 
   QuicVersionVector versions;
   versions.push_back(GetParam());
   scoped_ptr<QuicEncryptedPacket> data(
       framer_.BuildVersionNegotiationPacket(header, versions));
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
@@ skipping 27 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>(0x01),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x01 : 0x40),
     // 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 39 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 (congestion feedback frame)
-    0x03,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x03 : 0x20),
     // congestion feedback type (TCP)
     0x00,
     // accumulated number of lost packets
     0x01, 0x02,
     // TCP receive window
     0x03, 0x04,
   };
 
   scoped_ptr<QuicPacket> data(
       framer_.BuildUnsizedDataPacket(header, frames).packet);
@@ 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 (congestion feedback frame)
-    0x03,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x03 : 0x20),
     // congestion feedback type (inter arrival)
     0x01,
     // accumulated_number_of_lost_packets
     0x02, 0x03,
     // num received packets
     0x03,
     // lowest sequence number
     0xBA, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // receive time
@@ skipping 42 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 (congestion feedback frame)
-    0x03,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x03 : 0x20),
     // congestion feedback type (fix rate)
     0x02,
     // bitrate_in_bytes_per_second;
     0x01, 0x02, 0x03, 0x04,
   };
 
   scoped_ptr<QuicPacket> data(
       framer_.BuildUnsizedDataPacket(header, frames).packet);
   ASSERT_TRUE(data != NULL);
 
@@ skipping 45 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>(0x27),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x27 : 0x01),
     // 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>(0x2F),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x2F : 0x02),
     // 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>(0x37),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x37 : 0x03),
     // 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 320 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 (stream frame with fin and no length)
-    0xBE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xBE : 0xDF),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
@@ skipping 16 matching lines @@
     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 with fin and no length)
-    0xBE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xBE : 0xDF),
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data
     'h',  'e',  'l',  'l',
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
@@ skipping 14 matching lines @@
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // Entropy
     0x01,
 
     // frame type (stream frame with fin)
-    0xFE,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0xFE : 0xFF),
     // stream id
     0x04, 0x03, 0x02, 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,
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x01 : 0x40),
     // 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 24 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>(0x2F),
+    static_cast<unsigned char>(
+        GetParam() < QUIC_VERSION_10 ? 0x2F : 0x02),
     // 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