Clang format slam.

net/proxy/polling_proxy_config_service.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/proxy/polling_proxy_config_service.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/observer_list.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/worker_pool.h"
 #include "net/proxy/proxy_config.h"
 
 namespace net {
 
 // Reference-counted wrapper that does all the work (needs to be
 // reference-counted since we post tasks between threads; may outlive
 // the parent PollingProxyConfigService).
 class PollingProxyConfigService::Core
     : public base::RefCountedThreadSafe<PollingProxyConfigService::Core> {
  public:
-  Core(base::TimeDelta poll_interval,
-       GetConfigFunction get_config_func)
+  Core(base::TimeDelta poll_interval, GetConfigFunction get_config_func)
       : get_config_func_(get_config_func),
         poll_interval_(poll_interval),
         have_initialized_origin_loop_(false),
         has_config_(false),
         poll_task_outstanding_(false),
-        poll_task_queued_(false) {
-  }
+        poll_task_queued_(false) {}
 
   // Called when the parent PollingProxyConfigService is destroyed
   // (observers should not be called past this point).
   void Orphan() {
     base::AutoLock l(lock_);
     origin_loop_proxy_ = NULL;
   }
 
   bool GetLatestProxyConfig(ProxyConfig* config) {
     LazyInitializeOriginLoop();
@@ skipping 75 matching lines @@
 
     if (!origin_loop_proxy_.get())
       return;  // Was orphaned (parent has already been destroyed).
 
     DCHECK(origin_loop_proxy_->BelongsToCurrentThread());
 
     if (!has_config_ || !last_config_.Equals(config)) {
       // If the configuration has changed, notify the observers.
       has_config_ = true;
       last_config_ = config;
-      FOR_EACH_OBSERVER(Observer, observers_,
-                        OnProxyConfigChanged(config,
-                                             ProxyConfigService::CONFIG_VALID));
+      FOR_EACH_OBSERVER(
+          Observer,
+          observers_,
+          OnProxyConfigChanged(config, ProxyConfigService::CONFIG_VALID));
     }
 
     if (poll_task_queued_)
       CheckForChangesNow();
   }
 
   void LazyInitializeOriginLoop() {
     // TODO(eroman): Really this should be done in the constructor, but right
     //               now chrome is constructing the ProxyConfigService on the
     //               UI thread so we can't cache the IO thread for the purpose
@@ skipping 21 matching lines @@
 
 void PollingProxyConfigService::AddObserver(Observer* observer) {
   core_->AddObserver(observer);
 }
 
 void PollingProxyConfigService::RemoveObserver(Observer* observer) {
   core_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
-    PollingProxyConfigService::GetLatestProxyConfig(ProxyConfig* config) {
+PollingProxyConfigService::GetLatestProxyConfig(ProxyConfig* config) {
   return core_->GetLatestProxyConfig(config) ? CONFIG_VALID : CONFIG_PENDING;
 }
 
 void PollingProxyConfigService::OnLazyPoll() {
   core_->OnLazyPoll();
 }
 
 PollingProxyConfigService::PollingProxyConfigService(
     base::TimeDelta poll_interval,
     GetConfigFunction get_config_func)
     : core_(new Core(poll_interval, get_config_func)) {
 }
 
 PollingProxyConfigService::~PollingProxyConfigService() {
   core_->Orphan();
 }
 
 void PollingProxyConfigService::CheckForChangesNow() {
   core_->CheckForChangesNow();
 }
 
 }  // namespace net