Using 64-bit timestamp in webrtc/p2p

webrtc/p2p/base/p2ptransportchannel.h

 /*
  *  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 202 matching lines @@
                          PortInterface* origin_port);
   bool CreateConnection(PortInterface* port,
                         const Candidate& remote_candidate,
                         PortInterface* origin_port);
   bool FindConnection(cricket::Connection* connection) const;
 
   uint32_t GetRemoteCandidateGeneration(const Candidate& candidate);
   bool IsDuplicateRemoteCandidate(const Candidate& candidate);
   void RememberRemoteCandidate(const Candidate& remote_candidate,
                                PortInterface* origin_port);
-  bool IsPingable(Connection* conn, uint32_t now);
+  bool IsPingable(Connection* conn, int64_t now);
   void PingConnection(Connection* conn);
   void AddAllocatorSession(PortAllocatorSession* session);
   void AddConnection(Connection* connection);
 
   void OnPortReady(PortAllocatorSession *session, PortInterface* port);
   void OnCandidatesReady(PortAllocatorSession *session,
                          const std::vector<Candidate>& candidates);
   void OnCandidatesAllocationDone(PortAllocatorSession* session);
   void OnUnknownAddress(PortInterface* port,
                         const rtc::SocketAddress& addr,
@@ skipping 15 matching lines @@
   void OnNominated(Connection* conn);
 
   void OnMessage(rtc::Message* pmsg) override;
   void OnSort();
   void OnCheckAndPing();
 
   void PruneConnections();
   Connection* best_nominated_connection() const;
   bool IsBackupConnection(Connection* conn) const;
 
-  Connection* FindConnectionToPing(uint32_t now);
-  Connection* FindOldestConnectionNeedingTriggeredCheck(uint32_t now);
+  Connection* FindConnectionToPing(int64_t now);
+  Connection* FindOldestConnectionNeedingTriggeredCheck(int64_t now);
   // Between |conn1| and |conn2|, this function returns the one which should
   // be pinged first.
   Connection* SelectMostPingableConnection(Connection* conn1,
                                            Connection* conn2);
   // Select the connection which is Relay/Relay. If both of them are,
   // UDP relay protocol takes precedence.
   Connection* MostLikelyToWork(Connection* conn1, Connection* conn2);
   // Compare the last_ping_sent time and return the one least recently pinged.
   Connection* LeastRecentlyPinged(Connection* conn1, Connection* conn2);
 
@@ skipping 43 matching lines @@
   OptionMap options_;
   std::string ice_ufrag_;
   std::string ice_pwd_;
   std::vector<IceParameters> remote_ice_parameters_;
   IceMode remote_ice_mode_;
   IceRole ice_role_;
   uint64_t tiebreaker_;
   IceGatheringState gathering_state_;
 
   int check_receiving_interval_;
-  uint32_t last_ping_sent_ms_ = 0;
+  int64_t last_ping_sent_ms_ = 0;
   int weak_ping_interval_ = WEAK_PING_INTERVAL;
   TransportChannelState state_ = TransportChannelState::STATE_INIT;
   IceConfig config_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(P2PTransportChannel);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_