Land Recent QUIC changes.

net/tools/quic/quic_epoll_connection_helper_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/tools/quic/quic_epoll_connection_helper.h"
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_random.h"
@@ skipping 23 matching lines @@
 const bool kFromPeer = true;
 
 class TestWriter : public QuicPacketWriter {
  public:
   // QuicPacketWriter
   virtual WriteResult WritePacket(
       const char* buffer, size_t buf_len,
       const IPAddressNumber& self_address,
       const IPEndPoint& peer_address,
       QuicBlockedWriterInterface* blocked_writer) OVERRIDE {
-    QuicFramer framer(QuicVersionMax(), QuicTime::Zero(), true);
+    QuicFramer framer(QuicSupportedVersions(), QuicTime::Zero(), true);
     FramerVisitorCapturingFrames visitor;
     framer.set_visitor(&visitor);
     QuicEncryptedPacket packet(buffer, buf_len);
     EXPECT_TRUE(framer.ProcessPacket(packet));
     header_ = *visitor.header();
     return WriteResult(WRITE_STATUS_OK, packet.length());
   }
 
   virtual bool IsWriteBlockedDataBuffered() const OVERRIDE {
     return false;
   }
 
   // Returns the header from the last packet written.
   const QuicPacketHeader& header() { return header_; }
 
  private:
   QuicPacketHeader header_;
 };
 
 class TestConnection : public QuicConnection {
  public:
   TestConnection(QuicGuid guid,
                  IPEndPoint address,
                  QuicEpollConnectionHelper* helper,
                  TestWriter* writer)
-      : QuicConnection(guid, address, helper, writer, false, QuicVersionMax()) {
+      : QuicConnection(guid, address, helper, writer, false,
+                       QuicSupportedVersions()) {
   }
 
   void SendAck() {
     QuicConnectionPeer::SendAck(this);
   }
 
   void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) {
     QuicConnectionPeer::SetSendAlgorithm(this, send_algorithm);
   }
 };
 
 class QuicEpollConnectionHelperTest : public ::testing::Test {
  protected:
   QuicEpollConnectionHelperTest()
       : guid_(42),
-        framer_(QuicVersionMax(), QuicTime::Zero(), false),
+        framer_(QuicSupportedVersions(), QuicTime::Zero(), false),
         send_algorithm_(new testing::StrictMock<MockSendAlgorithm>),
         helper_(&epoll_server_),
         connection_(guid_, IPEndPoint(), &helper_, &writer_),
         frame_(3, false, 0, kData) {
     connection_.set_visitor(&visitor_);
     connection_.SetSendAlgorithm(send_algorithm_);
     epoll_server_.set_timeout_in_us(-1);
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
         WillRepeatedly(Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillRepeatedly(Return(
@@ skipping 131 matching lines @@
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(Return(true));
   EXPECT_CALL(visitor_, HasPendingHandshake()).Times(AnyNumber());
   epoll_server_.AdvanceByAndCallCallbacks(1);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net