Switch to standard integer types in net/.

net/spdy/spdy_protocol.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.
 
 // This file contains some protocol structures for use with SPDY 2 and 3
 // The SPDY 2 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft2
 // The SPDY 3 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
 
 #ifndef NET_SPDY_SPDY_PROTOCOL_H_
 #define NET_SPDY_SPDY_PROTOCOL_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <limits>
 #include <map>
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #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/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "net/spdy/spdy_header_block.h"
 
 namespace net {
 
 // The major versions of SPDY. Major version differences indicate
 // framer-layer incompatibility, as opposed to minor version numbers
 // which indicate application-layer incompatibility. Do not rely on
 // the mapping from enum value SPDYn to the integer n.
 enum SpdyMajorVersion {
   SPDY2 = 2,
   SPDY_MIN_VERSION = SPDY2,
   SPDY3 = 3,
   HTTP2 = 4,
   SPDY_MAX_VERSION = HTTP2
 };
 
 // A SPDY stream id is a 31 bit entity.
-typedef uint32 SpdyStreamId;
+typedef uint32_t SpdyStreamId;
 
 // Specifies the stream ID used to denote the current session (for
 // flow control).
 const SpdyStreamId kSessionFlowControlStreamId = 0;
 
 // The maxmium possible control frame size allowed by the spec.
-const int32 kSpdyMaxControlFrameSize = (1 << 24) - 1;
+const int32_t kSpdyMaxControlFrameSize = (1 << 24) - 1;
 
 // The maximum control frame size we accept.
-const int32 kControlFrameSizeLimit = 1 << 14;
+const int32_t kControlFrameSizeLimit = 1 << 14;
 
 // Maximum window size for a Spdy stream or session.
-const int32 kSpdyMaximumWindowSize = 0x7FFFFFFF;  // Max signed 32bit int
+const int32_t kSpdyMaximumWindowSize = 0x7FFFFFFF;  // Max signed 32bit int
 
 // Maximum padding size in octets for one DATA or HEADERS or PUSH_PROMISE frame.
-const int32 kPaddingSizePerFrame = 256;
+const int32_t kPaddingSizePerFrame = 256;
 
 // SPDY 2 dictionary.
 // This is just a hacked dictionary to use for shrinking HTTP-like headers.
 const char kV2Dictionary[] =
   "optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-"
   "languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi"
   "f-rangeif-unmodifiedsincemax-forwardsproxy-authorizationrangerefererteuser"
   "-agent10010120020120220320420520630030130230330430530630740040140240340440"
   "5406407408409410411412413414415416417500501502503504505accept-rangesageeta"
   "glocationproxy-authenticatepublicretry-afterservervarywarningwww-authentic"
@@ skipping 339 matching lines @@
   GOAWAY_COMPRESSION_ERROR = 9,
   GOAWAY_CONNECT_ERROR = 10,
   GOAWAY_ENHANCE_YOUR_CALM = 11,
   GOAWAY_INADEQUATE_SECURITY = 12,
   GOAWAY_HTTP_1_1_REQUIRED = 13
 };
 
 // A SPDY priority is a number between 0 and 7 (inclusive).
 // SPDY priority range is version-dependent. For SPDY 2 and below, priority is a
 // number between 0 and 3.
-typedef uint8 SpdyPriority;
+typedef uint8_t SpdyPriority;
 
 // Lowest and Highest here refer to SPDY priorities as described in
 
 // https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority
 const SpdyPriority kV3HighestPriority = 0;
 const SpdyPriority kV3LowestPriority = 7;
 
-typedef uint64 SpdyPingId;
+typedef uint64_t SpdyPingId;
 
 typedef std::string SpdyProtocolId;
 
 enum class SpdyHeaderValidatorType {
   REQUEST,
   RESPONSE_HEADER,
   RESPONSE_TRAILER
 };
 
 // TODO(hkhalil): Add direct testing for this? It won't increase coverage any,
@@ skipping 88 matching lines @@
   static size_t GetFrameMaximumSize(SpdyMajorVersion version);
 
   // Returns the size of a header block size field. Valid only for SPDY
   // versions <= 3.
   static size_t GetSizeOfSizeField(SpdyMajorVersion version);
 
   // Returns the size (in bytes) of a wire setting ID and value.
   static size_t GetSettingSize(SpdyMajorVersion version);
 
   // Initial window size for a stream in bytes.
-  static int32 GetInitialStreamWindowSize(SpdyMajorVersion version);
+  static int32_t GetInitialStreamWindowSize(SpdyMajorVersion version);
 
   // Initial window size for a session in bytes.
-  static int32 GetInitialSessionWindowSize(SpdyMajorVersion version);
+  static int32_t GetInitialSessionWindowSize(SpdyMajorVersion version);
 
   static SpdyMajorVersion ParseMajorVersion(int version_number);
 
   static int SerializeMajorVersion(SpdyMajorVersion version);
 
   static std::string GetVersionString(SpdyMajorVersion version);
 };
 
 class SpdyFrame;
 typedef SpdyFrame SpdySerializedFrame;
@@ skipping 198 matching lines @@
 
 class NET_EXPORT_PRIVATE SpdySettingsIR : public SpdyFrameIR {
  public:
   // Associates flags with a value.
   struct Value {
     Value() : persist_value(false),
               persisted(false),
               value(0) {}
     bool persist_value;
     bool persisted;
-    int32 value;
+    int32_t value;
   };
   typedef std::map<SpdySettingsIds, Value> ValueMap;
 
   SpdySettingsIR();
 
   ~SpdySettingsIR() override;
 
   // Overwrites as appropriate.
   const ValueMap& values() const { return values_; }
   void AddSetting(SpdySettingsIds id,
                   bool persist_value,
                   bool persisted,
-                  int32 value) {
+                  int32_t value) {
     values_[id].persist_value = persist_value;
     values_[id].persisted = persisted;
     values_[id].value = value;
   }
 
   bool clear_settings() const { return clear_settings_; }
   bool is_ack() const { return is_ack_; }
   void set_is_ack(bool is_ack) {
     is_ack_ = is_ack;
   }
@@ skipping 58 matching lines @@
 
 class NET_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
  public:
   explicit SpdyHeadersIR(SpdyStreamId stream_id)
       : SpdyFrameWithHeaderBlockIR(stream_id) {}
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   bool has_priority() const { return has_priority_; }
   void set_has_priority(bool has_priority) { has_priority_ = has_priority; }
-  uint32 priority() const { return priority_; }
+  uint32_t priority() const { return priority_; }
   void set_priority(SpdyPriority priority) { priority_ = priority; }
   SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
   void set_parent_stream_id(SpdyStreamId id) { parent_stream_id_ = id; }
   bool exclusive() const { return exclusive_; }
   void set_exclusive(bool exclusive) { exclusive_ = exclusive; }
   bool padded() const { return padded_; }
   int padding_payload_len() const { return padding_payload_len_; }
   void set_padding_len(int padding_len) {
     DCHECK_GT(padding_len, 0);
     DCHECK_LE(padding_len, kPaddingSizePerFrame);
     padded_ = true;
     // The pad field takes one octet on the wire.
     padding_payload_len_ = padding_len - 1;
   }
 
  private:
   bool has_priority_ = false;
   // 31-bit priority.
-  uint32 priority_ = 0;
+  uint32_t priority_ = 0;
   SpdyStreamId parent_stream_id_ = 0;
   bool exclusive_ = false;
   bool padded_ = false;
   int padding_payload_len_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyHeadersIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyWindowUpdateIR : public SpdyFrameWithStreamIdIR {
  public:
-  SpdyWindowUpdateIR(SpdyStreamId stream_id, int32 delta)
+  SpdyWindowUpdateIR(SpdyStreamId stream_id, int32_t delta)
       : SpdyFrameWithStreamIdIR(stream_id) {
     set_delta(delta);
   }
-  int32 delta() const { return delta_; }
-  void set_delta(int32 delta) {
+  int32_t delta() const { return delta_; }
+  void set_delta(int32_t delta) {
     DCHECK_LT(0, delta);
     DCHECK_LE(delta, kSpdyMaximumWindowSize);
     delta_ = delta;
   }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
-  int32 delta_;
+  int32_t delta_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyWindowUpdateIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyBlockedIR
     : public NON_EXPORTED_BASE(SpdyFrameWithStreamIdIR) {
  public:
   explicit SpdyBlockedIR(SpdyStreamId stream_id)
       : SpdyFrameWithStreamIdIR(stream_id) {}
 
@@ skipping 76 matching lines @@
 
 class NET_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameWithStreamIdIR {
  public:
   explicit SpdyPriorityIR(SpdyStreamId stream_id)
       : SpdyFrameWithStreamIdIR(stream_id),
         parent_stream_id_(0),
         weight_(1),
         exclusive_(false) {}
   SpdyPriorityIR(SpdyStreamId stream_id,
                  SpdyStreamId parent_stream_id,
-                 uint8 weight,
+                 uint8_t weight,
                  bool exclusive)
       : SpdyFrameWithStreamIdIR(stream_id),
         parent_stream_id_(parent_stream_id),
         weight_(weight),
         exclusive_(exclusive) {}
   SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
   void set_parent_stream_id(SpdyStreamId id) { parent_stream_id_ = id; }
-  uint8 weight() const { return weight_; }
-  void set_weight(uint8 weight) { weight_ = weight; }
+  uint8_t weight() const { return weight_; }
+  void set_weight(uint8_t weight) { weight_ = weight; }
   bool exclusive() const { return exclusive_; }
   void set_exclusive(bool exclusive) { exclusive_ = exclusive; }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId parent_stream_id_;
-  uint8 weight_;
+  uint8_t weight_;
   bool exclusive_;
   DISALLOW_COPY_AND_ASSIGN(SpdyPriorityIR);
 };
 
 // -------------------------------------------------------------------------
 // Wrapper classes for various SPDY frames.
 
 // All Spdy Frame types derive from this SpdyFrame class.
 class SpdyFrame {
  public:
@@ skipping 59 matching lines @@
   SpdyFrameVisitor() {}
   virtual ~SpdyFrameVisitor() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_PROTOCOL_H_