Land Recent QUIC Changes

net/quic/quic_network_transaction_unittest.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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/mock_cert_verifier.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/ssl_config_service_defaults.h"
@@ skipping 70 matching lines @@
     HttpStreamFactory::set_use_alternate_protocols(false);
     HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   }
 
   // TODO(rch): factor these Construct* methods out into a test helper class.
   scoped_ptr<QuicEncryptedPacket> ConstructChlo() {
     const std::string host = "www.google.com";
     scoped_ptr<QuicPacket> chlo(ConstructClientHelloPacket(0xDEADBEEF,
                                                            clock_,
                                                            &random_generator_,
-                                                           host));
+                                                           host,
+                                                           true));
     QuicFramer framer(kQuicVersion1,
                       QuicDecrypter::Create(kNULL),
-                      QuicEncrypter::Create(kNULL));
+                      QuicEncrypter::Create(kNULL),
+                      false);
     return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(1, *chlo));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructShlo() {
     const std::string host = "www.google.com";
     scoped_ptr<QuicPacket> shlo(ConstructServerHelloPacket(0xDEADBEEF,
                                                            clock_,
                                                            &random_generator_,
                                                            host));
     QuicFramer framer(kQuicVersion1,
                       QuicDecrypter::Create(kNULL),
-                      QuicEncrypter::Create(kNULL));
+                      QuicEncrypter::Create(kNULL),
+                      false);
     return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(1, *shlo));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket(
       QuicPacketSequenceNumber num,
       QuicStreamId stream_id) {
     QuicPacketHeader header;
     header.public_header.guid = 0xDEADBEEF;
     header.public_header.reset_flag = false;
     header.public_header.version_flag = false;
@@ skipping 14 matching lines @@
     QuicPacketHeader header;
     header.public_header.guid = 0xDEADBEEF;
     header.public_header.reset_flag = false;
     header.public_header.version_flag = false;
     header.packet_sequence_number = 3;
     header.entropy_flag = false;
     header.fec_flag = false;
     header.fec_entropy_flag = false;
     header.fec_group = 0;
 
-    QuicAckFrame ack(largest_received, least_unacked);
+    QuicAckFrame ack(largest_received, QuicTime::Zero(), least_unacked);
 
     QuicCongestionFeedbackFrame feedback;
     feedback.type = kTCP;
     feedback.tcp.accumulated_number_of_lost_packets = 0;
     feedback.tcp.receive_window = 256000;
 
     QuicFramer framer(kQuicVersion1,
                       QuicDecrypter::Create(kNULL),
-                      QuicEncrypter::Create(kNULL));
+                      QuicEncrypter::Create(kNULL),
+                      false);
     QuicFrames frames;
     frames.push_back(QuicFrame(&ack));
     frames.push_back(QuicFrame(&feedback));
     scoped_ptr<QuicPacket> packet(
         framer.ConstructFrameDataPacket(header, frames).packet);
     return scoped_ptr<QuicEncryptedPacket>(
         framer.EncryptPacket(header.packet_sequence_number, *packet));
   }
 
   std::string GetRequestString(const std::string& method,
@@ skipping 33 matching lines @@
     InitializeHeader(sequence_number);
     QuicStreamFrame frame(3, fin, offset, data);
     return ConstructPacket(header_, QuicFrame(&frame)).release();
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructPacket(
       const QuicPacketHeader& header,
       const QuicFrame& frame) {
     QuicFramer framer(kQuicVersion1,
                       QuicDecrypter::Create(kNULL),
-                      QuicEncrypter::Create(kNULL));
+                      QuicEncrypter::Create(kNULL),
+                      false);
     QuicFrames frames;
     frames.push_back(frame);
     scoped_ptr<QuicPacket> packet(
         framer.ConstructFrameDataPacket(header, frames).packet);
     return scoped_ptr<QuicEncryptedPacket>(
         framer.EncryptPacket(header.packet_sequence_number, *packet));
   }
 
   void InitializeHeader(QuicPacketSequenceNumber sequence_number) {
     header_.public_header.guid = random_generator_.RandUint64();
@@ skipping 298 matching lines @@
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_FALSE(response->was_fetched_via_spdy);
 
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
 }
 
 }  // namespace test
 }  // namespace net