Switch to standard integer types in net/.

net/spdy/spdy_framer.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_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "base/sys_byteorder.h"
 #include "net/base/net_export.h"
 #include "net/spdy/hpack/hpack_decoder.h"
@@ skipping 23 matching lines @@
 class TestSpdyVisitor;
 class SpdyFramerPeer;
 
 }  // namespace test
 
 // A datastructure for holding the ID and flag fields for SETTINGS.
 // Conveniently handles converstion to/from wire format.
 class NET_EXPORT_PRIVATE SettingsFlagsAndId {
  public:
   static SettingsFlagsAndId FromWireFormat(SpdyMajorVersion version,
-                                           uint32 wire);
+                                           uint32_t wire);
 
   SettingsFlagsAndId() : flags_(0), id_(0) {}
 
   // TODO(hkhalil): restrict to enums instead of free-form ints.
-  SettingsFlagsAndId(uint8 flags, uint32 id);
+  SettingsFlagsAndId(uint8_t flags, uint32_t id);
 
-  uint32 GetWireFormat(SpdyMajorVersion version) const;
+  uint32_t GetWireFormat(SpdyMajorVersion version) const;
 
-  uint32 id() const { return id_; }
-  uint8 flags() const { return flags_; }
+  uint32_t id() const { return id_; }
+  uint8_t flags() const { return flags_; }
 
  private:
-  static void ConvertFlagsAndIdForSpdy2(uint32* val);
+  static void ConvertFlagsAndIdForSpdy2(uint32_t* val);
 
-  uint8 flags_;
-  uint32 id_;
+  uint8_t flags_;
+  uint32_t id_;
 };
 
 // SettingsMap has unique (flags, value) pair for given SpdySettingsIds ID.
-typedef std::pair<SpdySettingsFlags, uint32> SettingsFlagsAndValue;
+typedef std::pair<SpdySettingsFlags, uint32_t> SettingsFlagsAndValue;
 typedef std::map<SpdySettingsIds, SettingsFlagsAndValue> SettingsMap;
 
 // SpdyFramerVisitorInterface is a set of callbacks for the SpdyFramer.
 // Implement this interface to receive event callbacks as frames are
 // decoded from the framer.
 //
 // Control frames that contain SPDY header blocks (SYN_STREAM, SYN_REPLY,
 // HEADER, and PUSH_PROMISE) are processed in fashion that allows the
 // decompressed header block to be delivered in chunks to the visitor.
 // The following steps are followed:
@@ skipping 85 matching lines @@
   // Called when a RST_STREAM frame has been parsed.
   virtual void OnRstStream(SpdyStreamId stream_id,
                            SpdyRstStreamStatus status) = 0;
 
   // Called when a SETTINGS frame is received.
   // |clear_persisted| True if the respective flag is set on the SETTINGS frame.
   virtual void OnSettings(bool clear_persisted) {}
 
   // Called when a complete setting within a SETTINGS frame has been parsed and
   // validated.
-  virtual void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) = 0;
+  virtual void OnSetting(SpdySettingsIds id, uint8_t flags, uint32_t value) = 0;
 
   // Called when a SETTINGS frame is received with the ACK flag set.
   virtual void OnSettingsAck() {}
 
   // Called before and after parsing SETTINGS id and value tuples.
   virtual void OnSettingsEnd() = 0;
 
   // Called when a PING frame has been parsed.
   virtual void OnPing(SpdyPingId unique_id, bool is_ack) = 0;
 
@@ skipping 65 matching lines @@
 
   // Called when an ALTSVC frame has been parsed.
   virtual void OnAltSvc(
       SpdyStreamId stream_id,
       base::StringPiece origin,
       const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {}
 
   // Called when a PRIORITY frame is received.
   virtual void OnPriority(SpdyStreamId stream_id,
                           SpdyStreamId parent_stream_id,
-                          uint8 weight,
+                          uint8_t weight,
                           bool exclusive) {}
 
   // Called when a frame type we don't recognize is received.
   // Return true if this appears to be a valid extension frame, false otherwise.
   // We distinguish between extension frames and nonsense by checking
   // whether the stream id is valid.
   virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) = 0;
 };
 
 // Optionally, and in addition to SpdyFramerVisitorInterface, a class supporting
@@ skipping 272 matching lines @@
   bool probable_http_response() const { return probable_http_response_; }
 
   SpdyPriority GetLowestPriority() const {
     return protocol_version_ < SPDY3 ? 3 : 7;
   }
 
   SpdyPriority GetHighestPriority() const { return 0; }
 
   // Interpolates SpdyPriority values into SPDY4/HTTP2 priority weights,
   // and vice versa.
-  static uint8 MapPriorityToWeight(SpdyPriority priority);
-  static SpdyPriority MapWeightToPriority(uint8 weight);
+  static uint8_t MapPriorityToWeight(SpdyPriority priority);
+  static SpdyPriority MapWeightToPriority(uint8_t weight);
 
   // Deliver the given control frame's compressed headers block to the visitor
   // in decompressed form, in chunks. Returns true if the visitor has
   // accepted all of the chunks.
   bool IncrementallyDecompressControlFrameHeaderData(
       SpdyStreamId stream_id,
       const char* data,
       size_t len);
 
   // Updates the maximum size of the header encoder compression table.
-  void UpdateHeaderEncoderTableSize(uint32 value);
+  void UpdateHeaderEncoderTableSize(uint32_t value);
 
   // Returns the maximum size of the header encoder compression table.
   size_t header_encoder_table_size() const;
 
  protected:
   friend class HttpNetworkLayer;  // This is temporary for the server.
   friend class HttpNetworkTransactionTest;
   friend class HttpProxyClientSocketPoolTest;
   friend class SpdyHttpStreamTest;
   friend class SpdyNetworkTransactionTest;
@@ skipping 146 matching lines @@
   // headers. Note that header data blocks (for control types that have them)
   // are part of the frame's payload, and not the frame's headers.
   size_t remaining_control_header_;
 
   CharBuffer current_frame_buffer_;
 
   // The type of the frame currently being read.
   SpdyFrameType current_frame_type_;
 
   // The total length of the frame currently being read, including frame header.
-  uint32 current_frame_length_;
+  uint32_t current_frame_length_;
 
   // The stream ID field of the frame currently being read, if applicable.
   SpdyStreamId current_frame_stream_id_;
 
   // Set this to the current stream when we receive a HEADERS, PUSH_PROMISE, or
   // CONTINUATION frame without the END_HEADERS(0x4) bit set. These frames must
   // be followed by a CONTINUATION frame, or else we throw a PROTOCOL_ERROR.
   // A value of 0 indicates that we are not expecting a CONTINUATION frame.
   SpdyStreamId expect_continuation_;
 
@@ skipping 13 matching lines @@
 
   SpdyFramerVisitorInterface* visitor_;
   SpdyFramerDebugVisitorInterface* debug_visitor_;
 
   std::string display_protocol_;
 
   // The protocol version to be spoken/understood by this framer.
   const SpdyMajorVersion protocol_version_;
 
   // The flags field of the frame currently being read.
-  uint8 current_frame_flags_;
+  uint8_t current_frame_flags_;
 
   // Determines whether HPACK or gzip compression is used.
   bool enable_compression_;
 
   // Tracks if we've ever gotten far enough in framing to see a control frame of
   // type SYN_STREAM or SYN_REPLY.
   //
   // If we ever get something which looks like a data frame before we've had a
   // SYN, we explicitly check to see if it looks like we got an HTTP response
   // to a SPDY request.  This boolean lets us do that.
@@ skipping 13 matching lines @@
   bool end_stream_when_done_;
 
   // If true, then ProcessInput returns after processing a full frame,
   // rather than reading all available input.
   bool process_single_input_frame_ = false;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_