Land Recent QUIC changes.

net/quic/test_tools/quic_test_utils.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/quic/test_tools/quic_test_utils.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/crypto_utils.h"
@@ skipping 217 matching lines @@
     QuicPacketEntropyHash entropy_hash,
     HasRetransmittableData retransmittable) {
   packets_.push_back(packet);
   QuicEncryptedPacket* encrypted =
       framer_.EncryptPacket(level, sequence_number, *packet);
   encrypted_packets_.push_back(encrypted);
   return true;
 }
 
 MockSession::MockSession(QuicConnection* connection, bool is_server)
-    : QuicSession(connection, QuicConfig(), is_server) {
+    : QuicSession(connection, DefaultQuicConfig(), is_server) {
   ON_CALL(*this, WriteData(_, _, _, _))
       .WillByDefault(testing::Return(QuicConsumedData(0, false)));
 }
 
 MockSession::~MockSession() {
 }
 
 TestSession::TestSession(QuicConnection* connection,
                          const QuicConfig& config,
                          bool is_server)
     : QuicSession(connection, config, is_server),
       crypto_stream_(NULL) {
 }
 
-TestSession::~TestSession() {
-}
+TestSession::~TestSession() {}
 
 void TestSession::SetCryptoStream(QuicCryptoStream* stream) {
   crypto_stream_ = stream;
 }
 
 QuicCryptoStream* TestSession::GetCryptoStream() {
   return crypto_stream_;
 }
 
 MockSendAlgorithm::MockSendAlgorithm() {
@@ skipping 93 matching lines @@
   QuicFramer quic_framer(kQuicVersion1, QuicTime::Zero(), false);
 
   QuicPacketHeader header;
   header.public_header.guid = guid;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = should_include_version;
   header.packet_sequence_number = 1;
   header.entropy_flag = false;
   header.entropy_hash = 0;
   header.fec_flag = false;
-  header.fec_entropy_flag = false;
   header.fec_group = 0;
 
   QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
                                data->AsStringPiece());
 
   QuicFrame frame(&stream_frame);
   QuicFrames frames;
   frames.push_back(frame);
   return quic_framer.ConstructFrameDataPacket(header, frames).packet;
 }
 
 QuicPacket* ConstructHandshakePacket(QuicGuid guid, QuicTag tag) {
   CryptoHandshakeMessage message;
   message.set_tag(tag);
   return ConstructPacketFromHandshakeMessage(guid, message, false);
 }
 
-size_t GetPacketLengthForOneStream(bool include_version, size_t payload) {
+size_t GetPacketLengthForOneStream(
+    bool include_version, InFecGroup is_in_fec_group, size_t payload) {
   // TODO(wtc): the hardcoded use of NullEncrypter here seems wrong.
   size_t packet_length = NullEncrypter().GetCiphertextSize(payload) +
-      QuicPacketCreator::StreamFramePacketOverhead(1, include_version);
+      QuicPacketCreator::StreamFramePacketOverhead(
+          1, PACKET_8BYTE_GUID, include_version, is_in_fec_group);
 
   size_t ack_length = NullEncrypter().GetCiphertextSize(
-      QuicFramer::GetMinAckFrameSize()) + GetPacketHeaderSize(include_version);
+      QuicFramer::GetMinAckFrameSize()) +
+      GetPacketHeaderSize(PACKET_8BYTE_GUID, include_version, is_in_fec_group);
   // Make sure that if we change the size of the packet length for one stream
   // or the ack frame; that all our test are configured correctly.
   DCHECK_GE(packet_length, ack_length);
   return packet_length;
 }
 
 QuicPacketEntropyHash TestEntropyCalculator::ReceivedEntropyHash(
     QuicPacketSequenceNumber sequence_number) const {
   return 1u;
 }
 
+QuicConfig DefaultQuicConfig() {
+  QuicConfig config;
+  config.SetDefaults();
+  return config;
+}
+
 bool TestDecompressorVisitor::OnDecompressedData(StringPiece data) {
   data.AppendToString(&data_);
   return true;
 }
 
 void TestDecompressorVisitor::OnDecompressionError() {
   error_ = true;
 }
 
 }  // namespace test
 }  // namespace net