Clang format slam.

net/dns/dns_config_service_posix.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_posix.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 33 matching lines @@
     FILE_PATH_LITERAL("/system/etc/hosts");
 #endif
 
 #if defined(OS_IOS)
 
 // There is no public API to watch the DNS configuration on iOS.
 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);
   }
 
   bool Watch(const base::Callback<void(bool succeeded)>& callback) {
     callback_ = callback;
     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);
   }
 
  private:
   base::Callback<void(bool succeeded)> callback_;
 };
 #elif !defined(OS_MACOSX)
 // DnsConfigWatcher for OS_MACOSX is in dns_config_watcher_mac.{hh,cc}.
 
 #ifndef _PATH_RESCONF  // Normally defined in <resolv.h>
 #define _PATH_RESCONF "/etc/resolv.conf"
 #endif
 
 static const base::FilePath::CharType* kFilePathConfig =
     FILE_PATH_LITERAL(_PATH_RESCONF);
 
 class DnsConfigWatcher {
  public:
   typedef base::Callback<void(bool succeeded)> CallbackType;
 
   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:
   void OnCallback(const base::FilePath& path, bool error) {
     callback_.Run(!error);
   }
 
   base::FilePathWatcher watcher_;
   CallbackType callback_;
 };
@@ skipping 13 matching lines @@
     result = CONFIG_PARSE_POSIX_RES_INIT_FAILED;
   }
 #else  // all other OS_POSIX
   struct __res_state res;
   memset(&res, 0, sizeof(res));
   if (res_ninit(&res) == 0) {
     result = ConvertResStateToDnsConfig(res, 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
   res_nclose(&res);
 #endif
 #endif
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   ConfigParsePosixResult error = DnsConfigWatcher::CheckDnsConfig();
   switch (error) {
@@ skipping 14 matching lines @@
 // Theoretically, this is bad. __system_property_get is not a supported API
 // (but it's currently visible to anyone using Bionic), and the properties
 // are implementation details that may disappear in future Android releases.
 // Practically, libcutils provides property_get, which is a public API, and the
 // DNS code (and its clients) are already robust against failing to get the DNS
 // config for whatever reason, so the properties can disappear and the world
 // won't end.
 // 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;
   __system_property_get("net.dns2", property_value);
   dns2_string = property_value;
   if (dns1_string.length() == 0 && dns2_string.length() == 0)
     return CONFIG_PARSE_POSIX_NO_NAMESERVERS;
 
   IPAddressNumber dns1_number, dns2_number;
   bool parsed1 = ParseIPLiteralToNumber(dns1_string, &dns1_number);
@@ skipping 12 matching lines @@
 
   return CONFIG_PARSE_POSIX_OK;
 }
 #endif
 
 }  // namespace
 
 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",
                                 DNS_CONFIG_WATCH_FAILED_TO_START_HOSTS,
                                 DNS_CONFIG_WATCH_MAX);
     }
     return success;
   }
 
  private:
@@ skipping 30 matching lines @@
   explicit ConfigReader(DnsConfigServicePosix* service)
       : service_(service), success_(false) {}
 
   virtual void DoWork() OVERRIDE {
     base::TimeTicks start_time = base::TimeTicks::Now();
     ConfigParsePosixResult result = ReadDnsConfig(&dns_config_);
     switch (result) {
       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;
       default:
         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);
   }
 
   virtual void OnWorkFinished() OVERRIDE {
     DCHECK(!IsCancelled());
     if (success_) {
       service_->OnConfigRead(dns_config_);
     } else {
       LOG(WARNING) << "Failed to read DnsConfig.";
     }
   }
 
  private:
   virtual ~ConfigReader() {}
 
   DnsConfigServicePosix* service_;
   // Written in DoWork, read in OnWorkFinished, no locking necessary.
   DnsConfig dns_config_;
   bool success_;
 
   DISALLOW_COPY_AND_ASSIGN(ConfigReader);
 };
 
 // A SerialWorker that reads the HOSTS file and runs Callback.
 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() {}
 
   virtual void DoWork() OVERRIDE {
     base::TimeTicks start_time = base::TimeTicks::Now();
     success_ = ParseHostsFile(path_, &hosts_);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HostParseResult", success_);
     UMA_HISTOGRAM_TIMES("AsyncDNS.HostsParseDuration",
                         base::TimeTicks::Now() - start_time);
@@ skipping 11 matching lines @@
   const base::FilePath path_;
   // Written in DoWork, read in OnWorkFinished, no locking necessary.
   DnsHosts hosts_;
   bool success_;
 
   DISALLOW_COPY_AND_ASSIGN(HostsReader);
 };
 
 DnsConfigServicePosix::DnsConfigServicePosix()
     : config_reader_(new ConfigReader(this)),
-      hosts_reader_(new HostsReader(this)) {}
+      hosts_reader_(new HostsReader(this)) {
+}
 
 DnsConfigServicePosix::~DnsConfigServicePosix() {
   config_reader_->Cancel();
   hosts_reader_->Cancel();
 }
 
 void DnsConfigServicePosix::ReadNow() {
   config_reader_->WorkNow();
   hosts_reader_->WorkNow();
 }
 
 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();
 }
 
 void DnsConfigServicePosix::OnConfigChanged(bool succeeded) {
   InvalidateConfig();
   if (succeeded) {
     config_reader_->WorkNow();
   } else {
     LOG(ERROR) << "DNS config watch failed.";
     set_watch_failed(true);
@@ skipping 34 matching lines @@
     IPEndPoint ipe;
     if (!ipe.FromSockAddr(
             reinterpret_cast<const struct sockaddr*>(&addresses[i]),
             sizeof addresses[i])) {
       return CONFIG_PARSE_POSIX_BAD_ADDRESS;
     }
     dns_config->nameservers.push_back(ipe);
   }
 #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|.
   // In res_send.c:res_nsend, it merges |nsaddr_list| into |nsaddrs|,
   // but we have to combine the two arrays ourselves.
   for (int i = 0; i < res.nscount; ++i) {
     IPEndPoint ipe;
     const struct sockaddr* addr = NULL;
     size_t addr_len = 0;
     if (res.nsaddr_list[i].sin_family) {  // The indicator used by res_nsend.
@@ skipping 64 matching lines @@
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace internal
 
 // static
 scoped_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return scoped_ptr<DnsConfigService>(new internal::DnsConfigServicePosix());
 }
 
 }  // namespace net