Switch to standard integer types in net/.

net/quic/test_tools/crypto_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/quic/test_tools/crypto_test_utils.h"
 
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
@@ skipping 36 matching lines @@
 
   const vector<CryptoHandshakeMessage>& messages() const { return messages_; }
 
  private:
   bool error_;
   vector<CryptoHandshakeMessage> messages_;
 };
 
 // HexChar parses |c| as a hex character. If valid, it sets |*value| to the
 // value of the hex character and returns true. Otherwise it returns false.
-bool HexChar(char c, uint8* value) {
+bool HexChar(char c, uint8_t* value) {
   if (c >= '0' && c <= '9') {
     *value = c - '0';
     return true;
   }
   if (c >= 'a' && c <= 'f') {
     *value = c - 'a' + 10;
     return true;
   }
   if (c >= 'A' && c <= 'F') {
     *value = c - 'A' + 10;
@@ skipping 213 matching lines @@
                                        QuicTag tag) {
   QuicTagValueMap::const_iterator it = message.tag_value_map().find(tag);
   if (it == message.tag_value_map().end()) {
     return string();
   }
   return it->second;
 }
 
 class MockCommonCertSets : public CommonCertSets {
  public:
-  MockCommonCertSets(StringPiece cert, uint64 hash, uint32 index)
+  MockCommonCertSets(StringPiece cert, uint64_t hash, uint32_t index)
       : cert_(cert.as_string()), hash_(hash), index_(index) {}
 
   StringPiece GetCommonHashes() const override {
     CHECK(false) << "not implemented";
     return StringPiece();
   }
 
-  StringPiece GetCert(uint64 hash, uint32 index) const override {
+  StringPiece GetCert(uint64_t hash, uint32_t index) const override {
     if (hash == hash_ && index == index_) {
       return cert_;
     }
     return StringPiece();
   }
 
   bool MatchCert(StringPiece cert,
                  StringPiece common_set_hashes,
-                 uint64* out_hash,
-                 uint32* out_index) const override {
+                 uint64_t* out_hash,
+                 uint32_t* out_index) const override {
     if (cert != cert_) {
       return false;
     }
 
-    if (common_set_hashes.size() % sizeof(uint64) != 0) {
+    if (common_set_hashes.size() % sizeof(uint64_t) != 0) {
       return false;
     }
     bool client_has_set = false;
-    for (size_t i = 0; i < common_set_hashes.size(); i += sizeof(uint64)) {
-      uint64 hash;
+    for (size_t i = 0; i < common_set_hashes.size(); i += sizeof(uint64_t)) {
+      uint64_t hash;
       memcpy(&hash, common_set_hashes.data() + i, sizeof(hash));
       if (hash == hash_) {
         client_has_set = true;
         break;
       }
     }
 
     if (!client_has_set) {
       return false;
     }
 
     *out_hash = hash_;
     *out_index = index_;
     return true;
   }
 
  private:
   const string cert_;
-  const uint64 hash_;
-  const uint32 index_;
+  const uint64_t hash_;
+  const uint32_t index_;
 };
 
 CommonCertSets* CryptoTestUtils::MockCommonCertSets(StringPiece cert,
-                                                    uint64 hash,
-                                                    uint32 index) {
+                                                    uint64_t hash,
+                                                    uint32_t index) {
   return new class MockCommonCertSets(cert, hash, index);
 }
 
 // static
 void CryptoTestUtils::FillInDummyReject(CryptoHandshakeMessage* rej,
                                         bool reject_is_stateless) {
   if (reject_is_stateless) {
     rej->set_tag(kSREJ);
   } else {
     rej->set_tag(kREJ);
@@ skipping 143 matching lines @@
 
   QuicTag tag = 0;
 
   if (tagstr[0] == '#') {
     CHECK_EQ(static_cast<size_t>(1 + 2 * 4), len);
     tagstr++;
 
     for (size_t i = 0; i < 8; i++) {
       tag <<= 4;
 
-      uint8 v = 0;
+      uint8_t v = 0;
       CHECK(HexChar(tagstr[i], &v));
       tag |= v;
     }
 
     return tag;
   }
 
   CHECK_LE(len, 4u);
   for (size_t i = 0; i < 4; i++) {
     tag >>= 8;
     if (i < len) {
-      tag |= static_cast<uint32>(tagstr[i]) << 24;
+      tag |= static_cast<uint32_t>(tagstr[i]) << 24;
     }
   }
 
   return tag;
 }
 
 // static
 CryptoHandshakeMessage CryptoTestUtils::Message(const char* message_tag, ...) {
   va_list ap;
   va_start(ap, message_tag);
@@ skipping 22 matching lines @@
 
     const QuicTag tag = ParseTag(tagstr);
     const char* valuestr = va_arg(ap, const char*);
 
     size_t len = strlen(valuestr);
     if (len > 0 && valuestr[0] == '#') {
       valuestr++;
       len--;
 
       CHECK_EQ(0u, len % 2);
-      scoped_ptr<uint8[]> buf(new uint8[len / 2]);
+      scoped_ptr<uint8_t[]> buf(new uint8_t[len / 2]);
 
       for (size_t i = 0; i < len / 2; i++) {
-        uint8 v = 0;
+        uint8_t v = 0;
         CHECK(HexChar(valuestr[i * 2], &v));
         buf[i] = v << 4;
         CHECK(HexChar(valuestr[i * 2 + 1], &v));
         buf[i] |= v;
       }
 
       msg.SetStringPiece(
           tag, StringPiece(reinterpret_cast<char*>(buf.get()), len / 2));
       continue;
     }
@@ skipping 50 matching lines @@
 
   ASSERT_EQ(0u, crypto_framer.InputBytesRemaining());
 
   for (const CryptoHandshakeMessage& message : crypto_visitor.messages()) {
     dest_stream->OnHandshakeMessage(message);
   }
 }
 
 }  // namespace test
 }  // namespace net