Clang format slam.

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>
@@ skipping 124 matching lines @@
 
 enum DnsResolveStatus {
   RESOLVE_STATUS_DNS_SUCCESS = 0,
   RESOLVE_STATUS_PROC_SUCCESS,
   RESOLVE_STATUS_FAIL,
   RESOLVE_STATUS_SUSPECT_NETBIOS,
   RESOLVE_STATUS_MAX
 };
 
 void UmaAsyncDnsResolveStatus(DnsResolveStatus result) {
-  UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ResolveStatus",
-                            result,
-                            RESOLVE_STATUS_MAX);
+  UMA_HISTOGRAM_ENUMERATION(
+      "AsyncDNS.ResolveStatus", result, RESOLVE_STATUS_MAX);
 }
 
 bool ResemblesNetBIOSName(const std::string& hostname) {
   return (hostname.size() < 16) && (hostname.find('.') == std::string::npos);
 }
 
 // True if |hostname| ends with either ".local" or ".local.".
 bool ResemblesMulticastDNSName(const std::string& hostname) {
   DCHECK(!hostname.empty());
   const char kSuffix[] = ".local.";
   const size_t kSuffixLen = sizeof(kSuffix) - 1;
   const size_t kSuffixLenTrimmed = kSuffixLen - 1;
   if (hostname[hostname.size() - 1] == '.') {
     return hostname.size() > kSuffixLen &&
-        !hostname.compare(hostname.size() - kSuffixLen, kSuffixLen, kSuffix);
+           !hostname.compare(hostname.size() - kSuffixLen, kSuffixLen, kSuffix);
   }
   return hostname.size() > kSuffixLenTrimmed &&
-      !hostname.compare(hostname.size() - kSuffixLenTrimmed, kSuffixLenTrimmed,
-                        kSuffix, kSuffixLenTrimmed);
+         !hostname.compare(hostname.size() - kSuffixLenTrimmed,
+                           kSuffixLenTrimmed,
+                           kSuffix,
+                           kSuffixLenTrimmed);
 }
 
 // Attempts to connect a UDP socket to |dest|:53.
 bool IsGloballyReachable(const IPAddressNumber& dest,
                          const BoundNetLog& net_log) {
   scoped_ptr<DatagramClientSocket> socket(
       ClientSocketFactory::GetDefaultFactory()->CreateDatagramClientSocket(
           DatagramSocket::DEFAULT_BIND,
           RandIntCallback(),
           net_log.net_log(),
           net_log.source()));
   int rv = socket->Connect(IPEndPoint(dest, 53));
   if (rv != OK)
     return false;
   IPEndPoint endpoint;
   rv = socket->GetLocalAddress(&endpoint);
   if (rv != OK)
     return false;
   DCHECK(endpoint.GetFamily() == ADDRESS_FAMILY_IPV6);
   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 };
-  bool is_teredo = std::equal(kTeredoPrefix,
-                              kTeredoPrefix + arraysize(kTeredoPrefix),
-                              address.begin());
+  const uint8 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.
-#define DNS_HISTOGRAM(name, time) UMA_HISTOGRAM_CUSTOM_TIMES(name, time, \
-    base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromHours(1), 100)
+#define DNS_HISTOGRAM(name, time)                                  \
+  UMA_HISTOGRAM_CUSTOM_TIMES(name,                                 \
+                             time,                                 \
+                             base::TimeDelta::FromMilliseconds(1), \
+                             base::TimeDelta::FromHours(1),        \
+                             100)
 
 // A macro to simplify code and readability.
 #define DNS_HISTOGRAM_BY_PRIORITY(basename, priority, time) \
-  do { \
-    switch (priority) { \
-      case HIGHEST: DNS_HISTOGRAM(basename "_HIGHEST", time); break; \
-      case MEDIUM: DNS_HISTOGRAM(basename "_MEDIUM", time); break; \
-      case LOW: DNS_HISTOGRAM(basename "_LOW", time); break; \
-      case LOWEST: DNS_HISTOGRAM(basename "_LOWEST", time); break; \
-      case IDLE: DNS_HISTOGRAM(basename "_IDLE", time); break; \
-      default: NOTREACHED(); break; \
-    } \
-    DNS_HISTOGRAM(basename, time); \
+  do {                                                      \
+    switch (priority) {                                     \
+      case HIGHEST:                                         \
+        DNS_HISTOGRAM(basename "_HIGHEST", time);           \
+        break;                                              \
+      case MEDIUM:                                          \
+        DNS_HISTOGRAM(basename "_MEDIUM", time);            \
+        break;                                              \
+      case LOW:                                             \
+        DNS_HISTOGRAM(basename "_LOW", time);               \
+        break;                                              \
+      case LOWEST:                                          \
+        DNS_HISTOGRAM(basename "_LOWEST", time);            \
+        break;                                              \
+      case IDLE:                                            \
+        DNS_HISTOGRAM(basename "_IDLE", time);              \
+        break;                                              \
+      default:                                              \
+        NOTREACHED();                                       \
+        break;                                              \
+    }                                                       \
+    DNS_HISTOGRAM(basename, time);                          \
   } while (0)
 
 // Record time from Request creation until a valid DNS response.
 void RecordTotalTime(bool had_dns_config,
                      bool speculative,
                      base::TimeDelta duration) {
   if (had_dns_config) {
     if (speculative) {
       DNS_HISTOGRAM("AsyncDNS.TotalTime_speculative", duration);
     } else {
       DNS_HISTOGRAM("AsyncDNS.TotalTime", duration);
     }
   } else {
     if (speculative) {
       DNS_HISTOGRAM("DNS.TotalTime_speculative", duration);
     } else {
       DNS_HISTOGRAM("DNS.TotalTime", duration);
     }
   }
 }
 
 void RecordTTL(base::TimeDelta ttl) {
-  UMA_HISTOGRAM_CUSTOM_TIMES("AsyncDNS.TTL", ttl,
+  UMA_HISTOGRAM_CUSTOM_TIMES("AsyncDNS.TTL",
+                             ttl,
                              base::TimeDelta::FromSeconds(1),
-                             base::TimeDelta::FromDays(1), 100);
+                             base::TimeDelta::FromDays(1),
+                             100);
 }
 
 bool ConfigureAsyncDnsNoFallbackFieldTrial() {
   const bool kDefault = false;
 
   // Configure the AsyncDns field trial as follows:
   // groups AsyncDnsNoFallbackA and AsyncDnsNoFallbackB: return true,
   // groups AsyncDnsA and AsyncDnsB: return false,
   // groups SystemDnsA and SystemDnsB: return false,
   // otherwise (trial absent): return default.
@@ skipping 41 matching lines @@
 
   dict->SetInteger("net_error", net_error);
 
   if (os_error) {
     dict->SetInteger("os_error", os_error);
 #if defined(OS_POSIX)
     dict->SetString("os_error_string", gai_strerror(os_error));
 #elif defined(OS_WIN)
     // Map the error code to a human-readable string.
     LPWSTR error_string = NULL;
-    int size = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                             FORMAT_MESSAGE_FROM_SYSTEM,
-                             0,  // Use the internal message table.
-                             os_error,
-                             0,  // Use default language.
-                             (LPWSTR)&error_string,
-                             0,  // Buffer size.
-                             0);  // Arguments (unused).
+    int size = FormatMessage(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+        0,  // Use the internal message table.
+        os_error,
+        0,  // Use default language.
+        (LPWSTR) & error_string,
+        0,   // Buffer size.
+        0);  // Arguments (unused).
     dict->SetString("os_error_string", base::WideToUTF8(error_string));
     LocalFree(error_string);
 #endif
   }
 
   return dict;
 }
 
 // Creates NetLog parameters when the DnsTask failed.
 base::Value* NetLogDnsTaskFailedCallback(int net_error,
                                          int dns_error,
                                          NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("net_error", net_error);
   if (dns_error)
     dict->SetInteger("dns_error", dns_error);
   return dict;
 };
 
 // Creates NetLog parameters containing the information in a RequestInfo object,
 // along with the associated NetLog::Source.
 base::Value* NetLogRequestInfoCallback(const NetLog::Source& source,
                                        const HostResolver::RequestInfo* info,
                                        NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   source.AddToEventParameters(dict);
 
   dict->SetString("host", info->host_port_pair().ToString());
-  dict->SetInteger("address_family",
-                   static_cast<int>(info->address_family()));
+  dict->SetInteger("address_family", static_cast<int>(info->address_family()));
   dict->SetBoolean("allow_cached_response", info->allow_cached_response());
   dict->SetBoolean("is_speculative", info->is_speculative());
   return dict;
 }
 
 // Creates NetLog parameters for the creation of a HostResolverImpl::Job.
 base::Value* NetLogJobCreationCallback(const NetLog::Source& source,
                                        const std::string* host,
                                        NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
@@ skipping 56 matching lines @@
 //-----------------------------------------------------------------------------
 
 // Keeps track of the highest priority.
 class PriorityTracker {
  public:
   explicit PriorityTracker(RequestPriority initial_priority)
       : highest_priority_(initial_priority), total_count_(0) {
     memset(counts_, 0, sizeof(counts_));
   }
 
-  RequestPriority highest_priority() const {
-    return highest_priority_;
-  }
+  RequestPriority highest_priority() const { return highest_priority_; }
 
-  size_t total_count() const {
-    return total_count_;
-  }
+  size_t total_count() const { return total_count_; }
 
   void Add(RequestPriority req_priority) {
     ++total_count_;
     ++counts_[req_priority];
     if (highest_priority_ < req_priority)
       highest_priority_ = req_priority;
   }
 
   void Remove(RequestPriority req_priority) {
     DCHECK_GT(total_count_, 0u);
     DCHECK_GT(counts_[req_priority], 0u);
     --total_count_;
     --counts_[req_priority];
     size_t i;
-    for (i = highest_priority_; i > MINIMUM_PRIORITY && !counts_[i]; --i);
+    for (i = highest_priority_; i > MINIMUM_PRIORITY && !counts_[i]; --i)
+      ;
     highest_priority_ = static_cast<RequestPriority>(i);
 
     // In absence of requests, default to MINIMUM_PRIORITY.
     if (total_count_ == 0)
       DCHECK_EQ(MINIMUM_PRIORITY, highest_priority_);
   }
 
  private:
   RequestPriority highest_priority_;
   size_t total_count_;
@@ skipping 26 matching lines @@
         addresses_(addresses),
         request_time_(base::TimeTicks::Now()) {}
 
   // Mark the request as canceled.
   void MarkAsCanceled() {
     job_ = NULL;
     addresses_ = NULL;
     callback_.Reset();
   }
 
-  bool was_canceled() const {
-    return callback_.is_null();
-  }
+  bool was_canceled() const { return callback_.is_null(); }
 
   void set_job(Job* job) {
     DCHECK(job);
     // Identify which job the request is waiting on.
     job_ = job;
   }
 
   // Prepare final AddressList and call completion callback.
   void OnComplete(int error, const AddressList& addr_list) {
     DCHECK(!was_canceled());
     if (error == OK)
       *addresses_ = EnsurePortOnAddressList(addr_list, info_.port());
     CompletionCallback callback = callback_;
     MarkAsCanceled();
     callback.Run(error);
   }
 
-  Job* job() const {
-    return job_;
-  }
+  Job* job() const { return job_; }
 
   // NetLog for the source, passed in HostResolver::Resolve.
-  const BoundNetLog& source_net_log() {
-    return source_net_log_;
-  }
+  const BoundNetLog& source_net_log() { return source_net_log_; }
 
   // NetLog for this request.
-  const BoundNetLog& request_net_log() {
-    return request_net_log_;
-  }
+  const BoundNetLog& request_net_log() { return request_net_log_; }
 
-  const RequestInfo& info() const {
-    return info_;
-  }
+  const RequestInfo& info() const { return info_; }
 
   RequestPriority priority() const { return priority_; }
 
   base::TimeTicks request_time() const { return request_time_; }
 
  private:
   BoundNetLog source_net_log_;
   BoundNetLog request_net_log_;
 
   // The request info that started the request.
@@ skipping 24 matching lines @@
 // resolution (OnLookupComplete) is completed or not. If the original attempt
 // hasn't completed, then we start another attempt for host resolution. We take
 // the results from the first attempt that finishes and ignore the results from
 // all other attempts.
 //
 // TODO(szym): Move to separate source file for testing and mocking.
 //
 class HostResolverImpl::ProcTask
     : public base::RefCountedThreadSafe<HostResolverImpl::ProcTask> {
  public:
-  typedef base::Callback<void(int net_error,
-                              const AddressList& addr_list)> Callback;
+  typedef base::Callback<void(int net_error, const AddressList& addr_list)>
+      Callback;
 
   ProcTask(const Key& key,
            const ProcTaskParams& params,
            const Callback& callback,
            const BoundNetLog& job_net_log)
       : key_(key),
         params_(params),
         callback_(callback),
         origin_loop_(base::MessageLoopProxy::current()),
         attempt_number_(0),
@@ skipping 53 matching lines @@
     // Dispatch the lookup attempt to a worker thread.
     if (!base::WorkerPool::PostTask(
             FROM_HERE,
             base::Bind(&ProcTask::DoLookup, this, start_time, attempt_number_),
             true)) {
       NOTREACHED();
 
       // Since we could be running within Resolve() right now, we can't just
       // call OnLookupComplete().  Instead we must wait until Resolve() has
       // returned (IO_PENDING).
-      origin_loop_->PostTask(
-          FROM_HERE,
-          base::Bind(&ProcTask::OnLookupComplete, this, AddressList(),
-                     start_time, attempt_number_, ERR_UNEXPECTED, 0));
+      origin_loop_->PostTask(FROM_HERE,
+                             base::Bind(&ProcTask::OnLookupComplete,
+                                        this,
+                                        AddressList(),
+                                        start_time,
+                                        attempt_number_,
+                                        ERR_UNEXPECTED,
+                                        0));
       return;
     }
 
     net_log_.AddEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_ATTEMPT_STARTED,
         NetLog::IntegerCallback("attempt_number", attempt_number_));
 
     // If we don't get the results within a given time, RetryIfNotComplete
     // will start a new attempt on a different worker thread if none of our
     // outstanding attempts have completed yet.
@@ skipping 14 matching lines @@
                 const uint32 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);
 
-    origin_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&ProcTask::OnLookupComplete, this, results, start_time,
-                   attempt_number, error, os_error));
+    origin_loop_->PostTask(FROM_HERE,
+                           base::Bind(&ProcTask::OnLookupComplete,
+                                      this,
+                                      results,
+                                      start_time,
+                                      attempt_number,
+                                      error,
+                                      os_error));
   }
 
   // Makes next attempt if DoLookup() has not finished (runs on origin thread).
   void RetryIfNotComplete() {
     DCHECK(origin_loop_->BelongsToCurrentThread());
 
     if (was_completed() || was_canceled())
       return;
 
     params_.unresponsive_delay *= params_.retry_factor;
@@ skipping 26 matching lines @@
     if (!was_retry_attempt)
       RecordPerformanceHistograms(start_time, error, os_error);
 
     RecordAttemptHistograms(start_time, attempt_number, error, os_error);
 
     if (was_canceled())
       return;
 
     NetLog::ParametersCallback net_log_callback;
     if (error != OK) {
-      net_log_callback = base::Bind(&NetLogProcTaskFailedCallback,
-                                    attempt_number,
-                                    error,
-                                    os_error);
+      net_log_callback = base::Bind(
+          &NetLogProcTaskFailedCallback, attempt_number, error, os_error);
     } else {
-      net_log_callback = NetLog::IntegerCallback("attempt_number",
-                                                 attempt_number);
+      net_log_callback =
+          NetLog::IntegerCallback("attempt_number", attempt_number);
     }
     net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_ATTEMPT_FINISHED,
                       net_log_callback);
 
     if (was_completed())
       return;
 
     // Copy the results from the first worker thread that resolves the host.
     results_ = results;
     completed_attempt_number_ = attempt_number;
     completed_attempt_error_ = error;
 
     if (was_retry_attempt) {
       // If retry attempt finishes before 1st attempt, then get stats on how
       // much time is saved by having spawned an extra attempt.
       retry_attempt_finished_time_ = base::TimeTicks::Now();
     }
 
     if (error != OK) {
-      net_log_callback = base::Bind(&NetLogProcTaskFailedCallback,
-                                    0, error, os_error);
+      net_log_callback =
+          base::Bind(&NetLogProcTaskFailedCallback, 0, error, os_error);
     } else {
       net_log_callback = results_.CreateNetLogCallback();
     }
     net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK,
                       net_log_callback);
 
     callback_.Run(error, results_);
   }
 
   void RecordPerformanceHistograms(const base::TimeTicks& start_time,
@@ skipping 14 matching lines @@
       if (had_non_speculative_request_) {
         category = RESOLVE_SUCCESS;
         DNS_HISTOGRAM("DNS.ResolveSuccess", duration);
       } else {
         category = RESOLVE_SPECULATIVE_SUCCESS;
         DNS_HISTOGRAM("DNS.ResolveSpeculativeSuccess", duration);
       }
 
       // Log DNS lookups based on |address_family|. This will help us determine
       // if IPv4 or IPv4/6 lookups are faster or slower.
-      switch(key_.address_family) {
+      switch (key_.address_family) {
         case ADDRESS_FAMILY_IPV4:
           DNS_HISTOGRAM("DNS.ResolveSuccess_FAMILY_IPV4", duration);
           break;
         case ADDRESS_FAMILY_IPV6:
           DNS_HISTOGRAM("DNS.ResolveSuccess_FAMILY_IPV6", duration);
           break;
         case ADDRESS_FAMILY_UNSPECIFIED:
           DNS_HISTOGRAM("DNS.ResolveSuccess_FAMILY_UNSPEC", duration);
           break;
       }
     } else {
       if (had_non_speculative_request_) {
         category = RESOLVE_FAIL;
         DNS_HISTOGRAM("DNS.ResolveFail", duration);
       } else {
         category = RESOLVE_SPECULATIVE_FAIL;
         DNS_HISTOGRAM("DNS.ResolveSpeculativeFail", duration);
       }
       // Log DNS lookups based on |address_family|. This will help us determine
       // if IPv4 or IPv4/6 lookups are faster or slower.
-      switch(key_.address_family) {
+      switch (key_.address_family) {
         case ADDRESS_FAMILY_IPV4:
           DNS_HISTOGRAM("DNS.ResolveFail_FAMILY_IPV4", duration);
           break;
         case ADDRESS_FAMILY_IPV6:
           DNS_HISTOGRAM("DNS.ResolveFail_FAMILY_IPV6", duration);
           break;
         case ADDRESS_FAMILY_UNSPECIFIED:
           DNS_HISTOGRAM("DNS.ResolveFail_FAMILY_UNSPEC", duration);
           break;
       }
@@ skipping 100 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ProcTask);
 };
 
 //-----------------------------------------------------------------------------
 
 // Wraps a call to HaveOnlyLoopbackAddresses to be executed on the WorkerPool as
 // it takes 40-100ms and should not block initialization.
 class HostResolverImpl::LoopbackProbeJob {
  public:
   explicit LoopbackProbeJob(const base::WeakPtr<HostResolverImpl>& resolver)
-      : resolver_(resolver),
-        result_(false) {
+      : resolver_(resolver), result_(false) {
     DCHECK(resolver.get());
     const bool kIsSlow = true;
     base::WorkerPool::PostTaskAndReply(
         FROM_HERE,
         base::Bind(&LoopbackProbeJob::DoProbe, base::Unretained(this)),
         base::Bind(&LoopbackProbeJob::OnProbeComplete, base::Owned(this)),
         kIsSlow);
   }
 
   virtual ~LoopbackProbeJob() {}
 
  private:
   // Runs on worker thread.
-  void DoProbe() {
-    result_ = HaveOnlyLoopbackAddresses();
-  }
+  void DoProbe() { result_ = HaveOnlyLoopbackAddresses(); }
 
   void OnProbeComplete() {
     if (!resolver_.get())
       return;
     resolver_->SetHaveOnlyLoopbackAddresses(result_);
   }
 
   // Used/set only on origin thread.
   base::WeakPtr<HostResolverImpl> resolver_;
 
@@ skipping 74 matching lines @@
     DCHECK(!transaction_aaaa_);
     DCHECK_NE(ADDRESS_FAMILY_IPV4, key_.address_family);
     transaction_aaaa_ = CreateTransaction(ADDRESS_FAMILY_IPV6);
     transaction_aaaa_->Start();
   }
 
   scoped_ptr<DnsTransaction> CreateTransaction(AddressFamily family) {
     DCHECK_NE(ADDRESS_FAMILY_UNSPECIFIED, family);
     return client_->GetTransactionFactory()->CreateTransaction(
         key_.hostname,
-        family == ADDRESS_FAMILY_IPV6 ? dns_protocol::kTypeAAAA :
-                                        dns_protocol::kTypeA,
-        base::Bind(&DnsTask::OnTransactionComplete, base::Unretained(this),
+        family == ADDRESS_FAMILY_IPV6 ? dns_protocol::kTypeAAAA
+                                      : dns_protocol::kTypeA,
+        base::Bind(&DnsTask::OnTransactionComplete,
+                   base::Unretained(this),
                    base::TimeTicks::Now()),
         net_log_);
   }
 
   void OnTransactionComplete(const base::TimeTicks& start_time,
                              DnsTransaction* transaction,
                              int net_error,
                              const DnsResponse* response) {
     DCHECK(transaction);
     base::TimeDelta duration = base::TimeTicks::Now() - start_time;
@@ skipping 56 matching lines @@
     }
 
     // If there are multiple addresses, and at least one is IPv6, need to sort
     // them.  Note that IPv6 addresses are always put before IPv4 ones, so it's
     // sufficient to just check the family of the first address.
     if (addr_list_.size() > 1 &&
         addr_list_[0].GetFamily() == ADDRESS_FAMILY_IPV6) {
       // Sort addresses if needed.  Sort could complete synchronously.
       client_->GetAddressSorter()->Sort(
           addr_list_,
-          base::Bind(&DnsTask::OnSortComplete,
-                     AsWeakPtr(),
-                     base::TimeTicks::Now()));
+          base::Bind(
+              &DnsTask::OnSortComplete, AsWeakPtr(), base::TimeTicks::Now()));
     } else {
       OnSuccess(addr_list_);
     }
   }
 
   void OnSortComplete(base::TimeTicks start_time,
                       bool success,
                       const AddressList& addr_list) {
     if (!success) {
       DNS_HISTOGRAM("AsyncDNS.SortFailure",
                     base::TimeTicks::Now() - start_time);
       OnFailure(ERR_DNS_SORT_ERROR, DnsResponse::DNS_PARSE_OK);
       return;
     }
 
-    DNS_HISTOGRAM("AsyncDNS.SortSuccess",
-                  base::TimeTicks::Now() - start_time);
+    DNS_HISTOGRAM("AsyncDNS.SortSuccess", base::TimeTicks::Now() - start_time);
 
     // AddressSorter prunes unusable destinations.
     if (addr_list.empty()) {
       LOG(WARNING) << "Address list empty after RFC3484 sort";
       OnFailure(ERR_NAME_NOT_RESOLVED, DnsResponse::DNS_PARSE_OK);
       return;
     }
 
     OnSuccess(addr_list);
   }
 
   void OnFailure(int net_error, DnsResponse::Result result) {
     DCHECK_NE(OK, net_error);
     net_log_.EndEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,
         base::Bind(&NetLogDnsTaskFailedCallback, net_error, result));
-    delegate_->OnDnsTaskComplete(task_start_time_, net_error, AddressList(),
-                                 base::TimeDelta());
+    delegate_->OnDnsTaskComplete(
+        task_start_time_, net_error, AddressList(), base::TimeDelta());
   }
 
   void OnSuccess(const AddressList& addr_list) {
     net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,
                       addr_list.CreateNetLogCallback());
     delegate_->OnDnsTaskComplete(task_start_time_, OK, addr_list, ttl_);
   }
 
   DnsClient* client_;
   Key key_;
@@ skipping 35 matching lines @@
         had_non_speculative_request_(false),
         had_dns_config_(false),
         num_occupied_job_slots_(0),
         dns_task_error_(OK),
         creation_time_(base::TimeTicks::Now()),
         priority_change_time_(creation_time_),
         net_log_(BoundNetLog::Make(request_net_log.net_log(),
                                    NetLog::SOURCE_HOST_RESOLVER_IMPL_JOB)) {
     request_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CREATE_JOB);
 
-    net_log_.BeginEvent(
-        NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
-        base::Bind(&NetLogJobCreationCallback,
-                   request_net_log.source(),
-                   &key_.hostname));
+    net_log_.BeginEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
+                        base::Bind(&NetLogJobCreationCallback,
+                                   request_net_log.source(),
+                                   &key_.hostname));
   }
 
   virtual ~Job() {
     if (is_running()) {
       // |resolver_| was destroyed with this Job still in flight.
       // Clean-up, record in the log, but don't run any callbacks.
       if (is_proc_running()) {
         proc_task_->Cancel();
         proc_task_ = NULL;
       }
       // Clean up now for nice NetLog.
       KillDnsTask();
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
                                         ERR_ABORTED);
     } else if (is_queued()) {
       // |resolver_| was destroyed without running this Job.
       // TODO(szym): is there any benefit in having this distinction?
       net_log_.AddEvent(NetLog::TYPE_CANCELLED);
       net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB);
     }
     // else CompleteRequests logged EndEvent.
 
     // Log any remaining Requests as cancelled.
     for (RequestsList::const_iterator it = requests_.begin();
-         it != requests_.end(); ++it) {
+         it != requests_.end();
+         ++it) {
       Request* req = *it;
       if (req->was_canceled())
         continue;
       DCHECK_EQ(this, req->job());
-      LogCancelRequest(req->source_net_log(), req->request_net_log(),
-                       req->info());
+      LogCancelRequest(
+          req->source_net_log(), req->request_net_log(), req->info());
     }
   }
 
   // Add this job to the dispatcher.  If "at_head" is true, adds at the front
   // of the queue.
   void Schedule(bool at_head) {
     DCHECK(!is_queued());
     PrioritizedDispatcher::Handle handle;
     if (!at_head) {
       handle = resolver_->dispatcher_.Add(this, priority());
@@ skipping 12 matching lines @@
   void AddRequest(scoped_ptr<Request> req) {
     DCHECK_EQ(key_.hostname, req->info().hostname());
 
     req->set_job(this);
     priority_tracker_.Add(req->priority());
 
     req->request_net_log().AddEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_ATTACH,
         net_log_.source().ToEventParametersCallback());
 
-    net_log_.AddEvent(
-        NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_ATTACH,
-        base::Bind(&NetLogJobAttachCallback,
-                   req->request_net_log().source(),
-                   priority()));
+    net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_ATTACH,
+                      base::Bind(&NetLogJobAttachCallback,
+                                 req->request_net_log().source(),
+                                 priority()));
 
     // TODO(szym): Check if this is still needed.
     if (!req->info().is_speculative()) {
       had_non_speculative_request_ = true;
       if (proc_task_.get())
         proc_task_->set_had_non_speculative_request();
     }
 
     requests_.push_back(req.release());
 
     UpdatePriority();
   }
 
   // Marks |req| as cancelled. If it was the last active Request, also finishes
   // this Job, marking it as cancelled, and deletes it.
   void CancelRequest(Request* req) {
     DCHECK_EQ(key_.hostname, req->info().hostname());
     DCHECK(!req->was_canceled());
 
     // Don't remove it from |requests_| just mark it canceled.
     req->MarkAsCanceled();
-    LogCancelRequest(req->source_net_log(), req->request_net_log(),
-                     req->info());
+    LogCancelRequest(
+        req->source_net_log(), req->request_net_log(), req->info());
 
     priority_tracker_.Remove(req->priority());
     net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_DETACH,
                       base::Bind(&NetLogJobAttachCallback,
                                  req->request_net_log().source(),
                                  priority()));
 
     if (num_active_requests() > 0) {
       UpdatePriority();
     } else {
@@ skipping 31 matching lines @@
 
     // This signals to CompleteRequests that this job never ran.
     CompleteRequestsWithError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
   }
 
   // Attempts to serve the job from HOSTS. Returns true if succeeded and
   // this Job was destroyed.
   bool ServeFromHosts() {
     DCHECK_GT(num_active_requests(), 0u);
     AddressList addr_list;
-    if (resolver_->ServeFromHosts(key(),
-                                  requests_.front()->info(),
-                                  &addr_list)) {
+    if (resolver_->ServeFromHosts(
+            key(), requests_.front()->info(), &addr_list)) {
       // This will destroy the Job.
       CompleteRequests(
           HostCache::Entry(OK, MakeAddressListForRequest(addr_list)),
           base::TimeDelta());
       return true;
     }
     return false;
   }
 
-  const Key key() const {
-    return key_;
-  }
+  const Key key() const { return key_; }
 
-  bool is_queued() const {
-    return !handle_.is_null();
-  }
+  bool is_queued() const { return !handle_.is_null(); }
 
-  bool is_running() const {
-    return is_dns_running() || is_proc_running();
-  }
+  bool is_running() const { return is_dns_running() || is_proc_running(); }
 
  private:
   void KillDnsTask() {
     if (dns_task_) {
       ReduceToOneJobSlot();
       dns_task_.reset();
     }
   }
 
   // Reduce the number of job slots occupied and queued in the dispatcher
@@ skipping 42 matching lines @@
 
     net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_STARTED);
 
     had_dns_config_ = resolver_->HaveDnsConfig();
 
     base::TimeTicks now = base::TimeTicks::Now();
     base::TimeDelta queue_time = now - creation_time_;
     base::TimeDelta queue_time_after_change = now - priority_change_time_;
 
     if (had_dns_config_) {
-      DNS_HISTOGRAM_BY_PRIORITY("AsyncDNS.JobQueueTime", priority(),
-                                queue_time);
-      DNS_HISTOGRAM_BY_PRIORITY("AsyncDNS.JobQueueTimeAfterChange", priority(),
+      DNS_HISTOGRAM_BY_PRIORITY(
+          "AsyncDNS.JobQueueTime", priority(), queue_time);
+      DNS_HISTOGRAM_BY_PRIORITY("AsyncDNS.JobQueueTimeAfterChange",
+                                priority(),
                                 queue_time_after_change);
     } else {
       DNS_HISTOGRAM_BY_PRIORITY("DNS.JobQueueTime", priority(), queue_time);
-      DNS_HISTOGRAM_BY_PRIORITY("DNS.JobQueueTimeAfterChange", priority(),
-                                queue_time_after_change);
+      DNS_HISTOGRAM_BY_PRIORITY(
+          "DNS.JobQueueTimeAfterChange", priority(), queue_time_after_change);
     }
 
     bool system_only =
         (key_.host_resolver_flags & HOST_RESOLVER_SYSTEM_ONLY) != 0;
 
     // Caution: Job::Start must not complete synchronously.
     if (!system_only && had_dns_config_ &&
         !ResemblesMulticastDNSName(key_.hostname)) {
       StartDnsTask();
     } else {
       StartProcTask();
     }
   }
 
   // TODO(szym): Since DnsTransaction does not consume threads, we can increase
   // the limits on |dispatcher_|. But in order to keep the number of WorkerPool
   // threads low, we will need to use an "inner" PrioritizedDispatcher with
   // tighter limits.
   void StartProcTask() {
     DCHECK(!is_dns_running());
-    proc_task_ = new ProcTask(
-        key_,
-        resolver_->proc_params_,
-        base::Bind(&Job::OnProcTaskComplete, base::Unretained(this),
-                   base::TimeTicks::Now()),
-        net_log_);
+    proc_task_ = new ProcTask(key_,
+                              resolver_->proc_params_,
+                              base::Bind(&Job::OnProcTaskComplete,
+                                         base::Unretained(this),
+                                         base::TimeTicks::Now()),
+                              net_log_);
 
     if (had_non_speculative_request_)
       proc_task_->set_had_non_speculative_request();
     // Start() could be called from within Resolve(), hence it must NOT directly
     // call OnProcTaskComplete, for example, on synchronous failure.
     proc_task_->Start();
   }
 
   // Called by ProcTask when it completes.
   void OnProcTaskComplete(base::TimeTicks start_time,
                           int net_error,
                           const AddressList& addr_list) {
     DCHECK(is_proc_running());
 
-    if (!resolver_->resolved_known_ipv6_hostname_ &&
-        net_error == OK &&
+    if (!resolver_->resolved_known_ipv6_hostname_ && net_error == OK &&
         key_.address_family == ADDRESS_FAMILY_UNSPECIFIED) {
       if (key_.hostname == "www.google.com") {
         resolver_->resolved_known_ipv6_hostname_ = true;
         bool got_ipv6_address = false;
         for (size_t i = 0; i < addr_list.size(); ++i) {
           if (addr_list[i].GetFamily() == ADDRESS_FAMILY_IPV6) {
             got_ipv6_address = true;
             break;
           }
         }
@@ skipping 21 matching lines @@
       }
     }
 
     base::TimeDelta ttl =
         base::TimeDelta::FromSeconds(kNegativeCacheEntryTTLSeconds);
     if (net_error == OK)
       ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
 
     // Don't store the |ttl| in cache since it's not obtained from the server.
     CompleteRequests(
-        HostCache::Entry(net_error, MakeAddressListForRequest(addr_list)),
-        ttl);
+        HostCache::Entry(net_error, MakeAddressListForRequest(addr_list)), ttl);
   }
 
   void StartDnsTask() {
     DCHECK(resolver_->HaveDnsConfig());
-    dns_task_.reset(new DnsTask(resolver_->dns_client_.get(), key_, this,
-                                net_log_));
+    dns_task_.reset(
+        new DnsTask(resolver_->dns_client_.get(), key_, this, net_log_));
 
     dns_task_->StartFirstTransaction();
     // Schedule a second transaction, if needed.
     if (dns_task_->needs_two_transactions())
       Schedule(true);
   }
 
   void StartSecondDnsTransaction() {
     DCHECK(dns_task_->needs_two_transactions());
     dns_task_->StartSecondTransaction();
@@ skipping 19 matching lines @@
     // ProcTask in that case is a waste of time.
     if (resolver_->fallback_to_proctask_) {
       KillDnsTask();
       StartProcTask();
     } else {
       UmaAsyncDnsResolveStatus(RESOLVE_STATUS_FAIL);
       CompleteRequestsWithError(net_error);
     }
   }
 
-
   // HostResolverImpl::DnsTask::Delegate implementation:
 
   virtual void OnDnsTaskComplete(base::TimeTicks start_time,
                                  int net_error,
                                  const AddressList& addr_list,
                                  base::TimeDelta ttl) OVERRIDE {
     DCHECK(is_dns_running());
 
     base::TimeDelta duration = base::TimeTicks::Now() - start_time;
     if (net_error != OK) {
       OnDnsTaskFailure(dns_task_->AsWeakPtr(), duration, net_error);
       return;
     }
     DNS_HISTOGRAM("AsyncDNS.ResolveSuccess", duration);
     // Log DNS lookups based on |address_family|.
-    switch(key_.address_family) {
+    switch (key_.address_family) {
       case ADDRESS_FAMILY_IPV4:
         DNS_HISTOGRAM("AsyncDNS.ResolveSuccess_FAMILY_IPV4", duration);
         break;
       case ADDRESS_FAMILY_IPV6:
         DNS_HISTOGRAM("AsyncDNS.ResolveSuccess_FAMILY_IPV6", duration);
         break;
       case ADDRESS_FAMILY_UNSPECIFIED:
         DNS_HISTOGRAM("AsyncDNS.ResolveSuccess_FAMILY_UNSPEC", duration);
         break;
     }
@@ skipping 18 matching lines @@
     ReduceToOneJobSlot();
 
     // We already have a job slot at the dispatcher, so if the second
     // transaction hasn't started, reuse it now instead of waiting in the queue
     // for the second slot.
     if (dns_task_->needs_another_transaction())
       dns_task_->StartSecondTransaction();
   }
 
   // Performs Job's last rites. Completes all Requests. Deletes this.
-  void CompleteRequests(const HostCache::Entry& entry,
-                        base::TimeDelta ttl) {
+  void CompleteRequests(const HostCache::Entry& entry, base::TimeDelta ttl) {
     CHECK(resolver_.get());
 
     // This job must be removed from resolver's |jobs_| now to make room for a
     // new job with the same key in case one of the OnComplete callbacks decides
     // to spawn one. Consequently, the job deletes itself when CompleteRequests
     // is done.
     scoped_ptr<Job> self_deleter(this);
 
     resolver_->RemoveJob(this);
 
@@ skipping 31 matching lines @@
                             resolver_->received_dns_config_);
     }
 
     bool did_complete = (entry.error != ERR_NETWORK_CHANGED) &&
                         (entry.error != ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
     if (did_complete)
       resolver_->CacheResult(key_, entry, ttl);
 
     // Complete all of the requests that were attached to the job.
     for (RequestsList::const_iterator it = requests_.begin();
-         it != requests_.end(); ++it) {
+         it != requests_.end();
+         ++it) {
       Request* req = *it;
 
       if (req->was_canceled())
         continue;
 
       DCHECK_EQ(this, req->job());
       // Update the net log and notify registered observers.
-      LogFinishRequest(req->source_net_log(), req->request_net_log(),
-                       req->info(), entry.error);
+      LogFinishRequest(req->source_net_log(),
+                       req->request_net_log(),
+                       req->info(),
+                       entry.error);
       if (did_complete) {
         // Record effective total time from creation to completion.
-        RecordTotalTime(had_dns_config_, req->info().is_speculative(),
+        RecordTotalTime(had_dns_config_,
+                        req->info().is_speculative(),
                         base::TimeTicks::Now() - req->request_time());
       }
       req->OnComplete(entry.error, entry.addrlist);
 
       // Check if the resolver was destroyed as a result of running the
       // callback. If it was, we could continue, but we choose to bail.
       if (!resolver_.get())
         return;
     }
   }
 
   // Convenience wrapper for CompleteRequests in case of failure.
   void CompleteRequestsWithError(int net_error) {
     CompleteRequests(HostCache::Entry(net_error, AddressList()),
                      base::TimeDelta());
   }
 
   RequestPriority priority() const {
     return priority_tracker_.highest_priority();
   }
 
   // Number of non-canceled requests in |requests_|.
-  size_t num_active_requests() const {
-    return priority_tracker_.total_count();
-  }
+  size_t num_active_requests() const { return priority_tracker_.total_count(); }
 
-  bool is_dns_running() const {
-    return dns_task_.get() != NULL;
-  }
+  bool is_dns_running() const { return dns_task_.get() != NULL; }
 
-  bool is_proc_running() const {
-    return proc_task_.get() != NULL;
-  }
+  bool is_proc_running() const { return proc_task_.get() != NULL; }
 
   base::WeakPtr<HostResolverImpl> resolver_;
 
   Key key_;
 
   // Tracks the highest priority across |requests_|.
   PriorityTracker priority_tracker_;
 
   bool had_non_speculative_request_;
 
@@ skipping 28 matching lines @@
 
 HostResolverImpl::ProcTaskParams::ProcTaskParams(
     HostResolverProc* resolver_proc,
     size_t max_retry_attempts)
     : resolver_proc(resolver_proc),
       max_retry_attempts(max_retry_attempts),
       unresponsive_delay(base::TimeDelta::FromMilliseconds(6000)),
       retry_factor(2) {
 }
 
-HostResolverImpl::ProcTaskParams::~ProcTaskParams() {}
+HostResolverImpl::ProcTaskParams::~ProcTaskParams() {
+}
 
 HostResolverImpl::HostResolverImpl(
     scoped_ptr<HostCache> cache,
     const PrioritizedDispatcher::Limits& job_limits,
     const ProcTaskParams& proc_params,
     NetLog* net_log)
     : cache_(cache.Pass()),
       dispatcher_(job_limits),
       max_queued_jobs_(job_limits.total_jobs * 100u),
       proc_params_(proc_params),
       net_log_(net_log),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       weak_ptr_factory_(this),
       probe_weak_ptr_factory_(this),
       received_dns_config_(false),
       num_dns_failures_(0),
       probe_ipv6_support_(true),
       use_local_ipv6_(false),
       resolved_known_ipv6_hostname_(false),
       additional_resolver_flags_(0),
       fallback_to_proctask_(true) {
-
   DCHECK_GE(dispatcher_.num_priorities(), static_cast<size_t>(NUM_PRIORITIES));
 
   // Maximum of 4 retry attempts for host resolution.
   static const size_t kDefaultMaxRetryAttempts = 4u;
 
   if (proc_params_.max_retry_attempts == HostResolver::kDefaultRetryAttempts)
     proc_params_.max_retry_attempts = kDefaultMaxRetryAttempts;
 
 #if defined(OS_WIN)
   EnsureWinsockInit();
@@ skipping 45 matching lines @@
   DCHECK(addresses);
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(false, callback.is_null());
 
   // Check that the caller supplied a valid hostname to resolve.
   std::string labeled_hostname;
   if (!DNSDomainFromDot(info.hostname(), &labeled_hostname))
     return ERR_NAME_NOT_RESOLVED;
 
   // Make a log item for the request.
-  BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
-      NetLog::SOURCE_HOST_RESOLVER_IMPL_REQUEST);
+  BoundNetLog request_net_log =
+      BoundNetLog::Make(net_log_, NetLog::SOURCE_HOST_RESOLVER_IMPL_REQUEST);
 
   LogStartRequest(source_net_log, request_net_log, info);
 
   // Build a key that identifies the request in the cache and in the
   // outstanding jobs map.
   Key key = GetEffectiveKeyForRequest(info, request_net_log);
 
   int rv = ResolveHelper(key, info, addresses, request_net_log);
   if (rv != ERR_DNS_CACHE_MISS) {
     LogFinishRequest(source_net_log, request_net_log, info, rv);
@@ skipping 64 matching lines @@
   return ERR_DNS_CACHE_MISS;
 }
 
 int HostResolverImpl::ResolveFromCache(const RequestInfo& info,
                                        AddressList* addresses,
                                        const BoundNetLog& source_net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(addresses);
 
   // Make a log item for the request.
-  BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
-      NetLog::SOURCE_HOST_RESOLVER_IMPL_REQUEST);
+  BoundNetLog request_net_log =
+      BoundNetLog::Make(net_log_, NetLog::SOURCE_HOST_RESOLVER_IMPL_REQUEST);
 
   // Update the net log and notify registered observers.
   LogStartRequest(source_net_log, request_net_log, info);
 
   Key key = GetEffectiveKeyForRequest(info, request_net_log);
 
   int rv = ResolveHelper(key, info, addresses, request_net_log);
   LogFinishRequest(source_net_log, request_net_log, info, rv);
   return rv;
 }
@@ skipping 50 matching lines @@
                                    const RequestInfo& info,
                                    int* net_error,
                                    AddressList* addresses) {
   DCHECK(addresses);
   DCHECK(net_error);
   IPAddressNumber ip_number;
   if (!ParseIPLiteralToNumber(key.hostname, &ip_number))
     return false;
 
   DCHECK_EQ(key.host_resolver_flags &
-      ~(HOST_RESOLVER_CANONNAME | HOST_RESOLVER_LOOPBACK_ONLY |
-        HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6),
-            0) << " Unhandled flag";
-  bool ipv6_disabled = (default_address_family_ == ADDRESS_FAMILY_IPV4) &&
-      !probe_ipv6_support_;
+                ~(HOST_RESOLVER_CANONNAME | HOST_RESOLVER_LOOPBACK_ONLY |
+                  HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6),
+            0)
+      << " Unhandled flag";
+  bool ipv6_disabled =
+      (default_address_family_ == ADDRESS_FAMILY_IPV4) && !probe_ipv6_support_;
   *net_error = OK;
   if ((ip_number.size() == kIPv6AddressSize) && ipv6_disabled) {
     *net_error = ERR_NAME_NOT_RESOLVED;
   } else {
     *addresses = AddressList::CreateFromIPAddress(ip_number, info.port());
     if (key.host_resolver_flags & HOST_RESOLVER_CANONNAME)
       addresses->SetDefaultCanonicalName();
   }
   return true;
 }
 
 bool HostResolverImpl::ServeFromCache(const Key& key,
                                       const RequestInfo& info,
                                       int* net_error,
                                       AddressList* addresses) {
   DCHECK(addresses);
   DCHECK(net_error);
   if (!info.allow_cached_response() || !cache_.get())
     return false;
 
-  const HostCache::Entry* cache_entry = cache_->Lookup(
-      key, base::TimeTicks::Now());
+  const HostCache::Entry* cache_entry =
+      cache_->Lookup(key, base::TimeTicks::Now());
   if (!cache_entry)
     return false;
 
   *net_error = cache_entry->error;
   if (*net_error == OK) {
     if (cache_entry->has_ttl())
       RecordTTL(cache_entry->ttl);
     *addresses = EnsurePortOnAddressList(cache_entry->addrlist, info.port());
   }
   return true;
@@ skipping 12 matching lines @@
 
   const DnsHosts& hosts = dns_client_->GetConfig()->hosts;
 
   // If |address_family| is ADDRESS_FAMILY_UNSPECIFIED other implementations
   // (glibc and c-ares) return the first matching line. We have more
   // flexibility, but lose implicit ordering.
   // We prefer IPv6 because "happy eyeballs" will fall back to IPv4 if
   // necessary.
   if (key.address_family == ADDRESS_FAMILY_IPV6 ||
       key.address_family == ADDRESS_FAMILY_UNSPECIFIED) {
-    DnsHosts::const_iterator it = hosts.find(
-        DnsHostsKey(hostname, ADDRESS_FAMILY_IPV6));
+    DnsHosts::const_iterator it =
+        hosts.find(DnsHostsKey(hostname, ADDRESS_FAMILY_IPV6));
     if (it != hosts.end())
       addresses->push_back(IPEndPoint(it->second, info.port()));
   }
 
   if (key.address_family == ADDRESS_FAMILY_IPV4 ||
       key.address_family == ADDRESS_FAMILY_UNSPECIFIED) {
-    DnsHosts::const_iterator it = hosts.find(
-        DnsHostsKey(hostname, ADDRESS_FAMILY_IPV4));
+    DnsHosts::const_iterator it =
+        hosts.find(DnsHostsKey(hostname, ADDRESS_FAMILY_IPV4));
     if (it != hosts.end())
       addresses->push_back(IPEndPoint(it->second, info.port()));
   }
 
   // If got only loopback addresses and the family was restricted, resolve
   // again, without restrictions. See SystemHostResolverCall for rationale.
   if ((key.host_resolver_flags &
-          HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6) &&
+       HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6) &&
       IsAllIPv4Loopback(*addresses)) {
     Key new_key(key);
     new_key.address_family = ADDRESS_FAMILY_UNSPECIFIED;
     new_key.host_resolver_flags &=
         ~HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
     return ServeFromHosts(new_key, info, addresses);
   }
   return !addresses->empty();
 }
 
@@ skipping 13 matching lines @@
 
 void HostResolverImpl::SetHaveOnlyLoopbackAddresses(bool result) {
   if (result) {
     additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
   } else {
     additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
   }
 }
 
 HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
-    const RequestInfo& info, const BoundNetLog& net_log) const {
+    const RequestInfo& info,
+    const BoundNetLog& net_log) const {
   HostResolverFlags effective_flags =
       info.host_resolver_flags() | additional_resolver_flags_;
   AddressFamily effective_address_family = info.address_family();
 
   if (info.address_family() == ADDRESS_FAMILY_UNSPECIFIED) {
     if (probe_ipv6_support_ && !use_local_ipv6_) {
       base::TimeTicks start_time = base::TimeTicks::Now();
       // Google DNS address.
-      const uint8 kIPv6Address[] =
-          { 0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88 };
+      const uint8 kIPv6Address[] = {0x20, 0x01, 0x48, 0x60, 0x48, 0x60,
+                                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                    0x00, 0x00, 0x88, 0x88};
       IPAddressNumber address(kIPv6Address,
                               kIPv6Address + arraysize(kIPv6Address));
       BoundNetLog probe_net_log = BoundNetLog::Make(
           net_log.net_log(), NetLog::SOURCE_IPV6_REACHABILITY_CHECK);
       probe_net_log.BeginEvent(NetLog::TYPE_IPV6_REACHABILITY_CHECK,
                                net_log.source().ToEventParametersCallback());
       bool rv6 = IsGloballyReachable(address, probe_net_log);
       probe_net_log.EndEvent(NetLog::TYPE_IPV6_REACHABILITY_CHECK);
       if (rv6)
         net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_IPV6_SUPPORTED);
 
       UMA_HISTOGRAM_TIMES("Net.IPv6ConnectDuration",
                           base::TimeTicks::Now() - start_time);
       if (rv6) {
-        UMA_HISTOGRAM_BOOLEAN("Net.IPv6ConnectSuccessMatch",
+        UMA_HISTOGRAM_BOOLEAN(
+            "Net.IPv6ConnectSuccessMatch",
             default_address_family_ == ADDRESS_FAMILY_UNSPECIFIED);
       } else {
-        UMA_HISTOGRAM_BOOLEAN("Net.IPv6ConnectFailureMatch",
+        UMA_HISTOGRAM_BOOLEAN(
+            "Net.IPv6ConnectFailureMatch",
             default_address_family_ != ADDRESS_FAMILY_UNSPECIFIED);
 
         effective_address_family = ADDRESS_FAMILY_IPV4;
         effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
       }
     } else {
       effective_address_family = default_address_family_;
     }
   }
 
   return Key(info.hostname(), effective_address_family, effective_flags);
 }
 
 void HostResolverImpl::AbortAllInProgressJobs() {
   // In Abort, a Request callback could spawn new Jobs with matching keys, so
   // first collect and remove all running jobs from |jobs_|.
   ScopedVector<Job> jobs_to_abort;
-  for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ) {
+  for (JobMap::iterator it = jobs_.begin(); it != jobs_.end();) {
     Job* job = it->second;
     if (job->is_running()) {
       jobs_to_abort.push_back(job);
       jobs_.erase(it++);
     } else {
       DCHECK(job->is_queued());
       ++it;
     }
   }
 
@@ skipping 60 matching lines @@
 #endif
   AbortAllInProgressJobs();
   // |this| may be deleted inside AbortAllInProgressJobs().
 }
 
 void HostResolverImpl::OnDNSChanged() {
   DnsConfig dns_config;
   NetworkChangeNotifier::GetDnsConfig(&dns_config);
 
   if (net_log_) {
-    net_log_->AddGlobalEntry(
-        NetLog::TYPE_DNS_CONFIG_CHANGED,
-        base::Bind(&NetLogDnsConfigCallback, &dns_config));
+    net_log_->AddGlobalEntry(NetLog::TYPE_DNS_CONFIG_CHANGED,
+                             base::Bind(&NetLogDnsConfigCallback, &dns_config));
   }
 
   // TODO(szym): Remove once http://crbug.com/137914 is resolved.
   received_dns_config_ = dns_config.IsValid();
   // Conservatively assume local IPv6 is needed when DnsConfig is not valid.
   use_local_ipv6_ = !dns_config.IsValid() || dns_config.use_local_ipv6;
 
   num_dns_failures_ = 0;
 
   // We want a new DnsSession in place, before we Abort running Jobs, so that
@@ skipping 67 matching lines @@
     dns_client_->SetConfig(dns_config);
     num_dns_failures_ = 0;
     if (dns_client_->GetConfig())
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
   }
 
   AbortDnsTasks();
 }
 
 }  // namespace net