Switch to standard integer types in net/.

net/quic/reliable_quic_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.
 //
 // The base class for client/server reliable streams.
 
 // It does not contain the entire interface needed by an application to interact
 // with a QUIC stream.  Some parts of the interface must be obtained by
 // accessing the owning session object.  A subclass of ReliableQuicStream
 // connects the object and the application that generates and consumes the data
 // of the stream.
 
 // The ReliableQuicStream object has a dependent QuicStreamSequencer object,
 // which is given the stream frames as they arrive, and provides stream data in
 // order by invoking ProcessRawData().
 
 #ifndef NET_QUIC_RELIABLE_QUIC_STREAM_H_
 #define NET_QUIC_RELIABLE_QUIC_STREAM_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <sys/types.h>
 
 #include <list>
 #include <string>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_piece.h"
 #include "net/base/iovec.h"
 #include "net/base/net_export.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_stream_sequencer.h"
 #include "net/quic/quic_types.h"
 //#include "std::strings/std::stringpiece.h"
 //#include "util/refcount/reffed_ptr.h"
@@ skipping 69 matching lines @@
   bool reading_stopped() const {
     return sequencer_.ignore_read_data() || read_side_closed_;
   }
   bool write_side_closed() const { return write_side_closed_; }
 
   bool rst_received() { return rst_received_; }
   bool rst_sent() { return rst_sent_; }
   bool fin_received() { return fin_received_; }
   bool fin_sent() { return fin_sent_; }
 
-  uint64 queued_data_bytes() const { return queued_data_bytes_; }
+  uint64_t queued_data_bytes() const { return queued_data_bytes_; }
 
-  uint64 stream_bytes_read() const { return stream_bytes_read_; }
-  uint64 stream_bytes_written() const { return stream_bytes_written_; }
+  uint64_t stream_bytes_read() const { return stream_bytes_read_; }
+  uint64_t stream_bytes_written() const { return stream_bytes_written_; }
 
   void set_fin_sent(bool fin_sent) { fin_sent_ = fin_sent; }
   void set_fin_received(bool fin_received) { fin_received_ = fin_received; }
   void set_rst_sent(bool rst_sent) { rst_sent_ = rst_sent; }
 
   void set_fec_policy(FecPolicy fec_policy) { fec_policy_ = fec_policy; }
   FecPolicy fec_policy() const { return fec_policy_; }
 
   void set_rst_received(bool rst_received) { rst_received_ = rst_received; }
   void set_stream_error(QuicRstStreamErrorCode error) { stream_error_ = error; }
@@ skipping 112 matching lines @@
   };
 
   // Calls MaybeSendBlocked on the stream's flow controller and the connection
   // level flow controller.  If the stream is flow control blocked by the
   // connection-level flow controller but not by the stream-level flow
   // controller, marks this stream as connection-level write blocked.
   void MaybeSendBlocked();
 
   std::list<PendingData> queued_data_;
   // How many bytes are queued?
-  uint64 queued_data_bytes_;
+  uint64_t queued_data_bytes_;
 
   QuicStreamSequencer sequencer_;
   QuicStreamId id_;
   // Pointer to the owning QuicSession object.
   QuicSession* session_;
   // Bytes read and written refer to payload bytes only: they do not include
   // framing, encryption overhead etc.
-  uint64 stream_bytes_read_;
-  uint64 stream_bytes_written_;
+  uint64_t stream_bytes_read_;
+  uint64_t stream_bytes_written_;
 
   // Stream error code received from a RstStreamFrame or error code sent by the
   // visitor or sequencer in the RstStreamFrame.
   QuicRstStreamErrorCode stream_error_;
   // Connection error code due to which the stream was closed. |stream_error_|
   // is set to |QUIC_STREAM_CONNECTION_ERROR| when this happens and consumers
   // should check |connection_error_|.
   QuicErrorCode connection_error_;
 
   // True if the read side is closed and further frames should be rejected.
@@ skipping 35 matching lines @@
   // connection level flow control limits (but are stream level flow control
   // limited).
   bool stream_contributes_to_connection_flow_control_;
 
   DISALLOW_COPY_AND_ASSIGN(ReliableQuicStream);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_RELIABLE_QUIC_STREAM_H_