Using 64-bit timestamp in webrtc/p2p

webrtc/p2p/base/p2ptransportchannel_unittest.cc

 /*
  *  Copyright 2009 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 486 matching lines @@
     if (remote_type != expected.remote_type2) {
       EXPECT_TRUE(expected.remote_type2 == cricket::LOCAL_PORT_TYPE ||
                   expected.remote_type2 == cricket::STUN_PORT_TYPE);
       EXPECT_TRUE(remote_type == cricket::LOCAL_PORT_TYPE ||
                   remote_type == cricket::STUN_PORT_TYPE ||
                   remote_type == cricket::PRFLX_PORT_TYPE);
     }
   }
 
   void Test(const Result& expected) {
-    int32_t connect_start = rtc::Time(), connect_time;
+    int64_t connect_start = rtc::Time64();
+    int64_t connect_time;
 
     // Create the channels and wait for them to connect.
     CreateChannels(1);
     EXPECT_TRUE_WAIT_MARGIN(ep1_ch1() != NULL &&
                             ep2_ch1() != NULL &&
                             ep1_ch1()->receiving() &&
                             ep1_ch1()->writable() &&
                             ep2_ch1()->receiving() &&
                             ep2_ch1()->writable(),
                             expected.connect_wait,
                             1000);
-    connect_time = rtc::TimeSince(connect_start);
+    connect_time = rtc::Time64() - connect_start;
     if (connect_time < expected.connect_wait) {
       LOG(LS_INFO) << "Connect time: " << connect_time << " ms";
     } else {
       LOG(LS_INFO) << "Connect time: " << "TIMEOUT ("
                    << expected.connect_wait << " ms)";
     }
 
     // Allow a few turns of the crank for the best connections to emerge.
     // This may take up to 2 seconds.
     if (ep1_ch1()->best_connection() &&
         ep2_ch1()->best_connection()) {
-      int32_t converge_start = rtc::Time(), converge_time;
-      int converge_wait = 2000;
+      int64_t converge_start = rtc::Time64();
+      int64_t converge_time;
+      int64_t converge_wait = 2000;
       EXPECT_TRUE_WAIT_MARGIN(CheckCandidate1(expected), converge_wait,
                               converge_wait);
       // Also do EXPECT_EQ on each part so that failures are more verbose.
       ExpectCandidate1(expected);
 
       // Verifying remote channel best connection information. This is done
       // only for the RFC 5245 as controlled agent will use USE-CANDIDATE
       // from controlling (ep1) agent. We can easily predict from EP1 result
       // matrix.
 
       // Checking for best connection candidates information at remote.
       EXPECT_TRUE_WAIT(CheckCandidate2(expected), kDefaultTimeout);
       // For verbose
       ExpectCandidate2(expected);
 
-      converge_time = rtc::TimeSince(converge_start);
+      converge_time = rtc::Time64() - converge_start;
       if (converge_time < converge_wait) {
         LOG(LS_INFO) << "Converge time: " << converge_time << " ms";
       } else {
         LOG(LS_INFO) << "Converge time: " << "TIMEOUT ("
                      << converge_wait << " ms)";
       }
     }
     // Try sending some data to other end.
     TestSendRecv(1);
 
@@ skipping 1205 matching lines @@
   int backup_ping_interval = 2000;
   ep2_ch1()->SetIceConfig(CreateIceConfig(2000, false, backup_ping_interval));
   // After the state becomes COMPLETED, the backup connection will be pinged
   // once every |backup_ping_interval| milliseconds.
   ASSERT_TRUE_WAIT(ep2_ch1()->GetState() == cricket::STATE_COMPLETED, 1000);
   const std::vector<cricket::Connection*>& connections =
       ep2_ch1()->connections();
   ASSERT_EQ(2U, connections.size());
   cricket::Connection* backup_conn = connections[1];
   EXPECT_TRUE_WAIT(backup_conn->writable(), 3000);
-  uint32_t last_ping_response_ms = backup_conn->last_ping_response_received();
+  int64_t last_ping_response_ms = backup_conn->last_ping_response_received();
   EXPECT_TRUE_WAIT(
       last_ping_response_ms < backup_conn->last_ping_response_received(), 5000);
   int time_elapsed =
       backup_conn->last_ping_response_received() - last_ping_response_ms;
   LOG(LS_INFO) << "Time elapsed: " << time_elapsed;
   EXPECT_GE(time_elapsed, backup_ping_interval);
 }
 
 TEST_F(P2PTransportChannelMultihomedTest, TestGetState) {
   AddAddress(0, kAlternateAddrs[0]);
@@ skipping 934 matching lines @@
 
   // TCP Relay/Relay is the next.
   VerifyNextPingableConnection(cricket::RELAY_PORT_TYPE,
                                cricket::RELAY_PORT_TYPE,
                                cricket::TCP_PROTOCOL_NAME);
 
   // Finally, Local/Relay will be pinged.
   VerifyNextPingableConnection(cricket::LOCAL_PORT_TYPE,
                                cricket::RELAY_PORT_TYPE);
 }