Clang format slam.

net/base/network_change_notifier_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/base/network_change_notifier_win.h"
 
 #include <iphlpapi.h>
 #include <winsock2.h>
 
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 const int kWatchForAddressChangeRetryIntervalMs = 500;
 
 }  // namespace
 
 // Thread on which we can run DnsConfigService, which requires AssertIOAllowed
 // to open registry keys and to handle FilePathWatcher updates.
 class NetworkChangeNotifierWin::DnsConfigServiceThread : public base::Thread {
  public:
   DnsConfigServiceThread() : base::Thread("DnsConfigService") {}
 
-  virtual ~DnsConfigServiceThread() {
-    Stop();
-  }
+  virtual ~DnsConfigServiceThread() { Stop(); }
 
   virtual void Init() OVERRIDE {
     service_ = DnsConfigService::CreateSystemService();
     service_->WatchConfig(base::Bind(&NetworkChangeNotifier::SetDnsConfig));
   }
 
-  virtual void CleanUp() OVERRIDE {
-    service_.reset();
-  }
+  virtual void CleanUp() OVERRIDE { service_.reset(); }
 
  private:
   scoped_ptr<DnsConfigService> service_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsConfigServiceThread);
 };
 
 NetworkChangeNotifierWin::NetworkChangeNotifierWin()
     : NetworkChangeNotifier(NetworkChangeCalculatorParamsWin()),
       is_watching_(false),
       sequential_failures_(0),
       weak_factory_(this),
       dns_config_service_thread_(new DnsConfigServiceThread()),
       last_computed_connection_type_(RecomputeCurrentConnectionType()),
-      last_announced_offline_(
-          last_computed_connection_type_ == CONNECTION_NONE) {
+      last_announced_offline_(last_computed_connection_type_ ==
+                              CONNECTION_NONE) {
   memset(&addr_overlapped_, 0, sizeof addr_overlapped_);
   addr_overlapped_.hEvent = WSACreateEvent();
 }
 
 NetworkChangeNotifierWin::~NetworkChangeNotifierWin() {
   if (is_watching_) {
     CancelIPChangeNotify(&addr_overlapped_);
     addr_watcher_.StopWatching();
   }
   WSACloseEvent(addr_overlapped_.hEvent);
@@ skipping 72 matching lines @@
   // The main difference is we only call WSALookupServiceNext once, whereas
   // the earlier code would traverse the entire list and pass LUP_FLUSHPREVIOUS
   // to skip past the large results.
 
   HANDLE ws_handle;
   WSAQUERYSET query_set = {0};
   query_set.dwSize = sizeof(WSAQUERYSET);
   query_set.dwNameSpace = NS_NLA;
   // Initiate a client query to iterate through the
   // currently connected networks.
-  if (0 != WSALookupServiceBegin(&query_set, LUP_RETURN_ALL,
-                                 &ws_handle)) {
+  if (0 != WSALookupServiceBegin(&query_set, LUP_RETURN_ALL, &ws_handle)) {
     LOG(ERROR) << "WSALookupServiceBegin failed with: " << WSAGetLastError();
     return NetworkChangeNotifier::CONNECTION_UNKNOWN;
   }
 
   bool found_connection = false;
 
   // Retrieve the first available network. In this function, we only
   // need to know whether or not there is network connection.
   // Allocate 256 bytes for name, it should be enough for most cases.
   // If the name is longer, it is OK as we will check the code returned and
   // set correct network status.
   char result_buffer[sizeof(WSAQUERYSET) + 256] = {0};
   DWORD length = sizeof(result_buffer);
   reinterpret_cast<WSAQUERYSET*>(&result_buffer[0])->dwSize =
       sizeof(WSAQUERYSET);
-  int result = WSALookupServiceNext(
-      ws_handle,
-      LUP_RETURN_NAME,
-      &length,
-      reinterpret_cast<WSAQUERYSET*>(&result_buffer[0]));
+  int result =
+      WSALookupServiceNext(ws_handle,
+                           LUP_RETURN_NAME,
+                           &length,
+                           reinterpret_cast<WSAQUERYSET*>(&result_buffer[0]));
 
   if (result == 0) {
     // Found a connection!
     found_connection = true;
   } else {
     DCHECK_EQ(SOCKET_ERROR, result);
     result = WSAGetLastError();
 
     // Error code WSAEFAULT means there is a network connection but the
     // result_buffer size is too small to contain the results. The
     // variable "length" returned from WSALookupServiceNext is the minimum
     // number of bytes required. We do not need to retrieve detail info,
     // it is enough knowing there was a connection.
     if (result == WSAEFAULT) {
       found_connection = true;
     } else if (result == WSA_E_NO_MORE || result == WSAENOMORE) {
       // There was nothing to iterate over!
     } else {
       LOG(WARNING) << "WSALookupServiceNext() failed with:" << result;
     }
   }
 
   result = WSALookupServiceEnd(ws_handle);
-  LOG_IF(ERROR, result != 0)
-      << "WSALookupServiceEnd() failed with: " << result;
+  LOG_IF(ERROR, result != 0) << "WSALookupServiceEnd() failed with: " << result;
 
   // TODO(droger): Return something more detailed than CONNECTION_UNKNOWN.
-  return found_connection ? NetworkChangeNotifier::CONNECTION_UNKNOWN :
-                            NetworkChangeNotifier::CONNECTION_NONE;
+  return found_connection ? NetworkChangeNotifier::CONNECTION_UNKNOWN
+                          : NetworkChangeNotifier::CONNECTION_NONE;
 }
 
 NetworkChangeNotifier::ConnectionType
 NetworkChangeNotifierWin::GetCurrentConnectionType() const {
   base::AutoLock auto_lock(last_computed_connection_type_lock_);
   return last_computed_connection_type_;
 }
 
 void NetworkChangeNotifierWin::SetCurrentConnectionType(
     ConnectionType connection_type) {
@@ skipping 18 matching lines @@
   NotifyObserversOfIPAddressChange();
 
   // Calling GetConnectionType() at this very moment is likely to give
   // the wrong result, so we delay that until a little bit later.
   //
   // The one second delay chosen here was determined experimentally
   // by adamk on Windows 7.
   // If after one second we determine we are still offline, we will
   // delay again.
   offline_polls_ = 0;
-  timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
+  timer_.Start(FROM_HERE,
+               base::TimeDelta::FromSeconds(1),
+               this,
                &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange);
 }
 
 void NetworkChangeNotifierWin::WatchForAddressChange() {
   DCHECK(CalledOnValidThread());
   DCHECK(!is_watching_);
 
   // NotifyAddrChange occasionally fails with ERROR_OPEN_FAILED for unknown
   // reasons.  More rarely, it's also been observed failing with
   // ERROR_NO_SYSTEM_RESOURCES.  When either of these happens, we retry later.
@@ skipping 30 matching lines @@
 
   is_watching_ = true;
   sequential_failures_ = 0;
 }
 
 bool NetworkChangeNotifierWin::WatchForAddressChangeInternal() {
   DCHECK(CalledOnValidThread());
 
   if (!dns_config_service_thread_->IsRunning()) {
     dns_config_service_thread_->StartWithOptions(
-      base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
+        base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   }
 
   HANDLE handle = NULL;
   DWORD ret = NotifyAddrChange(&handle, &addr_overlapped_);
   if (ret != ERROR_IO_PENDING)
     return false;
 
   addr_watcher_.StartWatching(addr_overlapped_.hEvent, this);
   return true;
 }
 
 void NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange() {
   SetCurrentConnectionType(RecomputeCurrentConnectionType());
   bool current_offline = IsOffline();
   offline_polls_++;
   // If we continue to appear offline, delay sending out the notification in
   // case we appear to go online within 20 seconds.  UMA histogram data shows
   // we may not detect the transition to online state after 1 second but within
   // 20 seconds we generally do.
   if (last_announced_offline_ && current_offline && offline_polls_ <= 20) {
-    timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
+    timer_.Start(FROM_HERE,
+                 base::TimeDelta::FromSeconds(1),
+                 this,
                  &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange);
     return;
   }
   if (last_announced_offline_)
     UMA_HISTOGRAM_CUSTOM_COUNTS("NCN.OfflinePolls", offline_polls_, 1, 50, 50);
   last_announced_offline_ = current_offline;
 
   NotifyObserversOfConnectionTypeChange();
 }
 
 }  // namespace net