Land Recent QUIC changes.

net/quic/quic_http_stream_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 "net/quic/quic_http_stream.h"
 
 #include <vector>
 
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 28 matching lines @@
 namespace test {
 namespace {
 
 const char kUploadData[] = "hello world!";
 
 class TestQuicConnection : public QuicConnection {
  public:
   TestQuicConnection(QuicGuid guid,
                      IPEndPoint address,
                      QuicConnectionHelper* helper)
-      : QuicConnection(guid, address, helper, false) {
+      : QuicConnection(guid, address, helper, false, QuicVersionMax()) {
   }
 
   void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) {
     QuicConnectionPeer::SetSendAlgorithm(this, send_algorithm);
   }
 
   void SetReceiveAlgorithm(ReceiveAlgorithmInterface* receive_algorithm) {
     QuicConnectionPeer::SetReceiveAlgorithm(this, receive_algorithm);
   }
 };
@@ skipping 51 matching lines @@
     }
     IoMode mode;
     QuicEncryptedPacket* packet;
   };
 
   QuicHttpStreamTest()
       : net_log_(BoundNetLog()),
         use_closing_stream_(false),
         read_buffer_(new IOBufferWithSize(4096)),
         guid_(2),
-        framer_(kQuicVersion1, QuicTime::Zero(), false),
+        framer_(QuicVersionMax(), QuicTime::Zero(), false),
         creator_(guid_, &framer_, &random_, false) {
     IPAddressNumber ip;
     CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
     peer_addr_ = IPEndPoint(ip, 443);
     self_addr_ = IPEndPoint(ip, 8435);
   }
 
   ~QuicHttpStreamTest() {
     for (size_t i = 0; i < writes_.size(); i++) {
       delete writes_[i].packet;
@@ skipping 29 matching lines @@
 
     socket_data_.reset(new StaticSocketDataProvider(NULL, 0, mock_writes_.get(),
                                                     writes_.size()));
 
     MockUDPClientSocket* socket = new MockUDPClientSocket(socket_data_.get(),
                                                           net_log_.net_log());
     socket->Connect(peer_addr_);
     runner_ = new TestTaskRunner(&clock_);
     send_algorithm_ = new MockSendAlgorithm();
     receive_algorithm_ = new TestReceiveAlgorithm(NULL);
+    EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
+        testing::Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).
         WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
     helper_ = new QuicConnectionHelper(runner_.get(), &clock_,
                                        &random_generator_, socket);
     connection_ = new TestQuicConnection(guid_, peer_addr_, helper_);
     connection_->set_visitor(&visitor_);
     connection_->SetSendAlgorithm(send_algorithm_);
     connection_->SetReceiveAlgorithm(receive_algorithm_);
     crypto_config_.SetDefaults();
     session_.reset(new QuicClientSession(connection_, socket, NULL,
@@ skipping 373 matching lines @@
 
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(*resp);
 
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 
 }  // namespace net