Using 64-bit timestamp in webrtc/p2p

webrtc/p2p/base/stunport.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.
  */
 
@@ skipping 17 matching lines @@
 // Lifetime chosen for STUN ports on low-cost networks.
 const int INFINITE_LIFETIME = -1;
 // Lifetime for STUN ports on high-cost networks: 2 minutes
 const int HIGH_COST_PORT_KEEPALIVE_LIFETIME = 2 * 60 * 1000;
 
 // Handles a binding request sent to the STUN server.
 class StunBindingRequest : public StunRequest {
  public:
   StunBindingRequest(UDPPort* port,
                      const rtc::SocketAddress& addr,
-                     uint32_t start_time,
+                     int64_t start_time,
                      int lifetime)
       : port_(port),
         server_addr_(addr),
         start_time_(start_time),
         lifetime_(lifetime) {}
 
   virtual ~StunBindingRequest() {
   }
 
   const rtc::SocketAddress& server_addr() const { return server_addr_; }
 
   virtual void Prepare(StunMessage* request) override {
     request->SetType(STUN_BINDING_REQUEST);
   }
 
   virtual void OnResponse(StunMessage* response) override {
     const StunAddressAttribute* addr_attr =
         response->GetAddress(STUN_ATTR_MAPPED_ADDRESS);
     if (!addr_attr) {
       LOG(LS_ERROR) << "Binding response missing mapped address.";
     } else if (addr_attr->family() != STUN_ADDRESS_IPV4 &&
                addr_attr->family() != STUN_ADDRESS_IPV6) {
       LOG(LS_ERROR) << "Binding address has bad family";
     } else {
       rtc::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
       port_->OnStunBindingRequestSucceeded(server_addr_, addr);
     }
 
     // The keep-alive requests will be stopped after its lifetime has passed.
-    if (WithinLifetime(rtc::Time())) {
+    if (WithinLifetime(rtc::Time64())) {
       port_->requests_.SendDelayed(
           new StunBindingRequest(port_, server_addr_, start_time_, lifetime_),
           port_->stun_keepalive_delay());
     }
   }
 
   virtual void OnErrorResponse(StunMessage* response) override {
     const StunErrorCodeAttribute* attr = response->GetErrorCode();
     if (!attr) {
       LOG(LS_ERROR) << "Bad allocate response error code";
     } else {
       LOG(LS_ERROR) << "Binding error response:"
                     << " class=" << attr->eclass()
                     << " number=" << attr->number() << " reason='"
                     << attr->reason() << "'";
     }
 
     port_->OnStunBindingOrResolveRequestFailed(server_addr_);
 
-    uint32_t now = rtc::Time();
+    int64_t now = rtc::Time64();
     if (WithinLifetime(now) &&
-        rtc::TimeDiff(now, start_time_) < RETRY_TIMEOUT) {
+        rtc::TimeDiff64(now, start_time_) < RETRY_TIMEOUT) {
       port_->requests_.SendDelayed(
           new StunBindingRequest(port_, server_addr_, start_time_, lifetime_),
           port_->stun_keepalive_delay());
     }
   }
   virtual void OnTimeout() override {
     LOG(LS_ERROR) << "Binding request timed out from "
                   << port_->GetLocalAddress().ToSensitiveString() << " ("
                   << port_->Network()->name() << ")";
 
     port_->OnStunBindingOrResolveRequestFailed(server_addr_);
   }
 
  private:
   // Returns true if |now| is within the lifetime of the request (a negative
   // lifetime means infinite).
-  bool WithinLifetime(uint32_t now) const {
-    return lifetime_ < 0 || rtc::TimeDiff(now, start_time_) <= lifetime_;
+  bool WithinLifetime(int64_t now) const {
+    return lifetime_ < 0 || rtc::TimeDiff64(now, start_time_) <= lifetime_;
   }
   UDPPort* port_;
   const rtc::SocketAddress server_addr_;
 
-  uint32_t start_time_;
+  int64_t start_time_;
   // The time duration for which this request will be rescheduled.
   int lifetime_;
 };
 
 UDPPort::AddressResolver::AddressResolver(
     rtc::PacketSocketFactory* factory)
     : socket_factory_(factory) {}
 
 UDPPort::AddressResolver::~AddressResolver() {
   for (ResolverMap::iterator it = resolvers_.begin();
@@ skipping 280 matching lines @@
   }
 }
 
 void UDPPort::SendStunBindingRequest(const rtc::SocketAddress& stun_addr) {
   if (stun_addr.IsUnresolvedIP()) {
     ResolveStunAddress(stun_addr);
 
   } else if (socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND) {
     // Check if |server_addr_| is compatible with the port's ip.
     if (IsCompatibleAddress(stun_addr)) {
-      requests_.Send(new StunBindingRequest(this, stun_addr, rtc::Time(),
+      requests_.Send(new StunBindingRequest(this, stun_addr, rtc::Time64(),
                                             stun_keepalive_lifetime_));
     } else {
       // Since we can't send stun messages to the server, we should mark this
       // port ready.
       LOG(LS_WARNING) << "STUN server address is incompatible.";
       OnStunBindingOrResolveRequestFailed(stun_addr);
     }
   }
 }
 
@@ skipping 94 matching lines @@
   const std::vector<Candidate>& existing_candidates = Candidates();
   std::vector<Candidate>::const_iterator it = existing_candidates.begin();
   for (; it != existing_candidates.end(); ++it) {
     if (it->address() == addr)
       return true;
   }
   return false;
 }
 
 }  // namespace cricket