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/hash_tables.h"
@@ skipping 172 matching lines @@
 
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) OVERRIDE {
     version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
   }
 
   virtual void OnRevivedPacket() OVERRIDE {
     revived_packets_++;
   }
 
-  virtual bool OnProtocolVersionMismatch(
-      QuicVersionTag version) OVERRIDE {
+  virtual bool OnProtocolVersionMismatch(QuicTag version) OVERRIDE {
     DCHECK(false);
     return true;
   }
 
   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
     packet_count_++;
     header_.reset(new QuicPacketHeader(header));
     return accept_packet_;
   }
 
@@ skipping 361 matching lines @@
 }
 
 TEST_F(QuicFramerTest, PacketHeaderWithVersionFlag) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // public flags (version)
     0x01,
     // version tag
-    'Q', '1', '.', '0',
+    'Q', '0', '0', '1',
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
     // first fec protected packet offset
     0xFF,
   };
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
@@ skipping 224 matching lines @@
 }
 
 TEST_F(QuicFramerTest, StreamFrameWithVersion) {
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // public flags (version)
     0x01,
     // version tag
-    'Q', '1', '.', '0',
+    'Q', '0', '0', '1',
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags
     0x00,
     // first fec protected packet offset
     0xFF,
 
     // frame type (stream frame)
     0x01,
@@ skipping 788 matching lines @@
   }
 }
 
 TEST_F(QuicFramerTest, VersionNegotiationPacket) {
   unsigned char packet[] = {
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // public flags (version)
     0x01,
     // version tag
-    'Q', '1', '.', '0',
+    'Q', '0', '0', '1',
     '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 178 matching lines @@
   QuicFrames frames;
   frames.push_back(QuicFrame(&stream_frame));
 
   unsigned char packet[] = {
     // guid
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // public flags (version)
     0x01,
     // version tag
-    'Q', '1', '.', '0',
+    'Q', '0', '0', '1',
     // packet sequence number
     0xBC, 0x9A, 0x78, 0x56,
     0x34, 0x12,
     // private flags (entropy)
     0x02,
     // first fec protected packet offset
     0xFF,
 
     // frame type (stream frame)
     0x01,
@@ skipping 27 matching lines @@
   header.guid = GG_UINT64_C(0xFEDCBA9876543210);
   header.reset_flag = false;
   header.version_flag = true;
 
   unsigned char packet[] = {
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // public flags (version)
     0x01,
     // version tag
-    'Q', '1', '.', '0',
+    'Q', '0', '0', '1',
     'Q', '2', '.', '0',
   };
 
   const int kQuicVersion2 = MakeQuicTag('Q', '2', '.', '0');
-  QuicVersionTagList versions;
+  QuicTagVector versions;
   versions.push_back(kQuicVersion1);
   versions.push_back(kQuicVersion2);
   scoped_ptr<QuicEncryptedPacket> data(
       framer_.ConstructVersionNegotiationPacket(header, versions));
 
   test::CompareCharArraysWithHexError("constructed packet",
                                       data->data(), data->length(),
                                       AsChars(packet), arraysize(packet));
 }
 
@@ skipping 904 matching lines @@
   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());
 }
 
 }  // namespace test
 }  // namespace net