Switch to standard integer types in net/.

net/dns/host_resolver_impl.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"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
 #endif
 
 #include <cmath>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 176 matching lines @@
     return false;
   IPEndPoint endpoint;
   rv = socket->GetLocalAddress(&endpoint);
   if (rv != OK)
     return false;
   DCHECK_EQ(ADDRESS_FAMILY_IPV6, endpoint.GetFamily());
   const IPAddressNumber& address = endpoint.address();
   bool is_link_local = (address[0] == 0xFE) && ((address[1] & 0xC0) == 0x80);
   if (is_link_local)
     return false;
-  const uint8 kTeredoPrefix[] = { 0x20, 0x01, 0, 0 };
+  const uint8_t kTeredoPrefix[] = {0x20, 0x01, 0, 0};
   bool is_teredo = std::equal(kTeredoPrefix,
                               kTeredoPrefix + arraysize(kTeredoPrefix),
                               address.begin());
   if (is_teredo)
     return false;
   return true;
 }
 
 // Provide a common macro to simplify code and readability. We must use a
 // macro as the underlying HISTOGRAM macro creates static variables.
@@ skipping 50 matching lines @@
   std::string group_name = base::FieldTrialList::FindFullName("AsyncDns");
   if (!group_name.empty()) {
     return base::StartsWith(group_name, "AsyncDnsNoFallback",
                             base::CompareCase::INSENSITIVE_ASCII);
   }
   return kDefault;
 }
 
 //-----------------------------------------------------------------------------
 
-AddressList EnsurePortOnAddressList(const AddressList& list, uint16 port) {
+AddressList EnsurePortOnAddressList(const AddressList& list, uint16_t port) {
   if (list.empty() || list.front().port() == port)
     return list;
   return AddressList::CopyWithPort(list, port);
 }
 
 // Returns true if |addresses| contains only IPv4 loopback addresses.
 bool IsAllIPv4Loopback(const AddressList& addresses) {
   for (unsigned i = 0; i < addresses.size(); ++i) {
     const IPAddressNumber& address = addresses[i].address();
     switch (addresses[i].GetFamily()) {
       case ADDRESS_FAMILY_IPV4:
         if (address[0] != 127)
           return false;
         break;
       case ADDRESS_FAMILY_IPV6:
         return false;
       default:
         NOTREACHED();
         return false;
     }
   }
   return true;
 }
 
 // Creates NetLog parameters when the resolve failed.
 scoped_ptr<base::Value> NetLogProcTaskFailedCallback(
-    uint32 attempt_number,
+    uint32_t attempt_number,
     int net_error,
     int os_error,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   if (attempt_number)
     dict->SetInteger("attempt_number", attempt_number);
 
   dict->SetInteger("net_error", net_error);
 
   if (os_error) {
@@ skipping 360 matching lines @@
           params_.unresponsive_delay);
     }
   }
 
   // WARNING: This code runs inside a worker pool. The shutdown code cannot
   // wait for it to finish, so we must be very careful here about using other
   // objects (like MessageLoops, Singletons, etc). During shutdown these objects
   // may no longer exist. Multiple DoLookups() could be running in parallel, so
   // any state inside of |this| must not mutate .
   void DoLookup(const base::TimeTicks& start_time,
-                const uint32 attempt_number) {
+                const uint32_t attempt_number) {
     AddressList results;
     int os_error = 0;
     // Running on the worker thread
     int error = params_.resolver_proc->Resolve(key_.hostname,
                                                key_.address_family,
                                                key_.host_resolver_flags,
                                                &results,
                                                &os_error);
 
     // Fail the resolution if the result contains 127.0.53.53. See the comment
@@ skipping 25 matching lines @@
     if (was_completed() || was_canceled())
       return;
 
     params_.unresponsive_delay *= params_.retry_factor;
     StartLookupAttempt();
   }
 
   // Callback for when DoLookup() completes (runs on task runner thread).
   void OnLookupComplete(const AddressList& results,
                         const base::TimeTicks& start_time,
-                        const uint32 attempt_number,
+                        const uint32_t attempt_number,
                         int error,
                         const int os_error) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     // If results are empty, we should return an error.
     bool empty_list_on_ok = (error == OK && results.empty());
     UMA_HISTOGRAM_BOOLEAN("DNS.EmptyAddressListAndNoError", empty_list_on_ok);
     if (empty_list_on_ok)
       error = ERR_NAME_NOT_RESOLVED;
 
     bool was_retry_attempt = attempt_number > 1;
@@ skipping 112 matching lines @@
       UMA_HISTOGRAM_CUSTOM_ENUMERATION(kOSErrorsForGetAddrinfoHistogramName,
                                        std::abs(os_error),
                                        GetAllGetAddrinfoOSErrors());
     }
     DCHECK_LT(category, static_cast<int>(RESOLVE_MAX));  // Be sure it was set.
 
     UMA_HISTOGRAM_ENUMERATION("DNS.ResolveCategory", category, RESOLVE_MAX);
   }
 
   void RecordAttemptHistograms(const base::TimeTicks& start_time,
-                               const uint32 attempt_number,
+                               const uint32_t attempt_number,
                                const int error,
                                const int os_error) const {
     DCHECK(task_runner_->BelongsToCurrentThread());
     bool first_attempt_to_complete =
         completed_attempt_number_ == attempt_number;
     bool is_first_attempt = (attempt_number == 1);
 
     if (first_attempt_to_complete) {
       // If this was first attempt to complete, then record the resolution
       // status of the attempt.
@@ skipping 47 matching lines @@
 
   // The listener to the results of this ProcTask.
   Callback callback_;
 
   // Used to post ourselves onto the task runner thread.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // Keeps track of the number of attempts we have made so far to resolve the
   // host. Whenever we start an attempt to resolve the host, we increase this
   // number.
-  uint32 attempt_number_;
+  uint32_t attempt_number_;
 
   // The index of the attempt which finished first (or 0 if the job is still in
   // progress).
-  uint32 completed_attempt_number_;
+  uint32_t completed_attempt_number_;
 
   // The result (a net error code) from the first attempt to complete.
   int completed_attempt_error_;
 
   // The time when retry attempt was finished.
   base::TimeTicks retry_attempt_finished_time_;
 
   // True if a non-speculative request was ever attached to this job
   // (regardless of whether or not it was later canceled.
   // This boolean is used for histogramming the duration of jobs used to
@@ skipping 1465 matching lines @@
     dns_client_->SetConfig(dns_config);
     num_dns_failures_ = 0;
     if (dns_client_->GetConfig())
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
   }
 
   AbortDnsTasks();
 }
 
 }  // namespace net