Switch to standard integer types in net/.

net/spdy/spdy_test_utils.cc

 // 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.
 
 #include "net/spdy/spdy_test_utils.h"
 
 #include <cstring>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 71 matching lines @@
   ADD_FAILURE()
       << "Description:\n"
       << description
       << "\n\nExpected:\n"
       << HexDumpWithMarks(expected, expected_len, marks.get(), max_len)
       << "\nActual:\n"
       << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
 }
 
 void SetFrameFlags(SpdyFrame* frame,
-                   uint8 flags,
+                   uint8_t flags,
                    SpdyMajorVersion spdy_version) {
   switch (spdy_version) {
     case SPDY2:
     case SPDY3:
     case HTTP2:
       frame->data()[4] = flags;
       break;
     default:
       LOG(FATAL) << "Unsupported SPDY version.";
   }
 }
 
 void SetFrameLength(SpdyFrame* frame,
                     size_t length,
                     SpdyMajorVersion spdy_version) {
   switch (spdy_version) {
     case SPDY2:
     case SPDY3:
       CHECK_EQ(0u, length & ~kLengthMask);
       {
-        int32 wire_length = base::HostToNet32(length);
+        int32_t wire_length = base::HostToNet32(length);
         // The length field in SPDY 2 and 3 is a 24-bit (3B) integer starting at
         // offset 5.
         memcpy(frame->data() + 5, reinterpret_cast<char*>(&wire_length) + 1, 3);
       }
       break;
     case HTTP2:
       CHECK_GT(1u<<14, length);
       {
-        int32 wire_length = base::HostToNet32(length);
+        int32_t wire_length = base::HostToNet32(length);
         memcpy(frame->data(),
                reinterpret_cast<char*>(&wire_length) + 1,
                3);
       }
       break;
     default:
       LOG(FATAL) << "Unsupported SPDY version.";
   }
 }
 
 std::string a2b_hex(const char* hex_data) {
-  std::vector<uint8> output;
+  std::vector<uint8_t> output;
   std::string result;
   if (base::HexStringToBytes(hex_data, &output))
     result.assign(reinterpret_cast<const char*>(&output[0]), output.size());
   return result;
 }
 
 HashValue GetTestHashValue(uint8_t label) {
   HashValue hash_value(HASH_VALUE_SHA256);
   memset(hash_value.data(), label, hash_value.size());
   return hash_value;
@@ skipping 18 matching lines @@
 
   // Construct a fake SSLInfo that will pass AddHPKPHeader's checks.
   SSLInfo ssl_info;
   ssl_info.is_issued_by_known_root = true;
   ssl_info.public_key_hashes.push_back(GetTestHashValue(primary_label));
   EXPECT_TRUE(state->AddHPKPHeader(host, header, ssl_info));
 }
 
 }  // namespace test
 }  // namespace net