Switch to standard integer types in net/.

net/dns/dns_test_util.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/dns/dns_test_util.h"
 
 #include <string>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
@@ skipping 23 matching lines @@
     callback.Run(true, list);
   }
 };
 
 // A DnsTransaction which uses MockDnsClientRuleList to determine the response.
 class MockTransaction : public DnsTransaction,
                         public base::SupportsWeakPtr<MockTransaction> {
  public:
   MockTransaction(const MockDnsClientRuleList& rules,
                   const std::string& hostname,
-                  uint16 qtype,
+                  uint16_t qtype,
                   const DnsTransactionFactory::CallbackType& callback)
       : result_(MockDnsClientRule::FAIL),
         hostname_(hostname),
         qtype_(qtype),
         callback_(callback),
         started_(false),
         delayed_(false) {
     // Find the relevant rule which matches |qtype| and prefix of |hostname|.
     for (size_t i = 0; i < rules.size(); ++i) {
       const std::string& prefix = rules[i].prefix;
       if ((rules[i].qtype == qtype) &&
           (hostname.size() >= prefix.size()) &&
           (hostname.compare(0, prefix.size(), prefix) == 0)) {
         result_ = rules[i].result;
         delayed_ = rules[i].delay;
         break;
       }
     }
   }
 
   const std::string& GetHostname() const override { return hostname_; }
 
-  uint16 GetType() const override { return qtype_; }
+  uint16_t GetType() const override { return qtype_; }
 
   void Start() override {
     EXPECT_FALSE(started_);
     started_ = true;
     if (delayed_)
       return;
     // Using WeakPtr to cleanly cancel when transaction is destroyed.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&MockTransaction::Finish, AsWeakPtr()));
   }
@@ skipping 17 matching lines @@
 
         DnsResponse response;
         char* buffer = response.io_buffer()->data();
         int nbytes = query.io_buffer()->size();
         memcpy(buffer, query.io_buffer()->data(), nbytes);
         dns_protocol::Header* header =
             reinterpret_cast<dns_protocol::Header*>(buffer);
         header->flags |= dns_protocol::kFlagResponse;
 
         if (MockDnsClientRule::OK == result_) {
-          const uint16 kPointerToQueryName =
-              static_cast<uint16>(0xc000 | sizeof(*header));
+          const uint16_t kPointerToQueryName =
+              static_cast<uint16_t>(0xc000 | sizeof(*header));
 
-          const uint32 kTTL = 86400;  // One day.
+          const uint32_t kTTL = 86400;  // One day.
 
           // Size of RDATA which is a IPv4 or IPv6 address.
           size_t rdata_size = qtype_ == dns_protocol::kTypeA ? kIPv4AddressSize
                                                              : kIPv6AddressSize;
 
           // 12 is the sum of sizes of the compressed name reference, TYPE,
           // CLASS, TTL and RDLENGTH.
           size_t answer_size = 12 + rdata_size;
 
           // Write answer with loopback IP address.
           header->ancount = base::HostToNet16(1);
           base::BigEndianWriter writer(buffer + nbytes, answer_size);
           writer.WriteU16(kPointerToQueryName);
           writer.WriteU16(qtype_);
           writer.WriteU16(dns_protocol::kClassIN);
           writer.WriteU32(kTTL);
-          writer.WriteU16(static_cast<uint16>(rdata_size));
+          writer.WriteU16(static_cast<uint16_t>(rdata_size));
           if (qtype_ == dns_protocol::kTypeA) {
             char kIPv4Loopback[] = { 0x7f, 0, 0, 1 };
             writer.WriteBytes(kIPv4Loopback, sizeof(kIPv4Loopback));
           } else {
             char kIPv6Loopback[] = { 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 1 };
             writer.WriteBytes(kIPv6Loopback, sizeof(kIPv6Loopback));
           }
           nbytes += answer_size;
         }
         EXPECT_TRUE(response.InitParse(nbytes, query));
         callback_.Run(this, OK, &response);
       } break;
       case MockDnsClientRule::FAIL:
         callback_.Run(this, ERR_NAME_NOT_RESOLVED, NULL);
         break;
       case MockDnsClientRule::TIMEOUT:
         callback_.Run(this, ERR_DNS_TIMED_OUT, NULL);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   MockDnsClientRule::Result result_;
   const std::string hostname_;
-  const uint16 qtype_;
+  const uint16_t qtype_;
   DnsTransactionFactory::CallbackType callback_;
   bool started_;
   bool delayed_;
 };
 
 }  // namespace
 
 // A DnsTransactionFactory which creates MockTransaction.
 class MockTransactionFactory : public DnsTransactionFactory {
  public:
   explicit MockTransactionFactory(const MockDnsClientRuleList& rules)
       : rules_(rules) {}
 
   ~MockTransactionFactory() override {}
 
   scoped_ptr<DnsTransaction> CreateTransaction(
       const std::string& hostname,
-      uint16 qtype,
+      uint16_t qtype,
       const DnsTransactionFactory::CallbackType& callback,
       const BoundNetLog&) override {
     MockTransaction* transaction =
         new MockTransaction(rules_, hostname, qtype, callback);
     if (transaction->delayed())
       delayed_transactions_.push_back(transaction->AsWeakPtr());
     return scoped_ptr<DnsTransaction>(transaction);
   }
 
   void CompleteDelayedTransactions() {
@@ skipping 36 matching lines @@
 
 AddressSorter* MockDnsClient::GetAddressSorter() {
   return address_sorter_.get();
 }
 
 void MockDnsClient::CompleteDelayedTransactions() {
   factory_->CompleteDelayedTransactions();
 }
 
 }  // namespace net