Remove kint32min.

net/spdy/spdy_stream.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_STREAM_H_
 #define NET_SPDY_SPDY_STREAM_H_
 
 #include <stdint.h>
 
 #include <deque>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_export.h"
 #include "net/base/request_priority.h"
 #include "net/log/net_log.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/spdy/spdy_buffer.h"
 #include "net/spdy/spdy_framer.h"
@@ skipping 137 matching lines @@
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // SpdyStream constructor
   SpdyStream(SpdyStreamType type,
              const base::WeakPtr<SpdySession>& session,
              const GURL& url,
              RequestPriority priority,
-             int32 initial_send_window_size,
-             int32 max_recv_window_size,
+             int32_t initial_send_window_size,
+             int32_t max_recv_window_size,
              const BoundNetLog& net_log);
 
   ~SpdyStream();
 
   // Set the delegate, which must not be NULL. Must not be called more
   // than once. For push streams, calling this may cause buffered data
   // to be sent to the delegate (from a posted task).
   void SetDelegate(Delegate* delegate);
 
   // Detach the delegate from the stream, which must not yet be
   // closed, and cancel it.
   void DetachDelegate();
 
   // The time at which the first bytes of the response were received
   // from the server, or null if the response hasn't been received
   // yet.
   base::Time response_time() const { return response_time_; }
 
   SpdyStreamType type() const { return type_; }
 
   SpdyStreamId stream_id() const { return stream_id_; }
   void set_stream_id(SpdyStreamId stream_id) { stream_id_ = stream_id; }
 
   const GURL& url() const { return url_; }
 
   RequestPriority priority() const { return priority_; }
 
-  int32 send_window_size() const { return send_window_size_; }
+  int32_t send_window_size() const { return send_window_size_; }
 
-  int32 recv_window_size() const { return recv_window_size_; }
+  int32_t recv_window_size() const { return recv_window_size_; }
 
   bool send_stalled_by_flow_control() const {
     return send_stalled_by_flow_control_;
   }
 
   void set_send_stalled_by_flow_control(bool stalled) {
     send_stalled_by_flow_control_ = stalled;
   }
 
   // Called by the session to adjust this stream's send window size by
   // |delta_window_size|, which is the difference between the
   // SETTINGS_INITIAL_WINDOW_SIZE in the most recent SETTINGS frame
   // and the previous initial send window size, possibly unstalling
   // this stream. Although |delta_window_size| may cause this stream's
   // send window size to go negative, it must not cause it to wrap
   // around in either direction. Does nothing if the stream is already
   // closed.
   //
   // If stream flow control is turned off, this must not be called.
-  void AdjustSendWindowSize(int32 delta_window_size);
+  void AdjustSendWindowSize(int32_t delta_window_size);
 
   // Called when bytes are consumed from a SpdyBuffer for a DATA frame
   // that is to be written or is being written. Increases the send
   // window size accordingly if some or all of the SpdyBuffer is being
   // discarded.
   //
   // If stream flow control is turned off, this must not be called.
   void OnWriteBufferConsumed(size_t frame_payload_size,
                              size_t consume_size,
                              SpdyBuffer::ConsumeSource consume_source);
 
   // Called by the session to increase this stream's send window size
   // by |delta_window_size| (which must be at least 1) from a received
   // WINDOW_UPDATE frame or from a dropped DATA frame that was
   // intended to be sent, possibly unstalling this stream. If
   // |delta_window_size| would cause this stream's send window size to
   // overflow, calls into the session to reset this stream. Does
   // nothing if the stream is already closed.
   //
   // If stream flow control is turned off, this must not be called.
-  void IncreaseSendWindowSize(int32 delta_window_size);
+  void IncreaseSendWindowSize(int32_t delta_window_size);
 
   // If stream flow control is turned on, called by the session to
   // decrease this stream's send window size by |delta_window_size|,
   // which must be at least 0 and at most kMaxSpdyFrameChunkSize.
   // |delta_window_size| must not cause this stream's send window size
   // to go negative. Does nothing if the stream is already closed.
   //
   // If stream 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 stream 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 stream's receive
   // window size by |delta_window_size|, which must be at least 1 and
   // must not cause this stream's receive window size to overflow,
   // possibly also sending a WINDOW_UPDATE frame. Does nothing if the
   // stream is not active.
   //
   // If stream 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 OnDataReceived or OnPaddingConsumed (which are in turn called by
   // the session) to decrease this stream's receive window size by
   // |delta_window_size|, which must be at least 1.  May close the stream on
   // flow control error.
   //
   // If stream flow control is turned off or the stream is not active,
   // this must not be called.
-  void DecreaseRecvWindowSize(int32 delta_window_size);
+  void DecreaseRecvWindowSize(int32_t delta_window_size);
 
   int GetPeerAddress(IPEndPoint* address) const;
   int GetLocalAddress(IPEndPoint* address) const;
 
   // Returns true if the underlying transport socket ever had any reads or
   // writes.
   bool WasEverUsed() const;
 
   const BoundNetLog& net_log() const { return net_log_; }
 
@@ skipping 128 matching lines @@
 
   // Returns the protocol used by this stream. Always between
   // kProtoSPDYMinimumVersion and kProtoSPDYMaximumVersion.
   NextProto GetProtocol() const;
 
   int response_status() const { return response_status_; }
 
   void AddRawReceivedBytes(size_t received_bytes);
   void AddRawSentBytes(size_t sent_bytes);
 
-  int64 raw_received_bytes() const { return raw_received_bytes_; }
+  int64_t raw_received_bytes() const { return raw_received_bytes_; }
   int64_t raw_sent_bytes() const { return raw_sent_bytes_; }
 
   bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const;
 
   // Get the URL from the appropriate stream headers, or the empty
   // GURL() if it is unknown.
   //
   // TODO(akalin): Figure out if we really need this function,
   // i.e. can we just use the URL this stream was created with and/or
   // one we receive headers validate that the URL from them is the
@@ skipping 63 matching lines @@
 
   const SpdyStreamType type_;
 
   SpdyStreamId stream_id_;
   const GURL url_;
   const RequestPriority priority_;
 
   bool send_stalled_by_flow_control_;
 
   // Current send window size.
-  int32 send_window_size_;
+  int32_t send_window_size_;
 
   // Maximum receive window size.  Each time a WINDOW_UPDATE is sent, it
   // restores the receive window size to this value.
-  int32 max_recv_window_size_;
+  int32_t max_recv_window_size_;
 
   // Sum of |session_unacked_recv_window_bytes_| and current receive window
   // size.
   // TODO(bnc): Rename or change semantics so that |window_size_| is actual
   // window size.
-  int32 recv_window_size_;
+  int32_t 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.
-  int32 unacked_recv_window_bytes_;
+  int32_t unacked_recv_window_bytes_;
 
   const base::WeakPtr<SpdySession> session_;
 
   // The transaction should own the delegate.
   SpdyStream::Delegate* delegate_;
 
   // The headers for the request to send.
   //
   // TODO(akalin): Hang onto this only until we send it. This
   // necessitates stashing the URL separately.
@@ skipping 25 matching lines @@
   int response_status_;
 
   BoundNetLog net_log_;
 
   base::TimeTicks send_time_;
   base::TimeTicks recv_first_byte_time_;
   base::TimeTicks recv_last_byte_time_;
 
   // Number of bytes that have been received on this stream, including frame
   // overhead and headers.
-  int64 raw_received_bytes_;
+  int64_t raw_received_bytes_;
   // Number of bytes that have been sent on this stream, including frame
   // overhead and headers.
   int64_t raw_sent_bytes_;
 
   // Number of data bytes that have been sent/received on this stream, not
   // including frame overhead. Note that this does not count headers.
   int send_bytes_;
   int recv_bytes_;
 
   // Guards calls of delegate write handlers ensuring |this| is not destroyed.
   // TODO(jgraettinger): Consider removing after crbug.com/35511 is tracked
   // down.
   bool write_handler_guard_;
 
   base::WeakPtrFactory<SpdyStream> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_STREAM_H_