Clang format slam.

net/base/network_change_notifier.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.h"
 
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "build/build_config.h"
@@ skipping 27 matching lines @@
 class MockNetworkChangeNotifier : public NetworkChangeNotifier {
  public:
   virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
     return CONNECTION_UNKNOWN;
   }
 };
 
 }  // namespace
 
 // The main observer class that records UMAs for network events.
-class HistogramWatcher
-    : public NetworkChangeNotifier::ConnectionTypeObserver,
-      public NetworkChangeNotifier::IPAddressObserver,
-      public NetworkChangeNotifier::DNSObserver,
-      public NetworkChangeNotifier::NetworkChangeObserver {
+class HistogramWatcher : public NetworkChangeNotifier::ConnectionTypeObserver,
+                         public NetworkChangeNotifier::IPAddressObserver,
+                         public NetworkChangeNotifier::DNSObserver,
+                         public NetworkChangeNotifier::NetworkChangeObserver {
  public:
   HistogramWatcher()
       : last_ip_address_change_(base::TimeTicks::Now()),
         last_connection_change_(base::TimeTicks::Now()),
         last_dns_change_(base::TimeTicks::Now()),
         last_network_change_(base::TimeTicks::Now()),
         last_connection_type_(NetworkChangeNotifier::CONNECTION_UNKNOWN),
         offline_packets_received_(0),
         bytes_read_since_last_connection_change_(0),
         peak_kbps_since_last_connection_change_(0) {}
@@ skipping 147 matching lines @@
         break;
     }
 
     if (type != NetworkChangeNotifier::CONNECTION_NONE) {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OnlineChange", state_duration);
 
       if (offline_packets_received_) {
         if ((now - last_offline_packet_received_) <
             base::TimeDelta::FromSeconds(5)) {
           // We can compare this sum with the sum of NCN.OfflineDataRecv.
-          UMA_HISTOGRAM_COUNTS_10000(
-              "NCN.OfflineDataRecvAny5sBeforeOnline",
-              offline_packets_received_);
+          UMA_HISTOGRAM_COUNTS_10000("NCN.OfflineDataRecvAny5sBeforeOnline",
+                                     offline_packets_received_);
         }
 
         UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineDataRecvUntilOnline",
                                    now - last_offline_packet_received_);
       }
     } else {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineChange", state_duration);
     }
-    UMA_HISTOGRAM_MEDIUM_TIMES(
-        "NCN.IPAddressChangeToConnectionTypeChange",
-        now - last_ip_address_change_);
+    UMA_HISTOGRAM_MEDIUM_TIMES("NCN.IPAddressChangeToConnectionTypeChange",
+                               now - last_ip_address_change_);
 
     offline_packets_received_ = 0;
     bytes_read_since_last_connection_change_ = 0;
     peak_kbps_since_last_connection_change_ = 0;
     last_connection_type_ = type;
     polling_interval_ = base::TimeDelta::FromSeconds(1);
   }
 
   // NetworkChangeNotifier::DNSObserver implementation.
   virtual void OnDNSChanged() OVERRIDE {
@@ skipping 47 matching lines @@
       return;
 
     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.OfflineDataRecv",
                                now - last_connection_change_);
     offline_packets_received_++;
     last_offline_packet_received_ = now;
 
     if ((now - last_polled_connection_) > polling_interval_) {
       polling_interval_ *= 2;
       last_polled_connection_ = now;
-      last_polled_connection_type_ =
-          NetworkChangeNotifier::GetConnectionType();
+      last_polled_connection_type_ = NetworkChangeNotifier::GetConnectionType();
     }
     if (last_polled_connection_type_ ==
         NetworkChangeNotifier::CONNECTION_NONE) {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.PollingOfflineDataRecv",
                                  now - last_connection_change_);
     }
   }
 
  private:
-  static base::TimeDelta SinceLast(base::TimeTicks *last_time) {
+  static base::TimeDelta SinceLast(base::TimeTicks* last_time) {
     base::TimeTicks current_time = base::TimeTicks::Now();
     base::TimeDelta delta = current_time - *last_time;
     *last_time = current_time;
     return delta;
   }
 
   base::TimeTicks last_ip_address_change_;
   base::TimeTicks last_connection_change_;
   base::TimeTicks last_dns_change_;
   base::TimeTicks last_network_change_;
@@ skipping 81 matching lines @@
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(g_network_change_notifier);
     RemoveConnectionTypeObserver(this);
     RemoveIPAddressObserver(this);
   }
 
   // NetworkChangeNotifier::IPAddressObserver implementation.
   virtual void OnIPAddressChanged() OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
     base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
-        ? params_.ip_address_offline_delay_ : params_.ip_address_online_delay_;
+                                ? params_.ip_address_offline_delay_
+                                : params_.ip_address_online_delay_;
     // Cancels any previous timer.
     timer_.Start(FROM_HERE, delay, this, &NetworkChangeCalculator::Notify);
   }
 
   // NetworkChangeNotifier::ConnectionTypeObserver implementation.
   virtual void OnConnectionTypeChanged(ConnectionType type) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
     pending_connection_type_ = type;
     base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
-        ? params_.connection_type_offline_delay_
-        : params_.connection_type_online_delay_;
+                                ? params_.connection_type_offline_delay_
+                                : params_.connection_type_online_delay_;
     // Cancels any previous timer.
     timer_.Start(FROM_HERE, delay, this, &NetworkChangeCalculator::Notify);
   }
 
  private:
   void Notify() {
     DCHECK(thread_checker_.CalledOnValidThread());
     // Don't bother signaling about dead connections.
     if (have_announced_ &&
         (last_announced_connection_type_ == CONNECTION_NONE) &&
@@ skipping 26 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(NetworkChangeCalculator);
 };
 
 NetworkChangeNotifier::~NetworkChangeNotifier() {
   network_change_calculator_.reset();
   DCHECK_EQ(this, g_network_change_notifier);
   g_network_change_notifier = NULL;
 }
 
 // static
-void NetworkChangeNotifier::SetFactory(
-    NetworkChangeNotifierFactory* factory) {
+void NetworkChangeNotifier::SetFactory(NetworkChangeNotifierFactory* factory) {
   CHECK(!g_network_change_notifier_factory);
   g_network_change_notifier_factory = factory;
 }
 
 // static
 NetworkChangeNotifier* NetworkChangeNotifier::Create() {
   if (g_network_change_notifier_factory)
     return g_network_change_notifier_factory->CreateInstance();
 
 #if defined(OS_WIN)
   NetworkChangeNotifierWin* network_change_notifier =
       new NetworkChangeNotifierWin();
   network_change_notifier->WatchForAddressChange();
   return network_change_notifier;
 #elif defined(OS_CHROMEOS) || defined(OS_ANDROID)
-  // ChromeOS and Android builds MUST use their own class factory.
+// ChromeOS and Android builds MUST use their own class factory.
 #if !defined(OS_CHROMEOS)
   // TODO(oshima): ash_shell do not have access to chromeos'es
   // notifier yet. Re-enable this when chromeos'es notifier moved to
   // chromeos root directory. crbug.com/119298.
   CHECK(false);
 #endif
   return NULL;
 #elif defined(OS_LINUX)
   return NetworkChangeNotifierLinux::Create();
 #elif defined(OS_MACOSX)
   return new NetworkChangeNotifierMac();
 #else
   NOTIMPLEMENTED();
   return NULL;
 #endif
 }
 
 // static
 NetworkChangeNotifier::ConnectionType
 NetworkChangeNotifier::GetConnectionType() {
-  return g_network_change_notifier ?
-      g_network_change_notifier->GetCurrentConnectionType() :
-      CONNECTION_UNKNOWN;
+  return g_network_change_notifier
+             ? g_network_change_notifier->GetCurrentConnectionType()
+             : CONNECTION_UNKNOWN;
 }
 
 // static
 void NetworkChangeNotifier::GetDnsConfig(DnsConfig* config) {
   if (!g_network_change_notifier) {
     *config = DnsConfig();
   } else {
     g_network_change_notifier->network_state_->GetDnsConfig(config);
   }
 }
 
 // static
-const char* NetworkChangeNotifier::ConnectionTypeToString(
-    ConnectionType type) {
+const char* NetworkChangeNotifier::ConnectionTypeToString(ConnectionType type) {
   static const char* kConnectionTypeNames[] = {
-    "CONNECTION_UNKNOWN",
-    "CONNECTION_ETHERNET",
-    "CONNECTION_WIFI",
-    "CONNECTION_2G",
-    "CONNECTION_3G",
-    "CONNECTION_4G",
-    "CONNECTION_NONE"
-  };
-  COMPILE_ASSERT(
-      arraysize(kConnectionTypeNames) ==
-          NetworkChangeNotifier::CONNECTION_NONE + 1,
-      ConnectionType_name_count_mismatch);
+      "CONNECTION_UNKNOWN", "CONNECTION_ETHERNET", "CONNECTION_WIFI",
+      "CONNECTION_2G",      "CONNECTION_3G",       "CONNECTION_4G",
+      "CONNECTION_NONE"};
+  COMPILE_ASSERT(arraysize(kConnectionTypeNames) ==
+                     NetworkChangeNotifier::CONNECTION_NONE + 1,
+                 ConnectionType_name_count_mismatch);
   if (type < CONNECTION_UNKNOWN || type > CONNECTION_NONE) {
     NOTREACHED();
     return "CONNECTION_INVALID";
   }
   return kConnectionTypeNames[type];
 }
 
 // static
 void NetworkChangeNotifier::NotifyDataReceived(const URLRequest& request,
                                                int bytes_read) {
@@ skipping 17 matching lines @@
 void NetworkChangeNotifier::ShutdownHistogramWatcher() {
   if (!g_network_change_notifier)
     return;
   g_network_change_notifier->histogram_watcher_.reset();
 }
 
 #if defined(OS_LINUX)
 // static
 const internal::AddressTrackerLinux*
 NetworkChangeNotifier::GetAddressTracker() {
-  return g_network_change_notifier ?
-        g_network_change_notifier->GetAddressTrackerInternal() : NULL;
+  return g_network_change_notifier
+             ? g_network_change_notifier->GetAddressTrackerInternal()
+             : NULL;
 }
 #endif
 
 // static
 bool NetworkChangeNotifier::IsOffline() {
-   return GetConnectionType() == CONNECTION_NONE;
+  return GetConnectionType() == CONNECTION_NONE;
 }
 
 // static
 bool NetworkChangeNotifier::IsConnectionCellular(ConnectionType type) {
   bool is_cellular = false;
   switch (type) {
     case CONNECTION_2G:
     case CONNECTION_3G:
     case CONNECTION_4G:
-      is_cellular =  true;
+      is_cellular = true;
       break;
     case CONNECTION_UNKNOWN:
     case CONNECTION_ETHERNET:
     case CONNECTION_WIFI:
     case CONNECTION_NONE:
       is_cellular = false;
       break;
   }
   return is_cellular;
 }
@@ skipping 57 matching lines @@
 void NetworkChangeNotifier::RemoveNetworkChangeObserver(
     NetworkChangeObserver* observer) {
   if (g_network_change_notifier) {
     g_network_change_notifier->network_change_observer_list_->RemoveObserver(
         observer);
   }
 }
 
 NetworkChangeNotifier::NetworkChangeNotifier(
     const NetworkChangeCalculatorParams& params
-        /*= NetworkChangeCalculatorParams()*/)
-    : ip_address_observer_list_(
-        new ObserverListThreadSafe<IPAddressObserver>(
-            ObserverListBase<IPAddressObserver>::NOTIFY_EXISTING_ONLY)),
+    /*= NetworkChangeCalculatorParams()*/)
+    : ip_address_observer_list_(new ObserverListThreadSafe<IPAddressObserver>(
+          ObserverListBase<IPAddressObserver>::NOTIFY_EXISTING_ONLY)),
       connection_type_observer_list_(
-        new ObserverListThreadSafe<ConnectionTypeObserver>(
-            ObserverListBase<ConnectionTypeObserver>::NOTIFY_EXISTING_ONLY)),
-      resolver_state_observer_list_(
-        new ObserverListThreadSafe<DNSObserver>(
-            ObserverListBase<DNSObserver>::NOTIFY_EXISTING_ONLY)),
+          new ObserverListThreadSafe<ConnectionTypeObserver>(
+              ObserverListBase<ConnectionTypeObserver>::NOTIFY_EXISTING_ONLY)),
+      resolver_state_observer_list_(new ObserverListThreadSafe<DNSObserver>(
+          ObserverListBase<DNSObserver>::NOTIFY_EXISTING_ONLY)),
       network_change_observer_list_(
-        new ObserverListThreadSafe<NetworkChangeObserver>(
-            ObserverListBase<NetworkChangeObserver>::NOTIFY_EXISTING_ONLY)),
+          new ObserverListThreadSafe<NetworkChangeObserver>(
+              ObserverListBase<NetworkChangeObserver>::NOTIFY_EXISTING_ONLY)),
       network_state_(new NetworkState()),
       network_change_calculator_(new NetworkChangeCalculator(params)) {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = this;
   network_change_calculator_->Init();
 }
 
 #if defined(OS_LINUX)
 const internal::AddressTrackerLinux*
 NetworkChangeNotifier::GetAddressTrackerInternal() const {
@@ skipping 21 matching lines @@
 void NetworkChangeNotifier::SetDnsConfig(const DnsConfig& config) {
   if (!g_network_change_notifier)
     return;
   g_network_change_notifier->network_state_->SetDnsConfig(config);
   NotifyObserversOfDNSChange();
 }
 
 void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange() {
   if (g_network_change_notifier) {
     g_network_change_notifier->connection_type_observer_list_->Notify(
-        &ConnectionTypeObserver::OnConnectionTypeChanged,
-        GetConnectionType());
+        &ConnectionTypeObserver::OnConnectionTypeChanged, GetConnectionType());
   }
 }
 
 void NetworkChangeNotifier::NotifyObserversOfNetworkChange(
     ConnectionType type) {
   if (g_network_change_notifier) {
     g_network_change_notifier->network_change_observer_list_->Notify(
-        &NetworkChangeObserver::OnNetworkChanged,
-        type);
+        &NetworkChangeObserver::OnNetworkChanged, type);
   }
 }
 
 NetworkChangeNotifier::DisableForTest::DisableForTest()
     : network_change_notifier_(g_network_change_notifier) {
   DCHECK(g_network_change_notifier);
   g_network_change_notifier = NULL;
 }
 
 NetworkChangeNotifier::DisableForTest::~DisableForTest() {
   DCHECK(!g_network_change_notifier);
   g_network_change_notifier = network_change_notifier_;
 }
 
 }  // namespace net