Rename rtc::Time64 --> rtc::TimeMillis.

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) {
-    int64_t connect_start = rtc::Time64();
+    int64_t connect_start = rtc::TimeMillis();
     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::Time64() - connect_start;
+    connect_time = rtc::TimeMillis() - 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()) {
-      int64_t converge_start = rtc::Time64();
+      int64_t converge_start = rtc::TimeMillis();
       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::Time64() - converge_start;
+      converge_time = rtc::TimeMillis() - 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 2234 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);
 }