Land Recent QUIC Changes

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"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
+#include "net/quic/quic_connection_helper.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_writer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
+#include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/test_tools/mock_epoll_server.h"
 #include "net/tools/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::test::BuildUnsizedDataPacket;
 using net::test::NoOpFramerVisitor;
 using net::test::QuicVersionMax;
 using net::test::QuicVersionMin;
 using net::test::ValueRestore;
@@ skipping 32 matching lines @@
 };
 
 class QuicTimeWaitListManagerPeer {
  public:
   static bool ShouldSendResponse(QuicTimeWaitListManager* manager,
                                  int received_packet_count) {
     return manager->ShouldSendResponse(received_packet_count);
   }
 
   static QuicTime::Delta time_wait_period(QuicTimeWaitListManager* manager) {
-    return manager->kTimeWaitPeriod_;
+    return manager->time_wait_period_;
   }
 
   static QuicVersion GetQuicVersionFromConnectionId(
       QuicTimeWaitListManager* manager,
       QuicConnectionId connection_id) {
     return manager->GetQuicVersionFromConnectionId(connection_id);
   }
 };
 
 namespace {
 
 class MockFakeTimeEpollServer : public FakeTimeEpollServer {
  public:
   MOCK_METHOD2(RegisterAlarm, void(int64 timeout_in_us,
                                    EpollAlarmCallbackInterface* alarm));
 };
 
 class QuicTimeWaitListManagerTest : public ::testing::Test {
  protected:
   QuicTimeWaitListManagerTest()
-      : time_wait_list_manager_(&writer_,
+      : helper_(&epoll_server_),
+        time_wait_list_manager_(&writer_,
                                 &visitor_,
-                                &epoll_server_,
+                                &helper_,
                                 QuicSupportedVersions()),
         framer_(QuicSupportedVersions(),
                 QuicTime::Zero(),
                 Perspective::IS_SERVER),
         connection_id_(45),
         client_address_(net::test::TestPeerIPAddress(), kTestPort),
         writer_is_blocked_(false) {}
 
   ~QuicTimeWaitListManagerTest() override {}
 
@@ skipping 53 matching lines @@
         BuildUnsizedDataPacket(&framer_, header, frames));
     EXPECT_TRUE(packet != nullptr);
     QuicEncryptedPacket* encrypted = framer_.EncryptPacket(ENCRYPTION_NONE,
                                                            sequence_number,
                                                            *packet);
     EXPECT_TRUE(encrypted != nullptr);
     return encrypted;
   }
 
   NiceMock<MockFakeTimeEpollServer> epoll_server_;
+  QuicEpollConnectionHelper helper_;
   StrictMock<MockPacketWriter> writer_;
   StrictMock<MockQuicServerSessionVisitor> visitor_;
   QuicTimeWaitListManager time_wait_list_manager_;
   QuicFramer framer_;
   QuicConnectionId connection_id_;
   IPEndPoint server_address_;
   IPEndPoint client_address_;
   bool writer_is_blocked_;
 };
 
@@ skipping 42 matching lines @@
 
 TEST_F(QuicTimeWaitListManagerTest, CheckConnectionIdInTimeWait) {
   EXPECT_FALSE(IsConnectionIdInTimeWait(connection_id_));
   EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_));
   AddConnectionId(connection_id_);
   EXPECT_EQ(1u, time_wait_list_manager_.num_connections());
   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, SendConnectionClose) {
-  size_t kConnectionCloseLength = 100;
+  const size_t kConnectionCloseLength = 100;
   EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_));
   AddConnectionId(
       connection_id_,
       QuicVersionMax(),
       new QuicEncryptedPacket(
           new char[kConnectionCloseLength], kConnectionCloseLength, true));
   const int kRandomSequenceNumber = 1;
   EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
                                    server_address_.address(),
                                    client_address_))
@@ skipping 34 matching lines @@
       EXPECT_FALSE(QuicTimeWaitListManagerPeer::ShouldSendResponse(
                        &time_wait_list_manager_, sequence_number));
     }
   }
 }
 
 TEST_F(QuicTimeWaitListManagerTest, CleanUpOldConnectionIds) {
   const size_t kConnectionIdCount = 100;
   const size_t kOldConnectionIdCount = 31;
 
-  // Add connection_ids such that their expiry time is kTimeWaitPeriod_.
+  // Add connection_ids such that their expiry time is time_wait_period_.
   epoll_server_.set_now_in_usec(0);
   for (size_t connection_id = 1; connection_id <= kOldConnectionIdCount;
        ++connection_id) {
     EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id));
     AddConnectionId(connection_id);
   }
   EXPECT_EQ(kOldConnectionIdCount, time_wait_list_manager_.num_connections());
 
   // Add remaining connection_ids such that their add time is
-  // 2 * kTimeWaitPeriod.
+  // 2 * time_wait_period_.
   const QuicTime::Delta time_wait_period =
       QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_);
   epoll_server_.set_now_in_usec(time_wait_period.ToMicroseconds());
   for (size_t connection_id = kOldConnectionIdCount + 1;
        connection_id <= kConnectionIdCount; ++connection_id) {
     EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id));
     AddConnectionId(connection_id);
   }
   EXPECT_EQ(kConnectionIdCount, time_wait_list_manager_.num_connections());
 
@@ skipping 104 matching lines @@
                 &time_wait_list_manager_, kConnectionId1));
   EXPECT_EQ(QuicVersionMax(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId(
                 &time_wait_list_manager_, kConnectionId2));
   EXPECT_EQ(QuicVersionMax(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId(
                 &time_wait_list_manager_, kConnectionId3));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, AddConnectionIdTwice) {
-  // Add connection_ids such that their expiry time is kTimeWaitPeriod_.
+  // Add connection_ids such that their expiry time is time_wait_period_.
   epoll_server_.set_now_in_usec(0);
   EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id_));
   AddConnectionId(connection_id_);
   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
-  size_t kConnectionCloseLength = 100;
+  const size_t kConnectionCloseLength = 100;
   AddConnectionId(
       connection_id_,
       QuicVersionMax(),
       new QuicEncryptedPacket(
           new char[kConnectionCloseLength], kConnectionCloseLength, true));
   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
   EXPECT_EQ(1u, time_wait_list_manager_.num_connections());
 
   EXPECT_CALL(writer_, WritePacket(_,
                                    kConnectionCloseLength,
@@ skipping 86 matching lines @@
               time_wait_list_manager_.num_connections());
     EXPECT_FALSE(IsConnectionIdInTimeWait(id_to_evict));
     EXPECT_TRUE(IsConnectionIdInTimeWait(current_connection_id));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net