Using 64-bit timestamp in webrtc/p2p

webrtc/p2p/base/relayserver.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 337 matching lines @@
   RelayServerBinding* binding;
 
   BindingMap::iterator biter = bindings_.find(username);
   if (biter != bindings_.end()) {
     binding = biter->second;
   } else {
     // NOTE: In the future, bindings will be created by the bot only.  This
     //       else-branch will then disappear.
 
     // Compute the appropriate lifetime for this binding.
-    uint32_t lifetime = MAX_LIFETIME;
+    int lifetime = MAX_LIFETIME;
     const StunUInt32Attribute* lifetime_attr =
         request.GetUInt32(STUN_ATTR_LIFETIME);
     if (lifetime_attr)
-      lifetime = std::min(lifetime, lifetime_attr->value() * 1000);
+      lifetime =
+          std::min(lifetime, static_cast<int>(lifetime_attr->value() * 1000));
 
     binding = new RelayServerBinding(this, username, "0", lifetime);
     binding->SignalTimeout.connect(this, &RelayServer::OnTimeout);
     bindings_[username] = binding;
 
     if (log_bindings_) {
       LOG(LS_INFO) << "Added new binding " << username << ", "
                    << bindings_.size() << " total";
     }
   }
@@ skipping 273 matching lines @@
 void RelayServerConnection::Unlock() {
   locked_ = false;
 }
 
 // IDs used for posted messages:
 const uint32_t MSG_LIFETIME_TIMER = 1;
 
 RelayServerBinding::RelayServerBinding(RelayServer* server,
                                        const std::string& username,
                                        const std::string& password,
-                                       uint32_t lifetime)
+                                       int lifetime)
     : server_(server),
       username_(username),
       password_(password),
       lifetime_(lifetime) {
   // For now, every connection uses the standard magic cookie value.
   magic_cookie_.append(
       reinterpret_cast<const char*>(TURN_MAGIC_COOKIE_VALUE),
       sizeof(TURN_MAGIC_COOKIE_VALUE));
 
   // Initialize the last-used time to now.
@@ skipping 19 matching lines @@
 
 void RelayServerBinding::AddInternalConnection(RelayServerConnection* conn) {
   internal_connections_.push_back(conn);
 }
 
 void RelayServerBinding::AddExternalConnection(RelayServerConnection* conn) {
   external_connections_.push_back(conn);
 }
 
 void RelayServerBinding::NoteUsed() {
-  last_used_ = rtc::Time();
+  last_used_ = rtc::Time64();
 }
 
 bool RelayServerBinding::HasMagicCookie(const char* bytes, size_t size) const {
   if (size < 24 + magic_cookie_.size()) {
     return false;
   } else {
     return memcmp(bytes + 24, magic_cookie_.c_str(), magic_cookie_.size()) == 0;
   }
 }
 
@@ skipping 20 matching lines @@
   }
   return 0;
 }
 
 void RelayServerBinding::OnMessage(rtc::Message *pmsg) {
   if (pmsg->message_id == MSG_LIFETIME_TIMER) {
     ASSERT(!pmsg->pdata);
 
     // If the lifetime timeout has been exceeded, then send a signal.
     // Otherwise, just keep waiting.
-    if (rtc::Time() >= last_used_ + lifetime_) {
+    if (rtc::Time64() >= last_used_ + lifetime_) {
       LOG(LS_INFO) << "Expiring binding " << username_;
       SignalTimeout(this);
     } else {
       server_->thread()->PostDelayed(lifetime_, this, MSG_LIFETIME_TIMER);
     }
 
   } else {
     ASSERT(false);
   }
 }
 
 }  // namespace cricket