Using 64-bit timestamp in webrtc/p2p

webrtc/p2p/base/turnport.cc

 /*
  *  Copyright 2012 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 127 matching lines @@
 
   TurnPort* port() { return port_; }
 
   int channel_id() const { return channel_id_; }
   // For testing only.
   void set_channel_id(int channel_id) { channel_id_ = channel_id; }
 
   const rtc::SocketAddress& address() const { return ext_addr_; }
   BindState state() const { return state_; }
 
-  uint32_t destruction_timestamp() { return destruction_timestamp_; }
-  void set_destruction_timestamp(uint32_t destruction_timestamp) {
+  int64_t destruction_timestamp() { return destruction_timestamp_; }
+  void set_destruction_timestamp(int64_t destruction_timestamp) {
     destruction_timestamp_ = destruction_timestamp;
   }
 
   // Helper methods to send permission and channel bind requests.
   void SendCreatePermissionRequest(int delay);
   void SendChannelBindRequest(int delay);
   // Sends a packet to the given destination address.
   // This will wrap the packet in STUN if necessary.
   int Send(const void* data, size_t size, bool payload,
            const rtc::PacketOptions& options);
 
   void OnCreatePermissionSuccess();
   void OnCreatePermissionError(StunMessage* response, int code);
   void OnCreatePermissionTimeout();
   void OnChannelBindSuccess();
   void OnChannelBindError(StunMessage* response, int code);
   void OnChannelBindTimeout();
   // Signal sent when TurnEntry is destroyed.
   sigslot::signal1<TurnEntry*> SignalDestroyed;
 
  private:
   TurnPort* port_;
   int channel_id_;
   rtc::SocketAddress ext_addr_;
   BindState state_;
   // A non-zero value indicates that this entry is scheduled to be destroyed.
   // It is also used as an ID of the event scheduling. When the destruction
   // event actually fires, the TurnEntry will be destroyed only if the
   // timestamp here matches the one in the firing event.
-  uint32_t destruction_timestamp_ = 0;
+  int64_t destruction_timestamp_ = 0;
 };
 
 TurnPort::TurnPort(rtc::Thread* thread,
                    rtc::PacketSocketFactory* factory,
                    rtc::Network* network,
                    rtc::AsyncPacketSocket* socket,
                    const std::string& username,
                    const std::string& password,
                    const ProtocolAddress& server_address,
                    const RelayCredentials& credentials,
@@ skipping 793 matching lines @@
   }
 }
 
 void TurnPort::DestroyEntry(TurnEntry* entry) {
   ASSERT(entry != NULL);
   entry->SignalDestroyed(entry);
   entries_.remove(entry);
   delete entry;
 }
 
-void TurnPort::DestroyEntryIfNotCancelled(TurnEntry* entry,
-                                          uint32_t timestamp) {
+void TurnPort::DestroyEntryIfNotCancelled(TurnEntry* entry, int64_t timestamp) {
   if (!EntryExists(entry)) {
     return;
   }
   bool cancelled = timestamp != entry->destruction_timestamp();
   if (!cancelled) {
     DestroyEntry(entry);
   }
 }
 
 void TurnPort::OnConnectionDestroyed(Connection* conn) {
   // Schedule an event to destroy TurnEntry for the connection, which is
   // already destroyed.
   const rtc::SocketAddress& remote_address = conn->remote_candidate().address();
   TurnEntry* entry = FindEntry(remote_address);
   ASSERT(entry != NULL);
   ScheduleEntryDestruction(entry);
 }
 
 void TurnPort::ScheduleEntryDestruction(TurnEntry* entry) {
   ASSERT(entry->destruction_timestamp() == 0);
-  uint32_t timestamp = rtc::Time();
+  int64_t timestamp = rtc::Time64();
   entry->set_destruction_timestamp(timestamp);
   invoker_.AsyncInvokeDelayed<void>(
       thread(),
       rtc::Bind(&TurnPort::DestroyEntryIfNotCancelled, this, entry, timestamp),
       TURN_PERMISSION_TIMEOUT);
 }
 
 void TurnPort::CancelEntryDestruction(TurnEntry* entry) {
   ASSERT(entry->destruction_timestamp() != 0);
   entry->set_destruction_timestamp(0);
@@ skipping 487 matching lines @@
   } else {
     state_ = STATE_UNBOUND;
     port_->DestroyConnection(ext_addr_);
   }
 }
 void TurnEntry::OnChannelBindTimeout() {
   state_ = STATE_UNBOUND;
   port_->DestroyConnection(ext_addr_);
 }
 }  // namespace cricket