Using 64-bit timestamp in webrtc/p2p

webrtc/p2p/stunprober/stunprober.cc

 /*
  *  Copyright 2015 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 143 matching lines @@
   // request timing could become too complicated. Callback is ignored by passing
   // empty AsyncCallback.
   rtc::PacketOptions options;
   int rv = socket_->SendTo(const_cast<char*>(request_packet->Data()),
                            request_packet->Length(), addr, options);
   if (rv < 0) {
     prober_->ReportOnFinished(WRITE_FAILED);
     return;
   }
 
-  request.sent_time_ms = rtc::Time();
+  request.sent_time_ms = rtc::Time64();
 
   num_request_sent_++;
   RTC_DCHECK(static_cast<size_t>(num_request_sent_) <= server_ips_.size());
 }
 
 void StunProber::Requester::Request::ProcessResponse(const char* buf,
                                                      size_t buf_len) {
-  int64_t now = rtc::Time();
+  int64_t now = rtc::Time64();
   rtc::ByteBuffer message(buf, buf_len);
   cricket::StunMessage stun_response;
   if (!stun_response.Read(&message)) {
     // Invalid or incomplete STUN packet.
     received_time_ms = 0;
     return;
   }
 
   // Get external address of the socket.
   const cricket::StunAddressAttribute* addr_attr =
@@ skipping 204 matching lines @@
     requesters_.push_back(current_requester_);
   }
   if (!current_requester_) {
     return false;
   }
   current_requester_->SendStunRequest();
   num_request_sent_++;
   return true;
 }
 
-bool StunProber::should_send_next_request(uint32_t now) {
+bool StunProber::should_send_next_request(int64_t now) {
   if (interval_ms_ < THREAD_WAKE_UP_INTERVAL_MS) {
     return now >= next_request_time_ms_;
   } else {
     return (now + (THREAD_WAKE_UP_INTERVAL_MS / 2)) >= next_request_time_ms_;
   }
 }
 
 int StunProber::get_wake_up_interval_ms() {
   if (interval_ms_ < THREAD_WAKE_UP_INTERVAL_MS) {
     return 1;
   } else {
     return THREAD_WAKE_UP_INTERVAL_MS;
   }
 }
 
 void StunProber::MaybeScheduleStunRequests() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  uint32_t now = rtc::Time();
+  int64_t now = rtc::Time64();
 
   if (Done()) {
     invoker_.AsyncInvokeDelayed<void>(
         thread_, rtc::Bind(&StunProber::ReportOnFinished, this, SUCCESS),
         timeout_ms_);
     return;
   }
   if (should_send_next_request(now)) {
     if (!SendNextRequest()) {
       ReportOnFinished(GENERIC_FAILURE);
@@ skipping 135 matching lines @@
   }
 }
 
 void StunProber::ReportOnFinished(StunProber::Status status) {
   if (observer_) {
     observer_->OnFinished(this, status);
   }
 }
 
 }  // namespace stunprober