Switch to standard integer types in net/.

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 71 matching lines @@
       QuicConnectionId connection_id) {
     return manager->GetQuicVersionFromConnectionId(connection_id);
   }
 };
 
 namespace {
 
 class MockFakeTimeEpollServer : public FakeTimeEpollServer {
  public:
   MOCK_METHOD2(RegisterAlarm,
-               void(int64 timeout_in_us, EpollAlarmCallbackInterface* alarm));
+               void(int64_t timeout_in_us, EpollAlarmCallbackInterface* alarm));
 };
 
 class QuicTimeWaitListManagerTest : public ::testing::Test {
  protected:
   QuicTimeWaitListManagerTest()
       : helper_(&epoll_server_),
         time_wait_list_manager_(&writer_, &visitor_, &helper_),
         connection_id_(45),
         client_address_(net::test::TestPeerIPAddress(), kTestPort),
         writer_is_blocked_(false) {}
@@ skipping 221 matching lines @@
     EXPECT_CALL(visitor_, OnConnectionAddedToTimeWaitList(connection_id));
     AddConnectionId(connection_id);
   }
   EXPECT_EQ(kConnectionIdCount, time_wait_list_manager_.num_connections());
 
   QuicTime::Delta offset = QuicTime::Delta::FromMicroseconds(39);
   // Now set the current time as time_wait_period + offset usecs.
   epoll_server_.set_now_in_usec(time_wait_period.Add(offset).ToMicroseconds());
   // After all the old connection_ids are cleaned up, check the next alarm
   // interval.
-  int64 next_alarm_time = epoll_server_.ApproximateNowInUsec() +
-                          time_wait_period.Subtract(offset).ToMicroseconds();
+  int64_t next_alarm_time = epoll_server_.ApproximateNowInUsec() +
+                            time_wait_period.Subtract(offset).ToMicroseconds();
   EXPECT_CALL(epoll_server_, RegisterAlarm(next_alarm_time, _));
 
   for (size_t connection_id = 1; connection_id <= kConnectionIdCount;
        ++connection_id) {
     if (connection_id <= kOldConnectionIdCount) {
       EXPECT_CALL(visitor_, OnConnectionRemovedFromTimeWaitList(connection_id));
     }
   }
   time_wait_list_manager_.CleanUpOldConnectionIds();
   for (size_t connection_id = 1; connection_id <= kConnectionIdCount;
@@ skipping 108 matching lines @@
   const int kRandomSequenceNumber = 1;
   ProcessPacket(connection_id_, kRandomSequenceNumber);
 
   const QuicTime::Delta time_wait_period =
       QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_);
 
   QuicTime::Delta offset = QuicTime::Delta::FromMicroseconds(39);
   // Now set the current time as time_wait_period + offset usecs.
   epoll_server_.set_now_in_usec(time_wait_period.Add(offset).ToMicroseconds());
   // After the connection_ids are cleaned up, check the next alarm interval.
-  int64 next_alarm_time =
+  int64_t next_alarm_time =
       epoll_server_.ApproximateNowInUsec() + time_wait_period.ToMicroseconds();
 
   EXPECT_CALL(epoll_server_, RegisterAlarm(next_alarm_time, _));
   EXPECT_CALL(visitor_, OnConnectionRemovedFromTimeWaitList(connection_id_));
   time_wait_list_manager_.CleanUpOldConnectionIds();
   EXPECT_FALSE(IsConnectionIdInTimeWait(connection_id_));
   EXPECT_EQ(0u, time_wait_list_manager_.num_connections());
 }
 
 TEST_F(QuicTimeWaitListManagerTest, ConnectionIdsOrderedByTime) {
@@ skipping 28 matching lines @@
   EXPECT_EQ(1u, time_wait_list_manager_.num_connections());
 }
 
 TEST_F(QuicTimeWaitListManagerTest, MaxConnectionsTest) {
   // Basically, shut off time-based eviction.
   FLAGS_quic_time_wait_list_seconds = 10000000000;
   FLAGS_quic_time_wait_list_max_connections = 5;
 
   QuicConnectionId current_connection_id = 0;
   // Add exactly the maximum number of connections
-  for (int64 i = 0; i < FLAGS_quic_time_wait_list_max_connections; ++i) {
+  for (int64_t i = 0; i < FLAGS_quic_time_wait_list_max_connections; ++i) {
     ++current_connection_id;
     EXPECT_FALSE(IsConnectionIdInTimeWait(current_connection_id));
     EXPECT_CALL(visitor_,
                 OnConnectionAddedToTimeWaitList(current_connection_id));
     AddConnectionId(current_connection_id);
     EXPECT_EQ(current_connection_id, time_wait_list_manager_.num_connections());
     EXPECT_TRUE(IsConnectionIdInTimeWait(current_connection_id));
   }
 
   // Now keep adding.  Since we're already at the max, every new connection-id
   // will evict the oldest one.
-  for (int64 i = 0; i < FLAGS_quic_time_wait_list_max_connections; ++i) {
+  for (int64_t i = 0; i < FLAGS_quic_time_wait_list_max_connections; ++i) {
     ++current_connection_id;
     const QuicConnectionId id_to_evict =
         current_connection_id - FLAGS_quic_time_wait_list_max_connections;
     EXPECT_TRUE(IsConnectionIdInTimeWait(id_to_evict));
     EXPECT_FALSE(IsConnectionIdInTimeWait(current_connection_id));
     EXPECT_CALL(visitor_, OnConnectionRemovedFromTimeWaitList(id_to_evict));
     EXPECT_CALL(visitor_,
                 OnConnectionAddedToTimeWaitList(current_connection_id));
     AddConnectionId(current_connection_id);
     EXPECT_EQ(static_cast<size_t>(FLAGS_quic_time_wait_list_max_connections),
               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