Land Recent QUIC Changes.

net/quic/test_tools/quic_test_packet_maker.cc

 // Copyright 2013 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/quic/test_tools/quic_test_packet_maker.h"
 
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 
 namespace net {
 namespace test {
 
-QuicTestPacketMaker::QuicTestPacketMaker(QuicVersion version, QuicGuid guid)
+QuicTestPacketMaker::QuicTestPacketMaker(QuicVersion version,
+                                         QuicConnectionId connection_id)
     : version_(version),
-      guid_(guid),
+      connection_id_(connection_id),
       spdy_request_framer_(SPDY3),
       spdy_response_framer_(SPDY3) {
 }
 
 QuicTestPacketMaker::~QuicTestPacketMaker() {
 }
 
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRstPacket(
     QuicPacketSequenceNumber num,
     bool include_version,
     QuicStreamId stream_id,
     QuicRstStreamErrorCode error_code) {
   QuicPacketHeader header;
-  header.public_header.guid = guid_;
+  header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = include_version;
   header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
   header.packet_sequence_number = num;
   header.entropy_flag = false;
   header.fec_flag = false;
   header.fec_group = 0;
 
   QuicRstStreamFrame rst(stream_id, error_code, 0);
   return scoped_ptr<QuicEncryptedPacket>(MakePacket(header, QuicFrame(&rst)));
 }
 
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckAndRstPacket(
     QuicPacketSequenceNumber num,
     bool include_version,
     QuicStreamId stream_id,
     QuicRstStreamErrorCode error_code,
     QuicPacketSequenceNumber largest_received,
     QuicPacketSequenceNumber least_unacked,
     bool send_feedback) {
 
   QuicPacketHeader header;
-  header.public_header.guid = guid_;
+  header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = include_version;
   header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
   header.packet_sequence_number = num;
   header.entropy_flag = false;
   header.fec_flag = false;
   header.fec_group = 0;
 
   QuicAckFrame ack(largest_received, QuicTime::Zero(), least_unacked);
   QuicFrames frames;
@@ skipping 18 matching lines @@
   QuicFramer framer(SupportedVersions(version_), QuicTime::Zero(), false);
   scoped_ptr<QuicPacket> packet(
       framer.BuildUnsizedDataPacket(header, frames).packet);
   return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(
       ENCRYPTION_NONE, header.packet_sequence_number, *packet));
 }
 
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeConnectionClosePacket(
     QuicPacketSequenceNumber num) {
   QuicPacketHeader header;
-  header.public_header.guid = guid_;
+  header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
   header.packet_sequence_number = num;
   header.entropy_flag = false;
   header.fec_flag = false;
   header.fec_group = 0;
 
   QuicConnectionCloseFrame close;
   close.error_code = QUIC_CRYPTO_VERSION_NOT_SUPPORTED;
   close.error_details = "Time to panic!";
   return scoped_ptr<QuicEncryptedPacket>(MakePacket(header, QuicFrame(&close)));
 }
 
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckPacket(
     QuicPacketSequenceNumber sequence_number,
     QuicPacketSequenceNumber largest_received,
     QuicPacketSequenceNumber least_unacked,
     bool send_feedback) {
   QuicPacketHeader header;
-  header.public_header.guid = guid_;
+  header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
   header.packet_sequence_number = sequence_number;
   header.entropy_flag = false;
   header.fec_flag = false;
   header.fec_group = 0;
 
   QuicAckFrame ack(largest_received, QuicTime::Zero(), least_unacked);
 
@@ skipping 116 matching lines @@
   frames.push_back(frame);
   scoped_ptr<QuicPacket> packet(
       framer.BuildUnsizedDataPacket(header, frames).packet);
   return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(
       ENCRYPTION_NONE, header.packet_sequence_number, *packet));
 }
 
 void QuicTestPacketMaker::InitializeHeader(
     QuicPacketSequenceNumber sequence_number,
     bool should_include_version) {
-  header_.public_header.guid = guid_;
+  header_.public_header.connection_id = connection_id_;
   header_.public_header.reset_flag = false;
   header_.public_header.version_flag = should_include_version;
   header_.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
   header_.packet_sequence_number = sequence_number;
   header_.fec_group = 0;
   header_.entropy_flag = false;
   header_.fec_flag = false;
 }
 
 std::string QuicTestPacketMaker::SerializeHeaderBlock(
     const SpdyHeaderBlock& headers) {
   QuicSpdyCompressor compressor;
   return compressor.CompressHeadersWithPriority(
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY), headers);
 }
 
 }  // namespace test
 }  // namespace net