Switch to standard integer types in net/.

net/spdy/spdy_test_util_common.h

 // Copyright (c) 2013 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_TEST_UTIL_COMMON_H_
 #define NET_SPDY_SPDY_TEST_UTIL_COMMON_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "crypto/ec_private_key.h"
 #include "crypto/ec_signature_creator.h"
 #include "net/base/completion_callback.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
@@ skipping 101 matching lines @@
 // This struct holds information used to construct spdy control and data frames.
 struct SpdyHeaderInfo {
   SpdyFrameType kind;
   SpdyStreamId id;
   SpdyStreamId assoc_id;
   SpdyPriority priority;
   SpdyControlFlags control_flags;
   bool compressed;
   SpdyRstStreamStatus status;
   const char* data;
-  uint32 data_length;
+  uint32_t data_length;
   SpdyDataFlags data_flags;
 };
 
 // An ECSignatureCreator that returns deterministic signatures.
 class MockECSignatureCreator : public crypto::ECSignatureCreator {
  public:
   explicit MockECSignatureCreator(crypto::ECPrivateKey* key);
 
   // crypto::ECSignatureCreator
-  bool Sign(const uint8* data,
+  bool Sign(const uint8_t* data,
             int data_len,
-            std::vector<uint8>* signature) override;
-  bool DecodeSignature(const std::vector<uint8>& signature,
-                       std::vector<uint8>* out_raw_sig) override;
+            std::vector<uint8_t>* signature) override;
+  bool DecodeSignature(const std::vector<uint8_t>& signature,
+                       std::vector<uint8_t>* out_raw_sig) override;
 
  private:
   crypto::ECPrivateKey* key_;
 
   DISALLOW_COPY_AND_ASSIGN(MockECSignatureCreator);
 };
 
 // An ECSignatureCreatorFactory creates MockECSignatureCreator.
 class MockECSignatureCreatorFactory : public crypto::ECSignatureCreatorFactory {
  public:
@@ skipping 127 matching lines @@
   // Add the appropriate headers to put |url| into |block|.
   void AddUrlToHeaderBlock(base::StringPiece url,
                            SpdyHeaderBlock* headers) const;
 
   scoped_ptr<SpdyHeaderBlock> ConstructGetHeaderBlock(
       base::StringPiece url) const;
   scoped_ptr<SpdyHeaderBlock> ConstructGetHeaderBlockForProxy(
       base::StringPiece url) const;
   scoped_ptr<SpdyHeaderBlock> ConstructHeadHeaderBlock(
       base::StringPiece url,
-      int64 content_length) const;
+      int64_t content_length) const;
   scoped_ptr<SpdyHeaderBlock> ConstructPostHeaderBlock(
       base::StringPiece url,
-      int64 content_length) const;
+      int64_t content_length) const;
   scoped_ptr<SpdyHeaderBlock> ConstructPutHeaderBlock(
       base::StringPiece url,
-      int64 content_length) const;
+      int64_t content_length) const;
 
   // Construct a SPDY frame.  If it is a SYN_STREAM or SYN_REPLY frame (as
   // specified in header_info.kind), the provided headers are included in the
   // frame.
   SpdyFrame* ConstructSpdyFrame(
       const SpdyHeaderInfo& header_info,
       scoped_ptr<SpdyHeaderBlock> headers) const;
 
   // Construct a SPDY frame.  If it is a SYN_STREAM or SYN_REPLY frame (as
   // specified in header_info.kind), the headers provided in extra_headers and
@@ skipping 40 matching lines @@
   // |settings| are the settings to set.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdyFrame* ConstructSpdySettings(const SettingsMap& settings) const;
 
   // Constructs an expected SPDY SETTINGS acknowledgement frame, if the protocol
   // version is SPDY4 or higher, or an empty placeholder frame otherwise.
   SpdyFrame* ConstructSpdySettingsAck() const;
 
   // Construct a SPDY PING frame.
   // Returns the constructed frame.  The caller takes ownership of the frame.
-  SpdyFrame* ConstructSpdyPing(uint32 ping_id, bool is_ack) const;
+  SpdyFrame* ConstructSpdyPing(uint32_t ping_id, bool is_ack) const;
 
   // Construct a SPDY GOAWAY frame with last_good_stream_id = 0.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdyFrame* ConstructSpdyGoAway() const;
 
   // Construct a SPDY GOAWAY frame with the specified last_good_stream_id.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdyFrame* ConstructSpdyGoAway(SpdyStreamId last_good_stream_id) const;
 
   // Construct a SPDY GOAWAY frame with the specified last_good_stream_id,
   // status, and description. Returns the constructed frame. The caller takes
   // ownership of the frame.
   SpdyFrame* ConstructSpdyGoAway(SpdyStreamId last_good_stream_id,
                                  SpdyGoAwayStatus status,
                                  const std::string& desc) const;
 
   // Construct a SPDY WINDOW_UPDATE frame.
   // Returns the constructed frame.  The caller takes ownership of the frame.
-  SpdyFrame* ConstructSpdyWindowUpdate(
-      SpdyStreamId stream_id,
-      uint32 delta_window_size) const;
+  SpdyFrame* ConstructSpdyWindowUpdate(SpdyStreamId stream_id,
+                                       uint32_t delta_window_size) const;
 
   // Construct a SPDY RST_STREAM frame.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdyFrame* ConstructSpdyRstStream(SpdyStreamId stream_id,
                                     SpdyRstStreamStatus status) const;
 
   // Constructs a standard SPDY GET SYN frame, optionally compressed
   // for |url|.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
@@ skipping 90 matching lines @@
                                         const char* const* const extra_headers,
                                         int extra_header_count,
                                         int stream_id);
 
   // Constructs a standard SPDY POST SYN frame.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdyFrame.
   SpdyFrame* ConstructSpdyPost(const char* url,
                                SpdyStreamId stream_id,
-                               int64 content_length,
+                               int64_t content_length,
                                RequestPriority priority,
                                const char* const extra_headers[],
                                int extra_header_count);
 
   // Constructs a chunked transfer SPDY POST SYN frame.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdyFrame.
   SpdyFrame* ConstructChunkedSpdyPost(const char* const extra_headers[],
                                       int extra_header_count);
 
   // Constructs a standard SPDY SYN_REPLY frame to match the SPDY POST.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdyFrame.
   SpdyFrame* ConstructSpdyPostSynReply(const char* const extra_headers[],
                                        int extra_header_count);
 
   // Constructs a single SPDY data frame with the contents "hello!"
   SpdyFrame* ConstructSpdyBodyFrame(int stream_id,
                                     bool fin);
 
   // Constructs a single SPDY data frame with the given content.
-  SpdyFrame* ConstructSpdyBodyFrame(int stream_id, const char* data,
-                                    uint32 len, bool fin);
+  SpdyFrame* ConstructSpdyBodyFrame(int stream_id,
+                                    const char* data,
+                                    uint32_t len,
+                                    bool fin);
 
   // Constructs a single SPDY data frame with the given content and padding.
   SpdyFrame* ConstructSpdyBodyFrame(int stream_id,
                                     const char* data,
-                                    uint32 len,
+                                    uint32_t len,
                                     bool fin,
                                     int padding_length);
 
   // Wraps |frame| in the payload of a data frame in stream |stream_id|.
   SpdyFrame* ConstructWrappedSpdyFrame(const scoped_ptr<SpdyFrame>& frame,
                                        int stream_id);
 
   // Called when necessary (when it will affect stream dependency specification
   // when setting dependencies based on priorioties) to notify the utility
   // class of stream destruction.
@@ skipping 20 matching lines @@
   const char* GetSchemeKey() const;
   const char* GetVersionKey() const;
   const char* GetPathKey() const;
 
  private:
   // |content_length| may be NULL, in which case the content-length
   // header will be omitted.
   scoped_ptr<SpdyHeaderBlock> ConstructHeaderBlock(
       base::StringPiece method,
       base::StringPiece url,
-      int64* content_length) const;
+      int64_t* content_length) const;
 
   const NextProto protocol_;
   const SpdyMajorVersion spdy_version_;
   GURL default_url_;
   bool dependency_priorities_;
 
   // Track a FIFO list of the stream_id of all created requests by priority.
   std::map<int, std::vector<int>> priority_to_stream_id_list_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_TEST_UTIL_COMMON_H_