Switch to standard integer types in net/.

net/quic/quic_config.h

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_QUIC_QUIC_CONFIG_H_
 #define NET_QUIC_QUIC_CONFIG_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
-#include "base/basictypes.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_time.h"
 
 namespace net {
 
 namespace test {
 class QuicConfigPeer;
 }  // namespace test
 
 class CryptoHandshakeMessage;
@@ skipping 54 matching lines @@
 class NET_EXPORT_PRIVATE QuicNegotiableUint32 : public QuicNegotiableValue {
  public:
   // Default and max values default to 0.
   QuicNegotiableUint32(QuicTag name, QuicConfigPresence presence);
   ~QuicNegotiableUint32() override;
 
   // Sets the maximum possible value that can be achieved after negotiation and
   // also the default values to be assumed if PRESENCE_OPTIONAL and the *HLO msg
   // doesn't contain a value corresponding to |name_|. |max| is serialised via
   // ToHandshakeMessage call if |negotiated_| is false.
-  void set(uint32 max, uint32 default_value);
+  void set(uint32_t max, uint32_t default_value);
 
   // Returns the value negotiated if |negotiated_| is true, otherwise returns
   // default_value_ (used to set default values before negotiation finishes).
-  uint32 GetUint32() const;
+  uint32_t GetUint32() const;
 
   // Serialises |name_| and value to |out|. If |negotiated_| is true then
   // |negotiated_value_| is serialised, otherwise |max_value_| is serialised.
   void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |negotiated_value_| to the minimum of |max_value_| and the
   // corresponding value from |peer_hello|. If the corresponding value is
   // missing and PRESENCE_OPTIONAL then |negotiated_value_| is set to
   // |default_value_|.
   QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
                                  HelloType hello_type,
                                  std::string* error_details) override;
 
  private:
-  uint32 max_value_;
-  uint32 default_value_;
-  uint32 negotiated_value_;
+  uint32_t max_value_;
+  uint32_t default_value_;
+  uint32_t negotiated_value_;
 };
 
 class NET_EXPORT_PRIVATE QuicNegotiableTag : public QuicNegotiableValue {
  public:
   QuicNegotiableTag(QuicTag name, QuicConfigPresence presence);
   ~QuicNegotiableTag() override;
 
   // Sets the possible values that |negotiated_tag_| can take after negotiation
   // and the default value that |negotiated_tag_| takes if OPTIONAL and *HLO
   // msg doesn't contain tag |name_|.
@@ skipping 18 matching lines @@
   QuicErrorCode ReadVector(const CryptoHandshakeMessage& msg,
                            const QuicTag** out,
                            size_t* out_length,
                            std::string* error_details) const;
 
   QuicTag negotiated_tag_;
   QuicTagVector possible_values_;
   QuicTag default_value_;
 };
 
-// Stores uint32 from CHLO or SHLO messages that are not negotiated.
+// Stores uint32_t from CHLO or SHLO messages that are not negotiated.
 class NET_EXPORT_PRIVATE QuicFixedUint32 : public QuicConfigValue {
  public:
   QuicFixedUint32(QuicTag name, QuicConfigPresence presence);
   ~QuicFixedUint32() override;
 
   bool HasSendValue() const;
 
-  uint32 GetSendValue() const;
+  uint32_t GetSendValue() const;
 
-  void SetSendValue(uint32 value);
+  void SetSendValue(uint32_t value);
 
   bool HasReceivedValue() const;
 
-  uint32 GetReceivedValue() const;
+  uint32_t GetReceivedValue() const;
 
-  void SetReceivedValue(uint32 value);
+  void SetReceivedValue(uint32_t value);
 
   // If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
   void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |value_| to the corresponding value from |peer_hello_| if it exists.
   QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
                                  HelloType hello_type,
                                  std::string* error_details) override;
 
  private:
-  uint32 send_value_;
+  uint32_t send_value_;
   bool has_send_value_;
-  uint32 receive_value_;
+  uint32_t receive_value_;
   bool has_receive_value_;
 };
 
 // Stores tag from CHLO or SHLO messages that are not negotiated.
 class NET_EXPORT_PRIVATE QuicFixedTagVector : public QuicConfigValue {
  public:
   QuicFixedTagVector(QuicTag name, QuicConfigPresence presence);
   ~QuicFixedTagVector() override;
 
   bool HasSendValues() const;
@@ skipping 59 matching lines @@
       QuicTime::Delta default_idle_conection_state_lifetime);
 
   QuicTime::Delta IdleConnectionStateLifetime() const;
 
   void SetSilentClose(bool silent_close);
 
   bool SilentClose() const;
 
   void SetMaxStreamsPerConnection(size_t max_streams, size_t default_streams);
 
-  uint32 MaxStreamsPerConnection() const;
+  uint32_t MaxStreamsPerConnection() const;
 
   void set_max_time_before_crypto_handshake(
       QuicTime::Delta max_time_before_crypto_handshake) {
     max_time_before_crypto_handshake_ = max_time_before_crypto_handshake;
   }
 
   QuicTime::Delta max_time_before_crypto_handshake() const {
     return max_time_before_crypto_handshake_;
   }
 
@@ skipping 11 matching lines @@
     max_undecryptable_packets_ = max_undecryptable_packets;
   }
 
   size_t max_undecryptable_packets() const {
     return max_undecryptable_packets_;
   }
 
   bool HasSetBytesForConnectionIdToSend() const;
 
   // Sets the peer's connection id length, in bytes.
-  void SetBytesForConnectionIdToSend(uint32 bytes);
+  void SetBytesForConnectionIdToSend(uint32_t bytes);
 
   bool HasReceivedBytesForConnectionId() const;
 
-  uint32 ReceivedBytesForConnectionId() const;
+  uint32_t ReceivedBytesForConnectionId() const;
 
   // Sets an estimated initial round trip time in us.
-  void SetInitialRoundTripTimeUsToSend(uint32 rtt_us);
+  void SetInitialRoundTripTimeUsToSend(uint32_t rtt_us);
 
   bool HasReceivedInitialRoundTripTimeUs() const;
 
-  uint32 ReceivedInitialRoundTripTimeUs() const;
+  uint32_t ReceivedInitialRoundTripTimeUs() const;
 
   bool HasInitialRoundTripTimeUsToSend() const;
 
-  uint32 GetInitialRoundTripTimeUsToSend() const;
+  uint32_t GetInitialRoundTripTimeUsToSend() const;
 
   // Sets an initial stream flow control window size to transmit to the peer.
-  void SetInitialStreamFlowControlWindowToSend(uint32 window_bytes);
+  void SetInitialStreamFlowControlWindowToSend(uint32_t window_bytes);
 
-  uint32 GetInitialStreamFlowControlWindowToSend() const;
+  uint32_t GetInitialStreamFlowControlWindowToSend() const;
 
   bool HasReceivedInitialStreamFlowControlWindowBytes() const;
 
-  uint32 ReceivedInitialStreamFlowControlWindowBytes() const;
+  uint32_t ReceivedInitialStreamFlowControlWindowBytes() const;
 
   // Sets an initial session flow control window size to transmit to the peer.
-  void SetInitialSessionFlowControlWindowToSend(uint32 window_bytes);
+  void SetInitialSessionFlowControlWindowToSend(uint32_t window_bytes);
 
-  uint32 GetInitialSessionFlowControlWindowToSend() const;
+  uint32_t GetInitialSessionFlowControlWindowToSend() const;
 
   bool HasReceivedInitialSessionFlowControlWindowBytes() const;
 
-  uint32 ReceivedInitialSessionFlowControlWindowBytes() const;
+  uint32_t ReceivedInitialSessionFlowControlWindowBytes() const;
 
   // Sets socket receive buffer to transmit to the peer.
-  void SetSocketReceiveBufferToSend(uint32 window_bytes);
+  void SetSocketReceiveBufferToSend(uint32_t window_bytes);
 
   bool HasReceivedSocketReceiveBuffer() const;
 
-  uint32 ReceivedSocketReceiveBuffer() const;
+  uint32_t ReceivedSocketReceiveBuffer() const;
 
   bool negotiated() const;
 
   // ToHandshakeMessage serialises the settings in this object as a series of
   // tags /value pairs and adds them to |out|.
   void ToHandshakeMessage(CryptoHandshakeMessage* out) const;
 
   // Calls ProcessPeerHello on each negotiable parameter. On failure returns
   // the corresponding QuicErrorCode and sets detailed error in |error_details|.
   QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
@@ skipping 32 matching lines @@
   // Initial session flow control receive window in bytes.
   QuicFixedUint32 initial_session_flow_control_window_bytes_;
 
   // Socket receive buffer in bytes.
   QuicFixedUint32 socket_receive_buffer_;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONFIG_H_