Use suffixed {uint,int}{8,16,32,64}_t types.

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 MIN_CONNECTION_LIFETIME = 10 * 1000;  // 10 seconds.
+const uint32_t MIN_CONNECTION_LIFETIME = 10 * 1000;  // 10 seconds.
 
 // The timeout duration when a connection does not receive anything.
-const uint32 WEAK_CONNECTION_RECEIVE_TIMEOUT = 2500;  // 2.5 seconds
+const uint32_t WEAK_CONNECTION_RECEIVE_TIMEOUT = 2500;  // 2.5 seconds
 
 // The length of time we wait before timing out writability on a connection.
-const uint32 CONNECTION_WRITE_TIMEOUT = 15 * 1000;  // 15 seconds
+const uint32_t CONNECTION_WRITE_TIMEOUT = 15 * 1000;  // 15 seconds
 
 // The length of time we wait before we become unwritable.
-const uint32 CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000;  // 5 seconds
+const uint32_t CONNECTION_WRITE_CONNECT_TIMEOUT = 5 * 1000;  // 5 seconds
 
 // The number of pings that must fail to respond before we become unwritable.
-const uint32 CONNECTION_WRITE_CONNECT_FAILURES = 5;
+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
 
 enum RelayType {
   RELAY_GTURN,   // Legacy google relay service.
   RELAY_TURN     // Standard (TURN) relay service.
 };
 
 enum IcePriorityValue {
@@ skipping 37 matching lines @@
        rtc::PacketSocketFactory* factory,
        rtc::Network* network,
        const rtc::IPAddress& ip,
        const std::string& username_fragment,
        const std::string& password);
   Port(rtc::Thread* thread,
        const std::string& type,
        rtc::PacketSocketFactory* factory,
        rtc::Network* network,
        const rtc::IPAddress& ip,
-       uint16 min_port,
-       uint16 max_port,
+       uint16_t min_port,
+       uint16_t max_port,
        const std::string& username_fragment,
        const std::string& password);
   virtual ~Port();
 
   virtual const std::string& Type() const { return type_; }
   virtual rtc::Network* Network() const { return network_; }
 
   // Methods to set/get ICE role and tiebreaker values.
   IceRole GetIceRole() const { return ice_role_; }
   void SetIceRole(IceRole role) { ice_role_ = role; }
 
-  void SetIceTiebreaker(uint64 tiebreaker) { tiebreaker_ = tiebreaker; }
-  uint64 IceTiebreaker() const { return tiebreaker_; }
+  void SetIceTiebreaker(uint64_t tiebreaker) { tiebreaker_ = tiebreaker; }
+  uint64_t IceTiebreaker() const { return tiebreaker_; }
 
   virtual bool SharedSocket() const { return shared_socket_; }
   void ResetSharedSocket() { shared_socket_ = false; }
 
   // The thread on which this port performs its I/O.
   rtc::Thread* thread() { return thread_; }
 
   // The factory used to create the sockets of this port.
   rtc::PacketSocketFactory* socket_factory() const { return factory_; }
   void set_socket_factory(rtc::PacketSocketFactory* factory) {
@@ skipping 10 matching lines @@
   void set_component(int component) { component_ = component; }
 
   bool send_retransmit_count_attribute() const {
     return send_retransmit_count_attribute_;
   }
   void set_send_retransmit_count_attribute(bool enable) {
     send_retransmit_count_attribute_ = enable;
   }
 
   // Identifies the generation that this port was created in.
-  uint32 generation() { return generation_; }
-  void set_generation(uint32 generation) { generation_ = generation; }
+  uint32_t generation() { return generation_; }
+  void set_generation(uint32_t generation) { generation_ = generation; }
 
   // ICE requires a single username/password per content/media line. So the
   // |ice_username_fragment_| of the ports that belongs to the same content will
   // be the same. However this causes a small complication with our relay
   // server, which expects different username for RTP and RTCP.
   //
   // To resolve this problem, we implemented the username_fragment(),
   // which returns a different username (calculated from
   // |ice_username_fragment_|) for RTCP in the case of ICEPROTO_GOOGLE. And the
   // username_fragment() simply returns |ice_username_fragment_| when running
@@ skipping 68 matching lines @@
   virtual void EnablePortPackets();
 
   // Called if the port has no connections and is no longer useful.
   void Destroy();
 
   virtual void OnMessage(rtc::Message *pmsg);
 
   // Debugging description of this port
   virtual std::string ToString() const;
   const rtc::IPAddress& ip() const { return ip_; }
-  uint16 min_port() { return min_port_; }
-  uint16 max_port() { return max_port_; }
+  uint16_t min_port() { return min_port_; }
+  uint16_t max_port() { return max_port_; }
 
   // Timeout shortening function to speed up unit tests.
   void set_timeout_delay(int delay) { timeout_delay_ = delay; }
 
   // This method will return local and remote username fragements from the
   // stun username attribute if present.
   bool ParseStunUsername(const StunMessage* stun_msg,
                          std::string* local_username,
                          std::string* remote_username) const;
   void CreateStunUsername(const std::string& remote_username,
                           std::string* stun_username_attr_str) const;
 
   bool MaybeIceRoleConflict(const rtc::SocketAddress& addr,
                             IceMessage* stun_msg,
                             const std::string& remote_ufrag);
 
   // Called when the socket is currently able to send.
   void OnReadyToSend();
 
   // Called when the Connection discovers a local peer reflexive candidate.
   // Returns the index of the new local candidate.
   size_t AddPrflxCandidate(const Candidate& local);
 
-  void set_candidate_filter(uint32 candidate_filter) {
+  void set_candidate_filter(uint32_t candidate_filter) {
     candidate_filter_ = candidate_filter;
   }
 
  protected:
   enum {
     MSG_DEAD = 0,
     MSG_FIRST_AVAILABLE
   };
 
   void set_type(const std::string& type) { type_ = type; }
 
   void AddAddress(const rtc::SocketAddress& address,
                   const rtc::SocketAddress& base_address,
                   const rtc::SocketAddress& related_address,
                   const std::string& protocol,
                   const std::string& relay_protocol,
                   const std::string& tcptype,
                   const std::string& type,
-                  uint32 type_preference,
-                  uint32 relay_preference,
+                  uint32_t type_preference,
+                  uint32_t relay_preference,
                   bool final);
 
   // Adds the given connection to the list.  (Deleting removes them.)
   void AddConnection(Connection* conn);
 
   // Called when a packet is received from an unknown address that is not
   // currently a connection.  If this is an authenticated STUN binding request,
   // then we will signal the client.
   void OnReadPacket(const char* data, size_t size,
                     const rtc::SocketAddress& addr,
@@ skipping 10 matching lines @@
 
   // Checks if the address in addr is compatible with the port's ip.
   bool IsCompatibleAddress(const rtc::SocketAddress& addr);
 
   // Returns default DSCP value.
   rtc::DiffServCodePoint DefaultDscpValue() const {
     // No change from what MediaChannel set.
     return rtc::DSCP_NO_CHANGE;
   }
 
-  uint32 candidate_filter() { return candidate_filter_; }
+  uint32_t candidate_filter() { return candidate_filter_; }
 
  private:
   void Construct();
   // Called when one of our connections deletes itself.
   void OnConnectionDestroyed(Connection* conn);
 
   // Whether this port is dead, and hence, should be destroyed on the controlled
   // side.
   bool dead() const {
     return ice_role_ == ICEROLE_CONTROLLED && connections_.empty();
   }
 
   rtc::Thread* thread_;
   rtc::PacketSocketFactory* factory_;
   std::string type_;
   bool send_retransmit_count_attribute_;
   rtc::Network* network_;
   rtc::IPAddress ip_;
-  uint16 min_port_;
-  uint16 max_port_;
+  uint16_t min_port_;
+  uint16_t max_port_;
   std::string content_name_;
   int component_;
-  uint32 generation_;
+  uint32_t generation_;
   // In order to establish a connection to this Port (so that real data can be
   // sent through), the other side must send us a STUN binding request that is
   // authenticated with this username_fragment and password.
   // PortAllocatorSession will provide these username_fragment and password.
   //
   // Note: we should always use username_fragment() instead of using
   // |ice_username_fragment_| directly. For the details see the comment on
   // username_fragment().
   std::string ice_username_fragment_;
   std::string password_;
   std::vector<Candidate> candidates_;
   AddressMap connections_;
   int timeout_delay_;
   bool enable_port_packets_;
   IceRole ice_role_;
-  uint64 tiebreaker_;
+  uint64_t tiebreaker_;
   bool shared_socket_;
   // Information to use when going through a proxy.
   std::string user_agent_;
   rtc::ProxyInfo proxy_;
 
   // Candidate filter is pushed down to Port such that each Port could
   // make its own decision on how to create candidates. For example,
   // when IceTransportsType is set to relay, both RelayPort and
   // TurnPort will hide raddr to avoid local address leakage.
-  uint32 candidate_filter_;
+  uint32_t candidate_filter_;
 
   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 sent_time)
-        : id(id),
-          sent_time(sent_time) {}
+    SentPing(const std::string id, uint32_t sent_time)
+        : id(id), sent_time(sent_time) {}
 
     std::string id;
-    uint32 sent_time;
+    uint32_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.
   };
 
   virtual ~Connection();
 
   // The local port where this connection sends and receives packets.
   Port* port() { return port_; }
   const Port* port() const { return port_; }
 
   // Returns the description of the local port
   virtual const Candidate& local_candidate() const;
 
   // Returns the description of the remote port to which we communicate.
   const Candidate& remote_candidate() const { return remote_candidate_; }
 
   // Returns the pair priority.
-  uint64 priority() const;
+  uint64_t priority() const;
 
   enum WriteState {
     STATE_WRITABLE          = 0,  // we have received ping responses recently
     STATE_WRITE_UNRELIABLE  = 1,  // we have had a few ping failures
     STATE_WRITE_INIT        = 2,  // we have yet to receive a ping response
     STATE_WRITE_TIMEOUT     = 3,  // we have had a large number of ping failures
   };
 
   WriteState write_state() const { return write_state_; }
   bool writable() const { return write_state_ == STATE_WRITABLE; }
   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 {
     // TODO(honghaiz): Move from using |write_state_| to using |pruned_|.
     return write_state_ != STATE_WRITE_TIMEOUT;
   }
   // A connection is dead if it can be safely deleted.
-  bool dead(uint32 now) const;
+  bool dead(uint32_t now) const;
 
   // Estimate of the round-trip time over this connection.
-  uint32 rtt() const { return rtt_; }
+  uint32_t 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 receiving_timeout_ms) {
+  void set_receiving_timeout(uint32_t receiving_timeout_ms) {
     receiving_timeout_ = receiving_timeout_ms;
   }
 
   // Makes the connection go away.
   void Destroy();
 
   // 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 now);
+  void UpdateState(uint32_t now);
 
   // Called when this connection should try checking writability again.
-  uint32 last_ping_sent() const { return last_ping_sent_; }
-  void Ping(uint32 now);
+  uint32_t last_ping_sent() const { return last_ping_sent_; }
+  void Ping(uint32_t now);
   void ReceivedPingResponse();
 
   // Called whenever a valid ping is received on this connection.  This is
   // public because the connection intercepts the first ping for us.
-  uint32 last_ping_received() const { return last_ping_received_; }
+  uint32_t last_ping_received() const { return last_ping_received_; }
   void ReceivedPing();
 
   // 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);
 
   bool reported() const { return reported_; }
@@ skipping 15 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 last_received();
+  uint32_t last_received();
 
  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 rtt_;
-  uint32 last_ping_sent_;      // last time we sent a ping to the other side
-  uint32 last_ping_received_;  // last time we received a ping from the other
-                               // side
-  uint32 last_data_received_;
-  uint32 last_ping_response_received_;
+  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_;
   std::vector<SentPing> pings_since_last_response_;
 
   rtc::RateTracker recv_rate_tracker_;
   rtc::RateTracker send_rate_tracker_;
-  uint32 sent_packets_discarded_;
-  uint32 sent_packets_total_;
+  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 receiving_timeout_;
-  uint32 time_created_ms_;
+  uint32_t receiving_timeout_;
+  uint32_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& candidate);
 
   virtual int Send(const void* data, size_t size,
                    const rtc::PacketOptions& options);
   virtual int GetError() { return error_; }
 
  private:
   int error_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORT_H_