Clang format slam.

net/dns/dns_config_service_posix.cc

Index: net/dns/dns_config_service_posix.cc
diff --git a/net/dns/dns_config_service_posix.cc b/net/dns/dns_config_service_posix.cc
index 0644d4d42947142a935786337a291fbd7e0c3d90..d837dd97bb5ba8a76d36c6ba7f53170e58efcbbb 100644
--- a/net/dns/dns_config_service_posix.cc
+++ b/net/dns/dns_config_service_posix.cc
@@ -51,18 +51,14 @@ class DnsConfigWatcher {
  public:
   typedef base::Callback<void(bool succeeded)> CallbackType;
 
-  bool Watch(const CallbackType& callback) {
-    return false;
-  }
+  bool Watch(const CallbackType& callback) { return false; }
 };
 
 #elif defined(OS_ANDROID)
 // On Android, assume DNS config may have changed on every network change.
 class DnsConfigWatcher : public NetworkChangeNotifier::NetworkChangeObserver {
  public:
-  DnsConfigWatcher() {
-    NetworkChangeNotifier::AddNetworkChangeObserver(this);
-  }
+  DnsConfigWatcher() { NetworkChangeNotifier::AddNetworkChangeObserver(this); }
 
   virtual ~DnsConfigWatcher() {
     NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
@@ -73,8 +69,8 @@ class DnsConfigWatcher : public NetworkChangeNotifier::NetworkChangeObserver {
     return true;
   }
 
-  virtual void OnNetworkChanged(NetworkChangeNotifier::ConnectionType type)
-      OVERRIDE {
+  virtual void OnNetworkChanged(
+      NetworkChangeNotifier::ConnectionType type) OVERRIDE {
     if (!callback_.is_null() && type != NetworkChangeNotifier::CONNECTION_NONE)
       callback_.Run(true);
   }
@@ -98,9 +94,10 @@ class DnsConfigWatcher {
 
   bool Watch(const CallbackType& callback) {
     callback_ = callback;
-    return watcher_.Watch(base::FilePath(kFilePathConfig), false,
-                          base::Bind(&DnsConfigWatcher::OnCallback,
-                                     base::Unretained(this)));
+    return watcher_.Watch(
+        base::FilePath(kFilePathConfig),
+        false,
+        base::Bind(&DnsConfigWatcher::OnCallback, base::Unretained(this)));
   }
 
  private:
@@ -134,7 +131,7 @@ ConfigParsePosixResult ReadDnsConfig(DnsConfig* config) {
   } else {
     result = CONFIG_PARSE_POSIX_RES_INIT_FAILED;
   }
-  // Prefer res_ndestroy where available.
+// Prefer res_ndestroy where available.
 #if defined(OS_MACOSX) || defined(OS_FREEBSD)
   res_ndestroy(&res);
 #else
@@ -169,7 +166,7 @@ ConfigParsePosixResult ReadDnsConfig(DnsConfig* config) {
 // TODO(ttuttle): Depend on libcutils, then switch this (and other uses of
 //                __system_property_get) to property_get.
 ConfigParsePosixResult ReadDnsConfig(DnsConfig* dns_config) {
-   std::string dns1_string, dns2_string;
+  std::string dns1_string, dns2_string;
   char property_value[PROP_VALUE_MAX];
   __system_property_get("net.dns1", property_value);
   dns1_string = property_value;
@@ -202,23 +199,23 @@ ConfigParsePosixResult ReadDnsConfig(DnsConfig* dns_config) {
 class DnsConfigServicePosix::Watcher {
  public:
   explicit Watcher(DnsConfigServicePosix* service)
-      : weak_factory_(this),
-        service_(service) {}
+      : weak_factory_(this), service_(service) {}
   ~Watcher() {}
 
   bool Watch() {
     bool success = true;
-    if (!config_watcher_.Watch(base::Bind(&Watcher::OnConfigChanged,
-                                          base::Unretained(this)))) {
+    if (!config_watcher_.Watch(
+            base::Bind(&Watcher::OnConfigChanged, base::Unretained(this)))) {
       LOG(ERROR) << "DNS config watch failed to start.";
       success = false;
       UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus",
                                 DNS_CONFIG_WATCH_FAILED_TO_START_CONFIG,
                                 DNS_CONFIG_WATCH_MAX);
     }
-    if (!hosts_watcher_.Watch(base::FilePath(kFilePathHosts), false,
-                              base::Bind(&Watcher::OnHostsChanged,
-                                         base::Unretained(this)))) {
+    if (!hosts_watcher_.Watch(
+            base::FilePath(kFilePathHosts),
+            false,
+            base::Bind(&Watcher::OnHostsChanged, base::Unretained(this)))) {
       LOG(ERROR) << "DNS hosts watch failed to start.";
       success = false;
       UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus",
@@ -269,7 +266,7 @@ class DnsConfigServicePosix::ConfigReader : public SerialWorker {
       case CONFIG_PARSE_POSIX_MISSING_OPTIONS:
       case CONFIG_PARSE_POSIX_UNHANDLED_OPTIONS:
         DCHECK(dns_config_.unhandled_options);
-        // Fall through.
+      // Fall through.
       case CONFIG_PARSE_POSIX_OK:
         success_ = true;
         break;
@@ -277,8 +274,8 @@ class DnsConfigServicePosix::ConfigReader : public SerialWorker {
         success_ = false;
         break;
     }
-    UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ConfigParsePosix",
-                              result, CONFIG_PARSE_POSIX_MAX);
+    UMA_HISTOGRAM_ENUMERATION(
+        "AsyncDNS.ConfigParsePosix", result, CONFIG_PARSE_POSIX_MAX);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.ConfigParseResult", success_);
     UMA_HISTOGRAM_TIMES("AsyncDNS.ConfigParseDuration",
                         base::TimeTicks::Now() - start_time);
@@ -308,7 +305,7 @@ class DnsConfigServicePosix::ConfigReader : public SerialWorker {
 class DnsConfigServicePosix::HostsReader : public SerialWorker {
  public:
   explicit HostsReader(DnsConfigServicePosix* service)
-      :  service_(service), path_(kFilePathHosts), success_(false) {}
+      : service_(service), path_(kFilePathHosts), success_(false) {}
 
  private:
   virtual ~HostsReader() {}
@@ -340,7 +337,8 @@ class DnsConfigServicePosix::HostsReader : public SerialWorker {
 
 DnsConfigServicePosix::DnsConfigServicePosix()
     : config_reader_(new ConfigReader(this)),
-      hosts_reader_(new HostsReader(this)) {}
+      hosts_reader_(new HostsReader(this)) {
+}
 
 DnsConfigServicePosix::~DnsConfigServicePosix() {
   config_reader_->Cancel();
@@ -355,8 +353,8 @@ void DnsConfigServicePosix::ReadNow() {
 bool DnsConfigServicePosix::StartWatching() {
   // TODO(szym): re-start watcher if that makes sense. http://crbug.com/116139
   watcher_.reset(new Watcher(this));
-  UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus", DNS_CONFIG_WATCH_STARTED,
-                            DNS_CONFIG_WATCH_MAX);
+  UMA_HISTOGRAM_ENUMERATION(
+      "AsyncDNS.WatchStatus", DNS_CONFIG_WATCH_STARTED, DNS_CONFIG_WATCH_MAX);
   return watcher_->Watch();
 }
 
@@ -411,7 +409,7 @@ ConfigParsePosixResult ConvertResStateToDnsConfig(const struct __res_state& res,
   }
 #elif defined(OS_LINUX)
   COMPILE_ASSERT(arraysize(res.nsaddr_list) >= MAXNS &&
-                 arraysize(res._u._ext.nsaddrs) >= MAXNS,
+                     arraysize(res._u._ext.nsaddrs) >= MAXNS,
                  incompatible_libresolv_res_state);
   DCHECK_LE(res.nscount, MAXNS);
   // Initially, glibc stores IPv6 in |_ext.nsaddrs| and IPv4 in |nsaddr_list|.