Using 64-bit timestamp in webrtc/p2p

webrtc/p2p/base/relayport.cc

 /*
  *  Copyright 2004 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.
  */
 #include <algorithm>
 
 #include "webrtc/p2p/base/relayport.h"
 #include "webrtc/base/asyncpacketsocket.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 
 namespace cricket {
 
-static const uint32_t kMessageConnectTimeout = 1;
+static const int kMessageConnectTimeout = 1;
 static const int kKeepAliveDelay           = 10 * 60 * 1000;
 static const int kRetryTimeout             = 50 * 1000;  // ICE says 50 secs
 // How long to wait for a socket to connect to remote host in milliseconds
 // before trying another connection.
 static const int kSoftConnectTimeoutMs     = 3 * 1000;
 
 // Handles a connection to one address/port/protocol combination for a
 // particular RelayEntry.
 class RelayConnection : public sigslot::has_slots<> {
  public:
@@ skipping 138 matching lines @@
   void OnSent() override;
   int resend_delay() override;
 
   void OnResponse(StunMessage* response) override;
   void OnErrorResponse(StunMessage* response) override;
   void OnTimeout() override;
 
  private:
   RelayEntry* entry_;
   RelayConnection* connection_;
-  uint32_t start_time_;
+  int64_t start_time_;
 };
 
 RelayPort::RelayPort(rtc::Thread* thread,
                      rtc::PacketSocketFactory* factory,
                      rtc::Network* network,
                      const rtc::IPAddress& ip,
                      uint16_t min_port,
                      uint16_t max_port,
                      const std::string& username,
                      const std::string& password)
@@ skipping 583 matching lines @@
     sent = current_connection_->Send(data, size, options);
   }
   return sent;
 }
 
 AllocateRequest::AllocateRequest(RelayEntry* entry,
                                  RelayConnection* connection)
     : StunRequest(new RelayMessage()),
       entry_(entry),
       connection_(connection) {
-  start_time_ = rtc::Time();
+  start_time_ = rtc::Time64();
 }
 
 void AllocateRequest::Prepare(StunMessage* request) {
   request->SetType(STUN_ALLOCATE_REQUEST);
 
   StunByteStringAttribute* username_attr =
       StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
   username_attr->CopyBytes(
       entry_->port()->username_fragment().c_str(),
       entry_->port()->username_fragment().size());
@@ skipping 34 matching lines @@
 void AllocateRequest::OnErrorResponse(StunMessage* response) {
   const StunErrorCodeAttribute* attr = response->GetErrorCode();
   if (!attr) {
     LOG(INFO) << "Bad allocate response error code";
   } else {
     LOG(INFO) << "Allocate error response:"
               << " code=" << attr->code()
               << " reason='" << attr->reason() << "'";
   }
 
-  if (rtc::TimeSince(start_time_) <= kRetryTimeout)
+  if (rtc::Time64() - start_time_ <= kRetryTimeout)
     entry_->ScheduleKeepAlive();
 }
 
 void AllocateRequest::OnTimeout() {
   LOG(INFO) << "Allocate request timed out";
   entry_->HandleConnectFailure(connection_->socket());
 }
 
 }  // namespace cricket