Clang format slam.

net/dns/dns_config_service.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_config_service.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/ip_pattern.h"
 
 namespace net {
 
 NameServerClassifier::NameServerClassifier() {
   // Google Public DNS addresses from:
   // https://developers.google.com/speed/public-dns/docs/using
   AddRule("8.8.8.8", NAME_SERVERS_TYPE_GOOGLE_PUBLIC_DNS);
   AddRule("8.8.4.4", NAME_SERVERS_TYPE_GOOGLE_PUBLIC_DNS);
   AddRule("2001:4860:4860:0:0:0:0:8888", NAME_SERVERS_TYPE_GOOGLE_PUBLIC_DNS),
-  AddRule("2001:4860:4860:0:0:0:0:8844", NAME_SERVERS_TYPE_GOOGLE_PUBLIC_DNS),
+      AddRule("2001:4860:4860:0:0:0:0:8844",
+              NAME_SERVERS_TYPE_GOOGLE_PUBLIC_DNS),
 
-  // Count localhost as private, since we don't know what upstream it uses:
-  AddRule("127.*.*.*", NAME_SERVERS_TYPE_PRIVATE);
+      // Count localhost as private, since we don't know what upstream it uses:
+      AddRule("127.*.*.*", NAME_SERVERS_TYPE_PRIVATE);
   AddRule("0:0:0:0:0:0:0:1", NAME_SERVERS_TYPE_PRIVATE);
 
   // RFC 1918 private addresses:
   AddRule("10.*.*.*", NAME_SERVERS_TYPE_PRIVATE);
   AddRule("172.[16-31].*.*", NAME_SERVERS_TYPE_PRIVATE);
   AddRule("192.168.*.*", NAME_SERVERS_TYPE_PRIVATE);
 
   // IPv4 link-local addresses:
   AddRule("169.254.*.*", NAME_SERVERS_TYPE_PRIVATE);
 
   // IPv6 link-local addresses:
   AddRule("fe80:*:*:*:*:*:*:*", NAME_SERVERS_TYPE_PRIVATE);
 
   // Anything else counts as public:
   AddRule("*.*.*.*", NAME_SERVERS_TYPE_PUBLIC);
   AddRule("*:*:*:*:*:*:*:*", NAME_SERVERS_TYPE_PUBLIC);
 }
 
-NameServerClassifier::~NameServerClassifier() {}
+NameServerClassifier::~NameServerClassifier() {
+}
 
 NameServerClassifier::NameServersType NameServerClassifier::GetNameServersType(
     const std::vector<IPEndPoint>& nameservers) const {
   NameServersType type = NAME_SERVERS_TYPE_NONE;
   for (std::vector<IPEndPoint>::const_iterator it = nameservers.begin();
        it != nameservers.end();
        ++it) {
     type = MergeNameServersTypes(type, GetNameServerType(it->address()));
   }
   return type;
@@ skipping 43 matching lines @@
 // |kDnsTimeoutSeconds|.
 DnsConfig::DnsConfig()
     : unhandled_options(false),
       append_to_multi_label_name(true),
       randomize_ports(false),
       ndots(1),
       timeout(base::TimeDelta::FromSeconds(kDnsTimeoutSeconds)),
       attempts(2),
       rotate(false),
       edns0(false),
-      use_local_ipv6(false) {}
+      use_local_ipv6(false) {
+}
 
-DnsConfig::~DnsConfig() {}
+DnsConfig::~DnsConfig() {
+}
 
 bool DnsConfig::Equals(const DnsConfig& d) const {
   return EqualsIgnoreHosts(d) && (hosts == d.hosts);
 }
 
 bool DnsConfig::EqualsIgnoreHosts(const DnsConfig& d) const {
-  return (nameservers == d.nameservers) &&
-         (search == d.search) &&
+  return (nameservers == d.nameservers) && (search == d.search) &&
          (unhandled_options == d.unhandled_options) &&
          (append_to_multi_label_name == d.append_to_multi_label_name) &&
-         (ndots == d.ndots) &&
-         (timeout == d.timeout) &&
-         (attempts == d.attempts) &&
-         (rotate == d.rotate) &&
-         (edns0 == d.edns0) &&
-         (use_local_ipv6 == d.use_local_ipv6);
+         (ndots == d.ndots) && (timeout == d.timeout) &&
+         (attempts == d.attempts) && (rotate == d.rotate) &&
+         (edns0 == d.edns0) && (use_local_ipv6 == d.use_local_ipv6);
 }
 
 void DnsConfig::CopyIgnoreHosts(const DnsConfig& d) {
   nameservers = d.nameservers;
   search = d.search;
   unhandled_options = d.unhandled_options;
   append_to_multi_label_name = d.append_to_multi_label_name;
   ndots = d.ndots;
   timeout = d.timeout;
   attempts = d.attempts;
@@ skipping 21 matching lines @@
   dict->SetDouble("timeout", timeout.InSecondsF());
   dict->SetInteger("attempts", attempts);
   dict->SetBoolean("rotate", rotate);
   dict->SetBoolean("edns0", edns0);
   dict->SetBoolean("use_local_ipv6", use_local_ipv6);
   dict->SetInteger("num_hosts", hosts.size());
 
   return dict;
 }
 
-
 DnsConfigService::DnsConfigService()
     : watch_failed_(false),
       have_config_(false),
       have_hosts_(false),
       need_update_(false),
-      last_sent_empty_(true) {}
+      last_sent_empty_(true) {
+}
 
 DnsConfigService::~DnsConfigService() {
 }
 
 void DnsConfigService::ReadConfig(const CallbackType& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
   DCHECK(callback_.is_null());
   callback_ = callback;
   ReadNow();
@@ skipping 93 matching lines @@
   // the config from the receiver. The goal is to avoid perceivable network
   // outage (when using the wrong config) but at the same time avoid
   // unnecessary Job aborts in HostResolverImpl. The signals come from multiple
   // sources so it might receive multiple events during a config change.
 
   // DHCP and user-induced changes are on the order of seconds, so 150ms should
   // not add perceivable delay. On the other hand, config readers should finish
   // within 150ms with the rare exception of I/O block or extra large HOSTS.
   const base::TimeDelta kTimeout = base::TimeDelta::FromMilliseconds(150);
 
-  timer_.Start(FROM_HERE,
-               kTimeout,
-               this,
-               &DnsConfigService::OnTimeout);
+  timer_.Start(FROM_HERE, kTimeout, this, &DnsConfigService::OnTimeout);
 }
 
 void DnsConfigService::OnTimeout() {
   DCHECK(CalledOnValidThread());
   DCHECK(!last_sent_empty_);
   // Indicate that even if there is no change in On*Read, we will need to
   // update the receiver when the config becomes complete.
   need_update_ = true;
   // Empty config is considered invalid.
   last_sent_empty_ = true;
   last_sent_empty_time_ = base::TimeTicks::Now();
   callback_.Run(DnsConfig());
 }
 
 void DnsConfigService::OnCompleteConfig() {
   timer_.Stop();
   if (!need_update_)
     return;
   need_update_ = false;
   last_sent_empty_ = false;
   if (watch_failed_) {
     // If a watch failed, the config may not be accurate, so report empty.
     callback_.Run(DnsConfig());
   } else {
     callback_.Run(dns_config_);
   }
 }
 
 }  // namespace net
-