Remove kint32max.

net/spdy/spdy_session.h

 // Copyright (c) 2012 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_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
+#include <stdint.h>
+
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_export.h"
 #include "net/base/request_priority.h"
 #include "net/socket/client_socket_handle.h"
@@ skipping 332 matching lines @@
   LoadState GetLoadState() const;
 
   // Fills SSL info in |ssl_info| and returns true when SSL is in use.
   bool GetSSLInfo(SSLInfo* ssl_info,
                   bool* was_npn_negotiated,
                   NextProto* protocol_negotiated);
 
   // Send a WINDOW_UPDATE frame for a stream. Called by a stream
   // whenever receive window size is increased.
   void SendStreamWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size);
+                              uint32_t delta_window_size);
 
   // Accessors for the session's availability state.
   bool IsAvailable() const { return availability_state_ == STATE_AVAILABLE; }
   bool IsGoingAway() const { return availability_state_ == STATE_GOING_AWAY; }
   bool IsDraining() const { return availability_state_ == STATE_DRAINING; }
 
   // Closes this session. This will close all active streams and mark
   // the session as permanently closed. Callers must assume that the
   // session is destroyed after this is called. (However, it may not
   // be destroyed right away, e.g. when a SpdySession function is
@@ skipping 70 matching lines @@
     DCHECK_LE(priority, MAXIMUM_PRIORITY);
     return pending_create_stream_queues_[priority].size();
   }
 
   // Returns the (version-dependent) flow control state.
   FlowControlState flow_control_state() const {
     return flow_control_state_;
   }
 
   // Returns the current |stream_initial_send_window_size_|.
-  int32 stream_initial_send_window_size() const {
+  int32_t stream_initial_send_window_size() const {
     return stream_initial_send_window_size_;
   }
 
   // Returns true if no stream in the session can send data due to
   // session flow control.
   bool IsSendStalled() const {
     return
         flow_control_state_ == FLOW_CONTROL_STREAM_AND_SESSION &&
         session_send_window_size_ == 0;
   }
@@ skipping 28 matching lines @@
   size_t GetFrameMaximumSize() const {
     return buffered_spdy_framer_->GetFrameMaximumSize();
   }
 
   size_t GetDataFrameMaximumPayload() const {
     return buffered_spdy_framer_->GetDataFrameMaximumPayload();
   }
 
   // Default value of SETTINGS_INITIAL_WINDOW_SIZE per protocol specification.
   // A session is always created with this initial window size.
-  static int32 GetDefaultInitialWindowSize(NextProto protocol) {
+  static int32_t GetDefaultInitialWindowSize(NextProto protocol) {
     return protocol < kProtoHTTP2 ? 65536 : 65535;
   }
 
   // https://http2.github.io/http2-spec/#TLSUsage mandates minimum security
   // standards for TLS.
   bool HasAcceptableTransportSecurity() const;
 
   // Must be used only by |pool_|.
   base::WeakPtr<SpdySession> GetWeakPtr();
 
@@ skipping 193 matching lines @@
   // Send initial data. Called when a connection is successfully
   // established in InitializeWithSocket() and
   // |enable_sending_initial_data_| is true.
   void SendInitialData();
 
   // Helper method to send a SETTINGS frame.
   void SendSettings(const SettingsMap& settings);
 
   // Handle SETTING.  Either when we send settings, or when we receive a
   // SETTINGS control frame, update our SpdySession accordingly.
-  void HandleSetting(uint32 id, uint32 value);
+  void HandleSetting(uint32_t id, uint32_t value);
 
   // Adjust the send window size of all ActiveStreams and PendingStreamRequests.
-  void UpdateStreamsSendWindowSize(int32 delta_window_size);
+  void UpdateStreamsSendWindowSize(int32_t delta_window_size);
 
   // Send the PING (preface-PING) frame.
   void SendPrefacePingIfNoneInFlight();
 
   // Send PING if there are no PINGs in flight and we haven't heard from server.
   void SendPrefacePing();
 
   // Send a single WINDOW_UPDATE frame.
-  void SendWindowUpdateFrame(SpdyStreamId stream_id, uint32 delta_window_size,
+  void SendWindowUpdateFrame(SpdyStreamId stream_id,
+                             uint32_t delta_window_size,
                              RequestPriority priority);
 
   // Send the PING frame.
   void WritePingFrame(SpdyPingId unique_id, bool is_ack);
 
   // Post a CheckPingStatus call after delay. Don't post if there is already
   // CheckPingStatus running.
   void PlanToCheckPingStatus();
 
   // Check the status of the connection. It calls |CloseSessionOnError| if we
@@ skipping 93 matching lines @@
                          bool fin) override;
   void OnStreamFrameData(SpdyStreamId stream_id,
                          const char* data,
                          size_t len,
                          bool fin) override;
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override;
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId stream_id) override;
   void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override;
   void OnSettings(bool clear_persisted) override;
-  void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override;
+  void OnSetting(SpdySettingsIds id, uint8_t flags, uint32_t value) override;
   void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override;
   void OnPushPromise(SpdyStreamId stream_id,
                      SpdyStreamId promised_stream_id,
                      const SpdyHeaderBlock& headers) override;
   void OnSynStream(SpdyStreamId stream_id,
                    SpdyStreamId associated_stream_id,
                    SpdyPriority priority,
                    bool fin,
                    bool unidirectional,
                    const SpdyHeaderBlock& headers) override;
@@ skipping 37 matching lines @@
   // If session flow control is turned off, this must not be called.
   void IncreaseSendWindowSize(int delta_window_size);
 
   // If session flow control is turned on, called by CreateDataFrame()
   // (which is in turn called by a stream) to decrease this session's
   // send window size by |delta_window_size|, which must be at least 1
   // and at most kMaxSpdyFrameChunkSize.  |delta_window_size| must not
   // cause this session's send window size to go negative.
   //
   // If session flow control is turned off, this must not be called.
-  void DecreaseSendWindowSize(int32 delta_window_size);
+  void DecreaseSendWindowSize(int32_t delta_window_size);
 
   // Called when bytes are consumed by the delegate from a SpdyBuffer
   // containing received data. Increases the receive window size
   // accordingly.
   //
   // If session flow control is turned off, this must not be called.
   void OnReadBufferConsumed(size_t consume_size,
                             SpdyBuffer::ConsumeSource consume_source);
 
   // Called by OnReadBufferConsume to increase this session's receive
   // window size by |delta_window_size|, which must be at least 1 and
   // must not cause this session's receive window size to overflow,
   // possibly also sending a WINDOW_UPDATE frame. Also called during
   // initialization to set the initial receive window size.
   //
   // If session flow control is turned off, this must not be called.
-  void IncreaseRecvWindowSize(int32 delta_window_size);
+  void IncreaseRecvWindowSize(int32_t delta_window_size);
 
   // Called by OnStreamFrameData (which is in turn called by the
   // framer) to decrease this session's receive window size by
   // |delta_window_size|, which must be at least 1 and must not cause
   // this session's receive window size to go negative.
   //
   // If session flow control is turned off, this must not be called.
-  void DecreaseRecvWindowSize(int32 delta_window_size);
+  void DecreaseRecvWindowSize(int32_t delta_window_size);
 
   // Queue a send-stalled stream for possibly resuming once we're not
   // send-stalled anymore.
   void QueueSendStalledStream(const SpdyStream& stream);
 
   // Go through the queue of send-stalled streams and try to resume as
   // many as possible.
   void ResumeSendStalledStreams();
 
   // Returns the next stream to possibly resume, or 0 if the queue is
   // empty.
   SpdyStreamId PopStreamToPossiblyResume();
 
   // --------------------------
   // Helper methods for testing
   // --------------------------
 
   void set_connection_at_risk_of_loss_time(base::TimeDelta duration) {
     connection_at_risk_of_loss_time_ = duration;
   }
 
   void set_hung_interval(base::TimeDelta duration) {
     hung_interval_ = duration;
   }
 
   void set_max_concurrent_pushed_streams(size_t value) {
     max_concurrent_pushed_streams_ = value;
   }
 
-  int64 pings_in_flight() const { return pings_in_flight_; }
+  int64_t pings_in_flight() const { return pings_in_flight_; }
 
   SpdyPingId next_ping_id() const { return next_ping_id_; }
 
   base::TimeTicks last_activity_time() const { return last_activity_time_; }
 
   bool check_ping_status_pending() const { return check_ping_status_pending_; }
 
   size_t max_concurrent_streams() const { return max_concurrent_streams_; }
 
   // Set whether priority->dependency conversion is enabled
@@ skipping 122 matching lines @@
   // |total_bytes_received_| keeps track of all the bytes read by the
   // SpdySession. It is used by the |Net.SpdySettingsCwnd...| histograms.
   int total_bytes_received_;
 
   bool sent_settings_;      // Did this session send settings when it started.
   bool received_settings_;  // Did this session receive at least one settings
                             // frame.
   int stalled_streams_;     // Count of streams that were ever stalled.
 
   // Count of all pings on the wire, for which we have not gotten a response.
-  int64 pings_in_flight_;
+  int64_t pings_in_flight_;
 
   // This is the next ping_id (unique_id) to be sent in PING frame.
   SpdyPingId next_ping_id_;
 
   // This is the last time we have sent a PING.
   base::TimeTicks last_ping_sent_time_;
 
   // This is the last time we had activity in the session.
   base::TimeTicks last_activity_time_;
 
   // This is the length of the last compressed frame.
   size_t last_compressed_frame_len_;
 
   // This is the next time that unclaimed push streams should be checked for
   // expirations.
   base::TimeTicks next_unclaimed_push_stream_sweep_time_;
 
   // Indicate if we have already scheduled a delayed task to check the ping
   // status.
   bool check_ping_status_pending_;
 
   // Whether to send the (HTTP/2) connection header prefix.
   bool send_connection_header_prefix_;
 
   // The (version-dependent) flow control state.
   FlowControlState flow_control_state_;
 
   // Current send window size.  Zero unless session flow control is turned on.
-  int32 session_send_window_size_;
+  int32_t session_send_window_size_;
 
   // Maximum receive window size.  Each time a WINDOW_UPDATE is sent, it
   // restores the receive window size to this value.  Zero unless session flow
   // control is turned on.
-  int32 session_max_recv_window_size_;
+  int32_t session_max_recv_window_size_;
 
   // Sum of |session_unacked_recv_window_bytes_| and current receive window
   // size.  Zero unless session flow control is turned on.
   // TODO(bnc): Rename or change semantics so that |window_size_| is actual
   // window size.
-  int32 session_recv_window_size_;
+  int32_t session_recv_window_size_;
 
   // When bytes are consumed, SpdyIOBuffer destructor calls back to SpdySession,
   // and this member keeps count of them until the corresponding WINDOW_UPDATEs
   // are sent.  Zero unless session flow control is turned on.
-  int32 session_unacked_recv_window_bytes_;
+  int32_t session_unacked_recv_window_bytes_;
 
   // Initial send window size for this session's streams. Can be
   // changed by an arriving SETTINGS frame. Newly created streams use
   // this value for the initial send window size.
-  int32 stream_initial_send_window_size_;
+  int32_t stream_initial_send_window_size_;
 
   // Initial receive window size for this session's streams. There are
   // plans to add a command line switch that would cause a SETTINGS
   // frame with window size announcement to be sent on startup. Newly
   // created streams will use this value for the initial receive
   // window size.
-  int32 stream_max_recv_window_size_;
+  int32_t stream_max_recv_window_size_;
 
   // A queue of stream IDs that have been send-stalled at some point
   // in the past.
   std::deque<SpdyStreamId> stream_send_unstall_queue_[NUM_PRIORITIES];
 
   BoundNetLog net_log_;
 
   // Outside of tests, these should always be true.
   bool verify_domain_authentication_;
   bool enable_sending_initial_data_;
@@ skipping 39 matching lines @@
   // Used for posting asynchronous IO tasks.  We use this even though
   // SpdySession is refcounted because we don't need to keep the SpdySession
   // alive if the last reference is within a RunnableMethod.  Just revoke the
   // method.
   base::WeakPtrFactory<SpdySession> weak_factory_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_