Clang format slam.

net/dns/dns_config_service_win.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_win.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 72 matching lines @@
       return true;
     }
     LONG result = key_.ReadValue(name, &out->value);
     if (result == ERROR_SUCCESS) {
       out->set = true;
       return true;
     }
     return (result == ERROR_FILE_NOT_FOUND);
   }
 
-  bool ReadDword(const wchar_t* name,
-                 DnsSystemSettings::RegDword* out) const {
+  bool ReadDword(const wchar_t* name, DnsSystemSettings::RegDword* out) const {
     DCHECK(CalledOnValidThread());
     out->set = false;
     if (!key_.Valid()) {
       // Assume that if the |key_| is invalid then the key is missing.
       return true;
     }
     LONG result = key_.ReadValueDW(name, &out->value);
     if (result == ERROR_SUCCESS) {
       out->set = true;
       return true;
@@ skipping 55 matching lines @@
 }
 
 bool ReadDevolutionSetting(const RegistryReader& reader,
                            DnsSystemSettings::DevolutionSetting* setting) {
   return reader.ReadDword(L"UseDomainNameDevolution", &setting->enabled) &&
          reader.ReadDword(L"DomainNameDevolutionLevel", &setting->level);
 }
 
 // Reads DnsSystemSettings from IpHelper and registry.
 ConfigParseWinResult ReadSystemSettings(DnsSystemSettings* settings) {
-  settings->addresses = ReadIpHelper(GAA_FLAG_SKIP_ANYCAST |
-                                     GAA_FLAG_SKIP_UNICAST |
-                                     GAA_FLAG_SKIP_MULTICAST |
-                                     GAA_FLAG_SKIP_FRIENDLY_NAME);
+  settings->addresses =
+      ReadIpHelper(GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_UNICAST |
+                   GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_FRIENDLY_NAME);
   if (!settings->addresses.get())
     return CONFIG_PARSE_WIN_READ_IPHELPER;
 
   RegistryReader tcpip_reader(kTcpipPath);
   RegistryReader tcpip6_reader(kTcpip6Path);
   RegistryReader dnscache_reader(kDnscachePath);
   RegistryReader policy_reader(kPolicyPath);
   RegistryReader primary_dns_suffix_reader(kPrimaryDnsSuffixPath);
 
-  if (!policy_reader.ReadString(L"SearchList",
-                                &settings->policy_search_list)) {
+  if (!policy_reader.ReadString(L"SearchList", &settings->policy_search_list)) {
     return CONFIG_PARSE_WIN_READ_POLICY_SEARCHLIST;
   }
 
   if (!tcpip_reader.ReadString(L"SearchList", &settings->tcpip_search_list))
     return CONFIG_PARSE_WIN_READ_TCPIP_SEARCHLIST;
 
   if (!tcpip_reader.ReadString(L"Domain", &settings->tcpip_domain))
     return CONFIG_PARSE_WIN_READ_DOMAIN;
 
   if (!ReadDevolutionSetting(policy_reader, &settings->policy_devolution))
@@ skipping 17 matching lines @@
 
   base::win::RegistryKeyIterator nrpt_rules(HKEY_LOCAL_MACHINE, kNRPTPath);
   settings->have_name_resolution_policy = (nrpt_rules.SubkeyCount() > 0);
 
   return CONFIG_PARSE_WIN_OK;
 }
 
 // Default address of "localhost" and local computer name can be overridden
 // by the HOSTS file, but if it's not there, then we need to fill it in.
 HostsParseWinResult AddLocalhostEntries(DnsHosts* hosts) {
-  const unsigned char kIPv4Localhost[] = { 127, 0, 0, 1 };
-  const unsigned char kIPv6Localhost[] = { 0, 0, 0, 0, 0, 0, 0, 0,
-                                           0, 0, 0, 0, 0, 0, 0, 1 };
+  const unsigned char kIPv4Localhost[] = {127, 0, 0, 1};
+  const unsigned char kIPv6Localhost[] = {0, 0, 0, 0, 0, 0, 0, 0,
+                                          0, 0, 0, 0, 0, 0, 0, 1};
   IPAddressNumber loopback_ipv4(kIPv4Localhost,
                                 kIPv4Localhost + arraysize(kIPv4Localhost));
   IPAddressNumber loopback_ipv6(kIPv6Localhost,
                                 kIPv6Localhost + arraysize(kIPv6Localhost));
 
   // This does not override any pre-existing entries from the HOSTS file.
   hosts->insert(std::make_pair(DnsHostsKey("localhost", ADDRESS_FAMILY_IPV4),
                                loopback_ipv4));
   hosts->insert(std::make_pair(DnsHostsKey("localhost", ADDRESS_FAMILY_IPV6),
                                loopback_ipv6));
 
   WCHAR buffer[MAX_PATH];
   DWORD size = MAX_PATH;
   std::string localname;
   if (!GetComputerNameExW(ComputerNameDnsHostname, buffer, &size) ||
       !ParseDomainASCII(buffer, &localname)) {
     return HOSTS_PARSE_WIN_COMPUTER_NAME_FAILED;
   }
   StringToLowerASCII(&localname);
 
   bool have_ipv4 =
       hosts->count(DnsHostsKey(localname, ADDRESS_FAMILY_IPV4)) > 0;
   bool have_ipv6 =
       hosts->count(DnsHostsKey(localname, ADDRESS_FAMILY_IPV6)) > 0;
 
   if (have_ipv4 && have_ipv6)
     return HOSTS_PARSE_WIN_OK;
 
   scoped_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> addresses =
-      ReadIpHelper(GAA_FLAG_SKIP_ANYCAST |
-                   GAA_FLAG_SKIP_DNS_SERVER |
-                   GAA_FLAG_SKIP_MULTICAST |
-                   GAA_FLAG_SKIP_FRIENDLY_NAME);
+      ReadIpHelper(GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_DNS_SERVER |
+                   GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_FRIENDLY_NAME);
   if (!addresses.get())
     return HOSTS_PARSE_WIN_IPHELPER_FAILED;
 
   // The order of adapters is the network binding order, so stick to the
   // first good adapter for each family.
   for (const IP_ADAPTER_ADDRESSES* adapter = addresses.get();
        adapter != NULL && (!have_ipv4 || !have_ipv6);
        adapter = adapter->Next) {
     if (adapter->OperStatus != IfOperStatusUp)
       continue;
@@ skipping 38 matching lines @@
     if (key_.StartWatching() != ERROR_SUCCESS)
       return false;
     if (!watcher_.StartWatching(key_.watch_event(), this))
       return false;
     return true;
   }
 
   virtual void OnObjectSignaled(HANDLE object) OVERRIDE {
     DCHECK(CalledOnValidThread());
     bool succeeded = (key_.StartWatching() == ERROR_SUCCESS) &&
-                      watcher_.StartWatching(key_.watch_event(), this);
+                     watcher_.StartWatching(key_.watch_event(), this);
     if (!succeeded && key_.Valid()) {
       watcher_.StopWatching();
       key_.StopWatching();
       key_.Close();
     }
     if (!callback_.is_null())
       callback_.Run(succeeded);
   }
 
  private:
   CallbackType callback_;
   base::win::RegKey key_;
   base::win::ObjectWatcher watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(RegistryWatcher);
 };
 
 // Returns true iff |address| is DNS address from IPv6 stateless discovery,
 // i.e., matches fec0:0:0:ffff::{1,2,3}.
 // http://tools.ietf.org/html/draft-ietf-ipngwg-dns-discovery
 bool IsStatelessDiscoveryAddress(const IPAddressNumber& address) {
   if (address.size() != kIPv6AddressSize)
     return false;
   const uint8 kPrefix[] = {
       0xfe, 0xc0, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   };
-  return std::equal(kPrefix, kPrefix + arraysize(kPrefix),
-                    address.begin()) && (address.back() < 4);
+  return std::equal(kPrefix, kPrefix + arraysize(kPrefix), address.begin()) &&
+         (address.back() < 4);
 }
 
 // Returns the path to the HOSTS file.
 base::FilePath GetHostsPath() {
   TCHAR buffer[MAX_PATH];
   UINT rc = GetSystemDirectory(buffer, MAX_PATH);
   DCHECK(0 < rc && rc < MAX_PATH);
-  return base::FilePath(buffer).Append(
-      FILE_PATH_LITERAL("drivers\\etc\\hosts"));
+  return base::FilePath(buffer)
+      .Append(FILE_PATH_LITERAL("drivers\\etc\\hosts"));
 }
 
 void ConfigureSuffixSearch(const DnsSystemSettings& settings,
                            DnsConfig* config) {
   // SearchList takes precedence, so check it first.
   if (settings.policy_search_list.set) {
     std::vector<std::string> search;
     if (ParseSearchList(settings.policy_search_list.value, &search)) {
       config->search.swap(search);
       return;
@@ skipping 57 matching lines @@
   // devolution setting.
   //
   // If the level is explicitly set below 2, devolution is disabled.
   if (!devolution.level.set || devolution.level.value < 2)
     return;  // Devolution disabled.
 
   // Devolve the primary suffix. This naive logic matches the observed
   // behavior (see also ParseSearchList). If a suffix is not valid, it will be
   // discarded when the fully-qualified name is converted to DNS format.
 
-  unsigned num_dots = std::count(primary_suffix.begin(),
-                                 primary_suffix.end(), '.');
+  unsigned num_dots =
+      std::count(primary_suffix.begin(), primary_suffix.end(), '.');
 
   for (size_t offset = 0; num_dots >= devolution.level.value; --num_dots) {
     offset = primary_suffix.find('.', offset + 1);
     config->search.push_back(primary_suffix.substr(offset + 1));
   }
 }
 
 }  // namespace
 
 bool ParseSearchList(const base::string16& value,
@@ skipping 96 matching lines @@
   ConfigureSuffixSearch(settings, config);
   return result;
 }
 
 // Watches registry and HOSTS file for changes. Must live on a thread which
 // allows IO.
 class DnsConfigServiceWin::Watcher
     : public NetworkChangeNotifier::IPAddressObserver {
  public:
   explicit Watcher(DnsConfigServiceWin* service) : service_(service) {}
-  ~Watcher() {
-    NetworkChangeNotifier::RemoveIPAddressObserver(this);
-  }
+  ~Watcher() { NetworkChangeNotifier::RemoveIPAddressObserver(this); }
 
   bool Watch() {
-    RegistryWatcher::CallbackType callback =
-        base::Bind(&DnsConfigServiceWin::OnConfigChanged,
-                   base::Unretained(service_));
+    RegistryWatcher::CallbackType callback = base::Bind(
+        &DnsConfigServiceWin::OnConfigChanged, base::Unretained(service_));
 
     bool success = true;
 
     // The Tcpip key must be present.
     if (!tcpip_watcher_.Watch(kTcpipPath, callback)) {
       LOG(ERROR) << "DNS registry watch failed to start.";
       success = false;
       UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus",
                                 DNS_CONFIG_WATCH_FAILED_TO_START_CONFIG,
                                 DNS_CONFIG_WATCH_MAX);
     }
 
     // Watch for IPv6 nameservers.
     tcpip6_watcher_.Watch(kTcpip6Path, callback);
 
     // DNS suffix search list and devolution can be configured via group
     // policy which sets this registry key. If the key is missing, the policy
     // does not apply, and the DNS client uses Tcpip and Dnscache settings.
     // If a policy is installed, DnsConfigService will need to be restarted.
     // BUG=99509
 
     dnscache_watcher_.Watch(kDnscachePath, callback);
     policy_watcher_.Watch(kPolicyPath, callback);
 
-    if (!hosts_watcher_.Watch(GetHostsPath(), false,
-                              base::Bind(&Watcher::OnHostsChanged,
-                                         base::Unretained(this)))) {
+    if (!hosts_watcher_.Watch(
+            GetHostsPath(),
+            false,
+            base::Bind(&Watcher::OnHostsChanged, base::Unretained(this)))) {
       UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus",
                                 DNS_CONFIG_WATCH_FAILED_TO_START_HOSTS,
                                 DNS_CONFIG_WATCH_MAX);
       LOG(ERROR) << "DNS hosts watch failed to start.";
       success = false;
     } else {
       // Also need to observe changes to local non-loopback IP for DnsHosts.
       NetworkChangeNotifier::AddIPAddressObserver(this);
     }
     return success;
@@ skipping 20 matching lines @@
   RegistryWatcher policy_watcher_;
   base::FilePathWatcher hosts_watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(Watcher);
 };
 
 // Reads config from registry and IpHelper. All work performed on WorkerPool.
 class DnsConfigServiceWin::ConfigReader : public SerialWorker {
  public:
   explicit ConfigReader(DnsConfigServiceWin* service)
-      : service_(service),
-        success_(false) {}
+      : service_(service), success_(false) {}
 
  private:
   virtual ~ConfigReader() {}
 
   virtual void DoWork() OVERRIDE {
     // Should be called on WorkerPool.
     base::TimeTicks start_time = base::TimeTicks::Now();
     DnsSystemSettings settings = {};
     ConfigParseWinResult result = ReadSystemSettings(&settings);
     if (result == CONFIG_PARSE_WIN_OK)
       result = ConvertSettingsToDnsConfig(settings, &dns_config_);
     success_ = (result == CONFIG_PARSE_WIN_OK ||
                 result == CONFIG_PARSE_WIN_UNHANDLED_OPTIONS);
-    UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ConfigParseWin",
-                              result, CONFIG_PARSE_WIN_MAX);
+    UMA_HISTOGRAM_ENUMERATION(
+        "AsyncDNS.ConfigParseWin", result, CONFIG_PARSE_WIN_MAX);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.ConfigParseResult", success_);
     UMA_HISTOGRAM_TIMES("AsyncDNS.ConfigParseDuration",
                         base::TimeTicks::Now() - start_time);
   }
 
   virtual void OnWorkFinished() OVERRIDE {
     DCHECK(loop()->BelongsToCurrentThread());
     DCHECK(!IsCancelled());
     if (success_) {
       service_->OnConfigRead(dns_config_);
@@ skipping 11 matching lines @@
   // Written in DoWork(), read in OnWorkFinished(). No locking required.
   DnsConfig dns_config_;
   bool success_;
 };
 
 // Reads hosts from HOSTS file and fills in localhost and local computer name if
 // necessary. All work performed on WorkerPool.
 class DnsConfigServiceWin::HostsReader : public SerialWorker {
  public:
   explicit HostsReader(DnsConfigServiceWin* service)
-      : path_(GetHostsPath()),
-        service_(service),
-        success_(false) {
-  }
+      : path_(GetHostsPath()), service_(service), success_(false) {}
 
  private:
   virtual ~HostsReader() {}
 
   virtual void DoWork() OVERRIDE {
     base::TimeTicks start_time = base::TimeTicks::Now();
     HostsParseWinResult result = HOSTS_PARSE_WIN_UNREADABLE_HOSTS_FILE;
     if (ParseHostsFile(path_, &hosts_))
       result = AddLocalhostEntries(&hosts_);
     success_ = (result == HOSTS_PARSE_WIN_OK);
-    UMA_HISTOGRAM_ENUMERATION("AsyncDNS.HostsParseWin",
-                              result, HOSTS_PARSE_WIN_MAX);
+    UMA_HISTOGRAM_ENUMERATION(
+        "AsyncDNS.HostsParseWin", result, HOSTS_PARSE_WIN_MAX);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HostParseResult", success_);
     UMA_HISTOGRAM_TIMES("AsyncDNS.HostsParseDuration",
                         base::TimeTicks::Now() - start_time);
   }
 
   virtual void OnWorkFinished() OVERRIDE {
     DCHECK(loop()->BelongsToCurrentThread());
     if (success_) {
       service_->OnHostsRead(hosts_);
     } else {
       LOG(WARNING) << "Failed to read DnsHosts.";
     }
   }
 
   const base::FilePath path_;
   DnsConfigServiceWin* service_;
   // Written in DoWork, read in OnWorkFinished, no locking necessary.
   DnsHosts hosts_;
   bool success_;
 
   DISALLOW_COPY_AND_ASSIGN(HostsReader);
 };
 
 DnsConfigServiceWin::DnsConfigServiceWin()
     : config_reader_(new ConfigReader(this)),
-      hosts_reader_(new HostsReader(this)) {}
+      hosts_reader_(new HostsReader(this)) {
+}
 
 DnsConfigServiceWin::~DnsConfigServiceWin() {
   config_reader_->Cancel();
   hosts_reader_->Cancel();
 }
 
 void DnsConfigServiceWin::ReadNow() {
   config_reader_->WorkNow();
   hosts_reader_->WorkNow();
 }
 
 bool DnsConfigServiceWin::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 DnsConfigServiceWin::OnConfigChanged(bool succeeded) {
   InvalidateConfig();
   if (succeeded) {
     config_reader_->WorkNow();
   } else {
     LOG(ERROR) << "DNS config watch failed.";
     set_watch_failed(true);
@@ skipping 17 matching lines @@
 }
 
 }  // namespace internal
 
 // static
 scoped_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return scoped_ptr<DnsConfigService>(new internal::DnsConfigServiceWin());
 }
 
 }  // namespace net