Using 64-bit timestamp in webrtc/p2p

webrtc/p2p/base/port.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 34 matching lines @@
 extern const char SSLTCP_PROTOCOL_NAME[];
 
 // RFC 6544, TCP candidate encoding rules.
 extern const int DISCARD_PORT;
 extern const char TCPTYPE_ACTIVE_STR[];
 extern const char TCPTYPE_PASSIVE_STR[];
 extern const char TCPTYPE_SIMOPEN_STR[];
 
 // The minimum time we will wait before destroying a connection after creating
 // it.
-const uint32_t MIN_CONNECTION_LIFETIME = 10 * 1000;  // 10 seconds.
+static const int MIN_CONNECTION_LIFETIME = 10 * 1000;  // 10 seconds.
 
 // A connection will be declared dead if it has not received anything for this
 // long.
-const uint32_t DEAD_CONNECTION_RECEIVE_TIMEOUT = 30 * 1000;  // 30 seconds.
+static const int DEAD_CONNECTION_RECEIVE_TIMEOUT = 30 * 1000;  // 30 seconds.
 
 // The timeout duration when a connection does not receive anything.
-const uint32_t WEAK_CONNECTION_RECEIVE_TIMEOUT = 2500;  // 2.5 seconds
+static const int WEAK_CONNECTION_RECEIVE_TIMEOUT = 2500;  // 2.5 seconds
 
 // The length of time we wait before timing out writability on a connection.
-const uint32_t CONNECTION_WRITE_TIMEOUT = 15 * 1000;  // 15 seconds
+static const int CONNECTION_WRITE_TIMEOUT = 15 * 1000;  // 15 seconds
 
 // The length of time we wait before we become unwritable.
-const uint32_t CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000;  // 5 seconds
+static const int CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000;  // 5 seconds
+
+// This is the length of time that we wait for a ping response to come back.
+static const int CONNECTION_RESPONSE_TIMEOUT = 5 * 1000;  // 5 seconds
 
 // The number of pings that must fail to respond before we become unwritable.
-const uint32_t CONNECTION_WRITE_CONNECT_FAILURES = 5;
-
-// This is the length of time that we wait for a ping response to come back.
-const int CONNECTION_RESPONSE_TIMEOUT = 5 * 1000;   // 5 seconds
+static const uint32_t CONNECTION_WRITE_CONNECT_FAILURES = 5;
 
 enum RelayType {
   RELAY_GTURN,   // Legacy google relay service.
   RELAY_TURN     // Standard (TURN) relay service.
 };
 
 enum IcePriorityValue {
   // The reason we are choosing Relay preference 2 is because, we can run
   // Relay from client to server on UDP/TCP/TLS. To distinguish the transport
   // protocol, we prefer UDP over TCP over TLS.
@@ skipping 320 matching lines @@
 
   friend class Connection;
 };
 
 // Represents a communication link between a port on the local client and a
 // port on the remote client.
 class Connection : public rtc::MessageHandler,
     public sigslot::has_slots<> {
  public:
   struct SentPing {
-    SentPing(const std::string id, uint32_t sent_time)
+    SentPing(const std::string id, int64_t sent_time)
         : id(id), sent_time(sent_time) {}
 
     std::string id;
-    uint32_t sent_time;
+    int64_t sent_time;
   };
 
   // States are from RFC 5245. http://tools.ietf.org/html/rfc5245#section-5.7.4
   enum State {
     STATE_WAITING = 0,  // Check has not been performed, Waiting pair on CL.
     STATE_INPROGRESS,   // Check has been sent, transaction is in progress.
     STATE_SUCCEEDED,    // Check already done, produced a successful result.
     STATE_FAILED        // Check for this connection failed.
   };
 
@@ skipping 24 matching lines @@
   bool receiving() const { return receiving_; }
 
   // Determines whether the connection has finished connecting.  This can only
   // be false for TCP connections.
   bool connected() const { return connected_; }
   bool weak() const { return !(writable() && receiving() && connected()); }
   bool active() const {
     return write_state_ != STATE_WRITE_TIMEOUT;
   }
   // A connection is dead if it can be safely deleted.
-  bool dead(uint32_t now) const;
+  bool dead(int64_t now) const;
 
   // Estimate of the round-trip time over this connection.
-  uint32_t rtt() const { return rtt_; }
+  int rtt() const { return rtt_; }
 
   size_t sent_total_bytes();
   size_t sent_bytes_second();
   // Used to track how many packets are discarded in the application socket due
   // to errors.
   size_t sent_discarded_packets();
   size_t sent_total_packets();
   size_t recv_total_bytes();
   size_t recv_bytes_second();
   sigslot::signal1<Connection*> SignalStateChange;
@@ skipping 33 matching lines @@
   bool use_candidate_attr() const { return use_candidate_attr_; }
   void set_use_candidate_attr(bool enable);
 
   bool nominated() const { return nominated_; }
   void set_nominated(bool nominated) { nominated_ = nominated; }
 
   void set_remote_ice_mode(IceMode mode) {
     remote_ice_mode_ = mode;
   }
 
-  void set_receiving_timeout(uint32_t receiving_timeout_ms) {
+  void set_receiving_timeout(int64_t receiving_timeout_ms) {
     receiving_timeout_ = receiving_timeout_ms;
   }
 
   // Makes the connection go away.
   void Destroy();
 
   // Makes the connection go away, in a failed state.
   void FailAndDestroy();
 
   // Checks that the state of this connection is up-to-date.  The argument is
   // the current time, which is compared against various timeouts.
-  void UpdateState(uint32_t now);
+  void UpdateState(int64_t now);
 
   // Called when this connection should try checking writability again.
-  uint32_t last_ping_sent() const { return last_ping_sent_; }
-  void Ping(uint32_t now);
+  int64_t last_ping_sent() const { return last_ping_sent_; }
+  void Ping(int64_t now);
   void ReceivedPingResponse();
-  uint32_t last_ping_response_received() const {
+  int64_t last_ping_response_received() const {
     return last_ping_response_received_;
   }
 
   // Called whenever a valid ping is received on this connection.  This is
   // public because the connection intercepts the first ping for us.
-  uint32_t last_ping_received() const { return last_ping_received_; }
+  int64_t last_ping_received() const { return last_ping_received_; }
   void ReceivedPing();
   // Handles the binding request; sends a response if this is a valid request.
   void HandleBindingRequest(IceMessage* msg);
 
   // Debugging description of this connection
   std::string ToDebugId() const;
   std::string ToString() const;
   std::string ToSensitiveString() const;
   // Prints pings_since_last_response_ into a string.
   void PrintPingsSinceLastResponse(std::string* pings, size_t max);
@@ skipping 19 matching lines @@
   void MaybeSetRemoteIceCredentials(const std::string& ice_ufrag,
                                     const std::string& ice_pwd);
 
   // If |remote_candidate_| is peer reflexive and is equivalent to
   // |new_candidate| except the type, update |remote_candidate_| to
   // |new_candidate|.
   void MaybeUpdatePeerReflexiveCandidate(const Candidate& new_candidate);
 
   // Returns the last received time of any data, stun request, or stun
   // response in milliseconds
-  uint32_t last_received() const;
+  int64_t last_received() const;
 
  protected:
   enum { MSG_DELETE = 0, MSG_FIRST_AVAILABLE };
 
   // Constructs a new connection to the given remote port.
   Connection(Port* port, size_t index, const Candidate& candidate);
 
   // Called back when StunRequestManager has a stun packet to send
   void OnSendStunPacket(const void* data, size_t size, StunRequest* req);
 
@@ skipping 23 matching lines @@
   // By default |use_candidate_attr_| flag will be true,
   // as we will be using aggressive nomination.
   // But when peer is ice-lite, this flag "must" be initialized to false and
   // turn on when connection becomes "best connection".
   bool use_candidate_attr_;
   // Whether this connection has been nominated by the controlling side via
   // the use_candidate attribute.
   bool nominated_;
   IceMode remote_ice_mode_;
   StunRequestManager requests_;
-  uint32_t rtt_;
-  uint32_t last_ping_sent_;      // last time we sent a ping to the other side
-  uint32_t last_ping_received_;  // last time we received a ping from the other
-                                 // side
-  uint32_t last_data_received_;
-  uint32_t last_ping_response_received_;
+  int rtt_;
+  int64_t last_ping_sent_;      // last time we sent a ping to the other side
+  int64_t last_ping_received_;  // last time we received a ping from the other
+                                // side
+  int64_t last_data_received_;
+  int64_t last_ping_response_received_;
   std::vector<SentPing> pings_since_last_response_;
 
   rtc::RateTracker recv_rate_tracker_;
   rtc::RateTracker send_rate_tracker_;
   uint32_t sent_packets_discarded_;
   uint32_t sent_packets_total_;
 
  private:
   void MaybeAddPrflxCandidate(ConnectionRequest* request,
                               StunMessage* response);
 
   bool reported_;
   State state_;
   // Time duration to switch from receiving to not receiving.
-  uint32_t receiving_timeout_;
-  uint32_t time_created_ms_;
+  int receiving_timeout_;
+  int64_t time_created_ms_;
 
   friend class Port;
   friend class ConnectionRequest;
 };
 
 // ProxyConnection defers all the interesting work to the port.
 class ProxyConnection : public Connection {
  public:
   ProxyConnection(Port* port, size_t index, const Candidate& remote_candidate);
 
   int Send(const void* data,
            size_t size,
            const rtc::PacketOptions& options) override;
   int GetError() override { return error_; }
 
  private:
   int error_ = 0;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORT_H_