Switch to standard integer types in net/.

net/dns/host_resolver_impl_unittest.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/host_resolver_impl.h"
 
 #include <algorithm>
 #include <string>
 #include <tuple>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/test/test_timeouts.h"
@@ skipping 154 matching lines @@
   std::map<ResolveKey, AddressList> rules_;
   CaptureList capture_list_;
   unsigned num_requests_waiting_;
   unsigned num_slots_available_;
   base::ConditionVariable requests_waiting_;
   base::ConditionVariable slots_available_;
 
   DISALLOW_COPY_AND_ASSIGN(MockHostResolverProc);
 };
 
-bool AddressListContains(const AddressList& list, const std::string& address,
-                         uint16 port) {
+bool AddressListContains(const AddressList& list,
+                         const std::string& address,
+                         uint16_t port) {
   IPAddressNumber ip;
   bool rv = ParseIPLiteralToNumber(address, &ip);
   DCHECK(rv);
   return std::find(list.begin(),
                    list.end(),
                    IPEndPoint(ip, port)) != list.end();
 }
 
 // A wrapper for requests to a HostResolver.
 class Request {
@@ skipping 47 matching lines @@
     handle_ = NULL;
   }
 
   const HostResolver::RequestInfo& info() const { return info_; }
   size_t index() const { return index_; }
   const AddressList& list() const { return list_; }
   int result() const { return result_; }
   bool completed() const { return result_ != ERR_IO_PENDING; }
   bool pending() const { return handle_ != NULL; }
 
-  bool HasAddress(const std::string& address, uint16 port) const {
+  bool HasAddress(const std::string& address, uint16_t port) const {
     return AddressListContains(list_, address, port);
   }
 
   // Returns the number of addresses in |list_|.
   unsigned NumberOfAddresses() const {
     return list_.size();
   }
 
-  bool HasOneAddress(const std::string& address, uint16 port) const {
+  bool HasOneAddress(const std::string& address, uint16_t port) const {
     return HasAddress(address, port) && (NumberOfAddresses() == 1u);
   }
 
   // Returns ERR_UNEXPECTED if timed out.
   int WaitForResult() {
     if (completed())
       return result_;
     base::CancelableClosure closure(base::MessageLoop::QuitWhenIdleClosure());
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, closure.callback(), TestTimeouts::action_max_timeout());
@@ skipping 1189 matching lines @@
     HostResolverImpl::Options options = DefaultOptions();
     options.max_concurrent_resolves = max_concurrent_resolves;
     resolver_.reset(new TestHostResolverImpl(options, NULL));
     resolver_->set_proc_params_for_test(params);
     dns_client_ = new MockDnsClient(DnsConfig(), dns_rules_);
     resolver_->SetDnsClient(scoped_ptr<DnsClient>(dns_client_));
   }
 
   // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply.
   void AddDnsRule(const std::string& prefix,
-                  uint16 qtype,
+                  uint16_t qtype,
                   MockDnsClientRule::Result result,
                   bool delay) {
     dns_rules_.push_back(MockDnsClientRule(prefix, qtype, result, delay));
   }
 
   void ChangeDnsConfig(const DnsConfig& config) {
     NetworkChangeNotifier::SetDnsConfig(config);
     // Notification is delivered asynchronously.
     base::MessageLoop::current()->RunUntilIdle();
   }
@@ skipping 682 matching lines @@
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
   EXPECT_EQ(OK, requests_[1]->WaitForResult());
   EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.0.2", 80));
   EXPECT_EQ(OK, requests_[2]->WaitForResult());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.0.3", 80));
 }
 
 }  // namespace net