Minor cleanup of QUIC MockConnection and PacketSavingConnection

net/tools/quic/quic_time_wait_list_manager_test.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/tools/quic/quic_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 68 matching lines @@
   QuicTimeWaitListManagerTest()
       : time_wait_list_manager_(
           &writer_, &epoll_server_, QuicSupportedVersions()),
         framer_(QuicSupportedVersions(), QuicTime::Zero(), true),
         guid_(45) {
   }
 
   virtual ~QuicTimeWaitListManagerTest() {}
 
   void AddGuid(QuicGuid guid) {
-    AddGuid(guid, test::QuicVersionMax(), NULL);
+    AddGuid(guid, net::test::QuicVersionMax(), NULL);
   }
 
   void AddGuid(QuicGuid guid,
                QuicVersion version,
                QuicEncryptedPacket* packet) {
     time_wait_list_manager_.AddGuidToTimeWait(guid, version, packet);
   }
 
   bool IsGuidInTimeWait(QuicGuid guid) {
     return time_wait_list_manager_.IsGuidInTimeWait(guid);
@@ skipping 89 matching lines @@
 
 TEST_F(QuicTimeWaitListManagerTest, CheckGuidInTimeWait) {
   EXPECT_FALSE(IsGuidInTimeWait(guid_));
   AddGuid(guid_);
   EXPECT_TRUE(IsGuidInTimeWait(guid_));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, SendConnectionClose) {
   size_t kConnectionCloseLength = 100;
   AddGuid(guid_,
-          QuicVersionMax(),
+          net::test::QuicVersionMax(),
           new QuicEncryptedPacket(
               new char[kConnectionCloseLength], kConnectionCloseLength, true));
   const int kRandomSequenceNumber = 1;
   scoped_ptr<QuicEncryptedPacket> packet(
       ConstructEncryptedPacket(ENCRYPTION_NONE, guid_, kRandomSequenceNumber));
   EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
                                    server_address_.address(),
                                    client_address_,
                                    &time_wait_list_manager_))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
@@ skipping 175 matching lines @@
                                    other_packet->length())));
   time_wait_list_manager_.OnCanWrite();
   EXPECT_FALSE(
       QuicTimeWaitListManagerPeer::is_write_blocked(&time_wait_list_manager_));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, MakeSureFramerUsesCorrectVersion) {
   const int kRandomSequenceNumber = 1;
   scoped_ptr<QuicEncryptedPacket> packet;
 
-  AddGuid(guid_, test::QuicVersionMin(), NULL);
-  framer_.set_version(test::QuicVersionMin());
+  AddGuid(guid_, net::test::QuicVersionMin(), NULL);
+  framer_.set_version(net::test::QuicVersionMin());
   packet.reset(
       ConstructEncryptedPacket(ENCRYPTION_NONE, guid_, kRandomSequenceNumber));
 
   // Reset packet should be written, using the minimum quic version.
   EXPECT_CALL(writer_, WritePacket(_, _, _, _, _)).Times(1)
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
   ProcessPacket(guid_, *packet);
   EXPECT_EQ(QuicTimeWaitListManagerPeer::version(&time_wait_list_manager_),
-            test::QuicVersionMin());
+            net::test::QuicVersionMin());
 
   // New guid
   ++guid_;
 
-  AddGuid(guid_, test::QuicVersionMax(), NULL);
-  framer_.set_version(test::QuicVersionMax());
+  AddGuid(guid_, net::test::QuicVersionMax(), NULL);
+  framer_.set_version(net::test::QuicVersionMax());
   packet.reset(
       ConstructEncryptedPacket(ENCRYPTION_NONE, guid_, kRandomSequenceNumber));
 
   // Reset packet should be written, using the maximum quic version.
   EXPECT_CALL(writer_, WritePacket(_, _, _, _, _)).Times(1)
     .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
   ProcessPacket(guid_, *packet);
   EXPECT_EQ(QuicTimeWaitListManagerPeer::version(&time_wait_list_manager_),
-            test::QuicVersionMax());
+            net::test::QuicVersionMax());
 }
 
 TEST_F(QuicTimeWaitListManagerTest, GetQuicVersionFromMap) {
   const int kGuid1 = 123;
   const int kGuid2 = 456;
   const int kGuid3 = 789;
 
-  AddGuid(kGuid1, test::QuicVersionMin(), NULL);
-  AddGuid(kGuid2, test::QuicVersionMax(), NULL);
-  AddGuid(kGuid3, test::QuicVersionMax(), NULL);
+  AddGuid(kGuid1, net::test::QuicVersionMin(), NULL);
+  AddGuid(kGuid2, net::test::QuicVersionMax(), NULL);
+  AddGuid(kGuid3, net::test::QuicVersionMax(), NULL);
 
-  EXPECT_EQ(test::QuicVersionMin(),
+  EXPECT_EQ(net::test::QuicVersionMin(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromGuid(
                 &time_wait_list_manager_, kGuid1));
-  EXPECT_EQ(test::QuicVersionMax(),
+  EXPECT_EQ(net::test::QuicVersionMax(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromGuid(
                 &time_wait_list_manager_, kGuid2));
-  EXPECT_EQ(test::QuicVersionMax(),
+  EXPECT_EQ(net::test::QuicVersionMax(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromGuid(
                 &time_wait_list_manager_, kGuid3));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net