Switch to standard integer types in net/.

net/spdy/spdy_test_util_common.cc

 // 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.
 
 #include "net/spdy/spdy_test_util_common.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 
@@ skipping 208 matching lines @@
                          const char* data,
                          size_t len,
                          bool fin) override {}
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {}
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId stream_id) override {
     return nullptr;
   }
   void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {}
   void OnSettings(bool clear_persisted) override {}
-  void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override {}
+  void OnSetting(SpdySettingsIds id, uint8_t flags, uint32_t value) override {}
   void OnPing(SpdyPingId unique_id, bool is_ack) override {}
   void OnRstStream(SpdyStreamId stream_id,
                    SpdyRstStreamStatus status) override {}
   void OnGoAway(SpdyStreamId last_accepted_stream_id,
                 SpdyGoAwayStatus status,
                 StringPiece debug_data) override {}
   void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override {}
   void OnPushPromise(SpdyStreamId stream_id,
                      SpdyStreamId promised_stream_id,
                      const SpdyHeaderBlock& headers) override {}
@@ skipping 49 matching lines @@
     SpdyStreamRequest* request, int result) {
   if (result == OK)
     request->ReleaseStream()->Cancel();
   SetResult(result);
 }
 
 MockECSignatureCreator::MockECSignatureCreator(crypto::ECPrivateKey* key)
     : key_(key) {
 }
 
-bool MockECSignatureCreator::Sign(const uint8* data,
+bool MockECSignatureCreator::Sign(const uint8_t* data,
                                   int data_len,
-                                  std::vector<uint8>* signature) {
-  std::vector<uint8> private_key_value;
+                                  std::vector<uint8_t>* signature) {
+  std::vector<uint8_t> private_key_value;
   key_->ExportValue(&private_key_value);
   std::string head = "fakesignature";
   std::string tail = "/fakesignature";
 
   signature->clear();
   signature->insert(signature->end(), head.begin(), head.end());
   signature->insert(signature->end(), private_key_value.begin(),
                     private_key_value.end());
   signature->insert(signature->end(), '-');
   signature->insert(signature->end(), data, data + data_len);
   signature->insert(signature->end(), tail.begin(), tail.end());
   return true;
 }
 
 bool MockECSignatureCreator::DecodeSignature(
-    const std::vector<uint8>& signature,
-    std::vector<uint8>* out_raw_sig) {
+    const std::vector<uint8_t>& signature,
+    std::vector<uint8_t>* out_raw_sig) {
   *out_raw_sig = signature;
   return true;
 }
 
 MockECSignatureCreatorFactory::MockECSignatureCreatorFactory() {
   crypto::ECSignatureCreator::SetFactoryForTesting(this);
 }
 
 MockECSignatureCreatorFactory::~MockECSignatureCreatorFactory() {
   crypto::ECSignatureCreator::SetFactoryForTesting(NULL);
@@ skipping 389 matching lines @@
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlockForProxy(
     base::StringPiece url) const {
   scoped_ptr<SpdyHeaderBlock> headers(ConstructGetHeaderBlock(url));
   return headers.Pass();
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeadHeaderBlock(
     base::StringPiece url,
-    int64 content_length) const {
+    int64_t content_length) const {
   return ConstructHeaderBlock("HEAD", url, nullptr);
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPostHeaderBlock(
     base::StringPiece url,
-    int64 content_length) const {
+    int64_t content_length) const {
   return ConstructHeaderBlock("POST", url, &content_length);
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPutHeaderBlock(
     base::StringPiece url,
-    int64 content_length) const {
+    int64_t content_length) const {
   return ConstructHeaderBlock("PUT", url, &content_length);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(
     const SpdyHeaderInfo& header_info,
     scoped_ptr<SpdyHeaderBlock> headers) const {
   BufferedSpdyFramer framer(spdy_version_, header_info.compressed);
   SpdyFrame* frame = NULL;
   switch (header_info.kind) {
     case DATA:
@@ skipping 126 matching lines @@
 
   if (spdy_version() > SPDY3) {
     SpdySettingsIR settings_ir;
     settings_ir.set_is_ack(true);
     return CreateFramer(false)->SerializeFrame(settings_ir);
   }
   // No settings ACK write occurs. Create an empty placeholder write.
   return new SpdyFrame(kEmptyWrite, 0, false);
 }
 
-SpdyFrame* SpdyTestUtil::ConstructSpdyPing(uint32 ping_id, bool is_ack) const {
+SpdyFrame* SpdyTestUtil::ConstructSpdyPing(uint32_t ping_id,
+                                           bool is_ack) const {
   SpdyPingIR ping_ir(ping_id);
   ping_ir.set_is_ack(is_ack);
   return CreateFramer(false)->SerializeFrame(ping_ir);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway() const {
   return ConstructSpdyGoAway(0);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway(
     SpdyStreamId last_good_stream_id) const {
   SpdyGoAwayIR go_ir(last_good_stream_id, GOAWAY_OK, "go away");
   return CreateFramer(false)->SerializeFrame(go_ir);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway(SpdyStreamId last_good_stream_id,
                                              SpdyGoAwayStatus status,
                                              const std::string& desc) const {
   SpdyGoAwayIR go_ir(last_good_stream_id, status, desc);
   return CreateFramer(false)->SerializeFrame(go_ir);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyWindowUpdate(
-    const SpdyStreamId stream_id, uint32 delta_window_size) const {
+    const SpdyStreamId stream_id,
+    uint32_t delta_window_size) const {
   SpdyWindowUpdateIR update_ir(stream_id, delta_window_size);
   return CreateFramer(false)->SerializeFrame(update_ir);
 }
 
 // TODO(jgraettinger): Eliminate uses of this method in tests (prefer
 // SpdyRstStreamIR).
 SpdyFrame* SpdyTestUtil::ConstructSpdyRstStream(
     SpdyStreamId stream_id,
     SpdyRstStreamStatus status) const {
   SpdyRstStreamIR rst_ir(stream_id, status);
@@ skipping 255 matching lines @@
   block[GetStatusKey()] = "200";
   MaybeAddVersionHeader(&block);
   block["hello"] = "bye";
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
 
   return ConstructSpdyReply(stream_id, block);
 }
 
 SpdyFrame* SpdyTestUtil::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) {
   scoped_ptr<SpdyHeaderBlock> block(
       ConstructPostHeaderBlock(url, content_length));
   AppendToHeaderBlock(extra_headers, extra_header_count, block.get());
   return ConstructSpdySyn(stream_id, *block, priority, false, false);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
@@ skipping 17 matching lines @@
 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id, bool fin) {
   SpdyFramer framer(spdy_version_);
   SpdyDataIR data_ir(stream_id,
                      base::StringPiece(kUploadData, kUploadDataSize));
   data_ir.set_fin(fin);
   return framer.SerializeData(data_ir);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
                                                 const char* data,
-                                                uint32 len,
+                                                uint32_t len,
                                                 bool fin) {
   SpdyFramer framer(spdy_version_);
   SpdyDataIR data_ir(stream_id, base::StringPiece(data, len));
   data_ir.set_fin(fin);
   return framer.SerializeData(data_ir);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
                                                 const char* data,
-                                                uint32 len,
+                                                uint32_t len,
                                                 bool fin,
                                                 int padding_length) {
   SpdyFramer framer(spdy_version_);
   SpdyDataIR data_ir(stream_id, base::StringPiece(data, len));
   data_ir.set_fin(fin);
   data_ir.set_padding_len(padding_length);
   return framer.SerializeData(data_ir);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructWrappedSpdyFrame(
@@ skipping 46 matching lines @@
   return ":version";
 }
 
 const char* SpdyTestUtil::GetPathKey() const {
   return ":path";
 }
 
 scoped_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeaderBlock(
     base::StringPiece method,
     base::StringPiece url,
-    int64* content_length) const {
+    int64_t* content_length) const {
   std::string scheme, host, path;
   ParseUrl(url.data(), &scheme, &host, &path);
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
   if (include_version_header()) {
     (*headers)[GetVersionKey()] = "HTTP/1.1";
   }
   (*headers)[GetMethodKey()] = method.as_string();
   (*headers)[GetHostKey()] = host.c_str();
   (*headers)[GetSchemeKey()] = scheme.c_str();
   (*headers)[GetPathKey()] = path.c_str();
@@ skipping 17 matching lines @@
   }
 }
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
   ir->set_priority(ConvertRequestPriorityToSpdyPriority(
       priority, spdy_version()));
 }
 
 }  // namespace net