Clang format slam.

net/proxy/multi_threaded_proxy_resolver.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/multi_threaded_proxy_resolver.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/proxy/proxy_info.h"
 
 // TODO(eroman): Have the MultiThreadedProxyResolver clear its PAC script
 //               data when SetPacScript fails. That will reclaim memory when
 //               testing bogus scripts.
 
 namespace net {
 
 // An "executor" is a job-runner for PAC requests. It encapsulates a worker
 // thread and a synchronous ProxyResolver (which will be operated on said
 // thread.)
 class MultiThreadedProxyResolver::Executor
-    : public base::RefCountedThreadSafe<MultiThreadedProxyResolver::Executor > {
+    : public base::RefCountedThreadSafe<MultiThreadedProxyResolver::Executor> {
  public:
   // |coordinator| must remain valid throughout our lifetime. It is used to
   // signal when the executor is ready to receive work by calling
   // |coordinator->OnExecutorReady()|.
   // The constructor takes ownership of |resolver|.
   // |thread_number| is an identifier used when naming the worker thread.
   Executor(MultiThreadedProxyResolver* coordinator,
            ProxyResolver* resolver,
            int thread_number);
 
@@ skipping 44 matching lines @@
   enum Type {
     TYPE_GET_PROXY_FOR_URL,
     TYPE_SET_PAC_SCRIPT,
     TYPE_SET_PAC_SCRIPT_INTERNAL,
   };
 
   Job(Type type, const CompletionCallback& callback)
       : type_(type),
         callback_(callback),
         executor_(NULL),
-        was_cancelled_(false) {
-  }
+        was_cancelled_(false) {}
 
-  void set_executor(Executor* executor) {
-    executor_ = executor;
-  }
+  void set_executor(Executor* executor) { executor_ = executor; }
 
   // The "executor" is the job runner that is scheduling this job. If
   // this job has not been submitted to an executor yet, this will be
   // NULL (and we know it hasn't started yet).
-  Executor* executor() {
-    return executor_;
-  }
+  Executor* executor() { return executor_; }
 
   // Mark the job as having been cancelled.
-  void Cancel() {
-    was_cancelled_ = true;
-  }
+  void Cancel() { was_cancelled_ = true; }
 
   // Returns true if Cancel() has been called.
   bool was_cancelled() const { return was_cancelled_; }
 
   Type type() const { return type_; }
 
   // Returns true if this job still has a user callback. Some jobs
   // do not have a user callback, because they were helper jobs
   // scheduled internally (for example TYPE_SET_PAC_SCRIPT_INTERNAL).
   //
@@ skipping 40 matching lines @@
 };
 
 // MultiThreadedProxyResolver::SetPacScriptJob ---------------------------------
 
 // Runs on the worker thread to call ProxyResolver::SetPacScript.
 class MultiThreadedProxyResolver::SetPacScriptJob
     : public MultiThreadedProxyResolver::Job {
  public:
   SetPacScriptJob(const scoped_refptr<ProxyResolverScriptData>& script_data,
                   const CompletionCallback& callback)
-    : Job(!callback.is_null() ? TYPE_SET_PAC_SCRIPT :
-                                TYPE_SET_PAC_SCRIPT_INTERNAL,
-          callback),
-      script_data_(script_data) {
-  }
+      : Job(!callback.is_null() ? TYPE_SET_PAC_SCRIPT
+                                : TYPE_SET_PAC_SCRIPT_INTERNAL,
+            callback),
+        script_data_(script_data) {}
 
   // Runs on the worker thread.
   virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) OVERRIDE {
     ProxyResolver* resolver = executor()->resolver();
     int rv = resolver->SetPacScript(script_data_, CompletionCallback());
 
     DCHECK_NE(rv, ERR_IO_PENDING);
     origin_loop->PostTask(
-        FROM_HERE,
-        base::Bind(&SetPacScriptJob::RequestComplete, this, rv));
+        FROM_HERE, base::Bind(&SetPacScriptJob::RequestComplete, this, rv));
   }
 
  protected:
   virtual ~SetPacScriptJob() {}
 
  private:
   // Runs the completion callback on the origin thread.
   void RequestComplete(int result_code) {
     // The task may have been cancelled after it was started.
     if (!was_cancelled() && has_user_callback()) {
@@ skipping 47 matching lines @@
   }
 
   // Runs on the worker thread.
   virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) OVERRIDE {
     ProxyResolver* resolver = executor()->resolver();
     int rv = resolver->GetProxyForURL(
         url_, &results_buf_, CompletionCallback(), NULL, net_log_);
     DCHECK_NE(rv, ERR_IO_PENDING);
 
     origin_loop->PostTask(
-        FROM_HERE,
-        base::Bind(&GetProxyForURLJob::QueryComplete, this, rv));
+        FROM_HERE, base::Bind(&GetProxyForURLJob::QueryComplete, this, rv));
   }
 
  protected:
   virtual ~GetProxyForURLJob() {}
 
  private:
   // Runs the completion callback on the origin thread.
   void QueryComplete(int result_code) {
     // The Job may have been cancelled after it was started.
     if (!was_cancelled()) {
@@ skipping 41 matching lines @@
 MultiThreadedProxyResolver::Executor::Executor(
     MultiThreadedProxyResolver* coordinator,
     ProxyResolver* resolver,
     int thread_number)
     : coordinator_(coordinator),
       thread_number_(thread_number),
       resolver_(resolver) {
   DCHECK(coordinator);
   DCHECK(resolver);
   // Start up the thread.
-  thread_.reset(new base::Thread(base::StringPrintf("PAC thread #%d",
-                                                    thread_number)));
+  thread_.reset(
+      new base::Thread(base::StringPrintf("PAC thread #%d", thread_number)));
   CHECK(thread_->Start());
 }
 
 void MultiThreadedProxyResolver::Executor::StartJob(Job* job) {
   DCHECK(!outstanding_job_.get());
   outstanding_job_ = job;
 
   // Run the job. Once it has completed (regardless of whether it was
   // cancelled), it will invoke OnJobCompleted() on this thread.
   job->set_executor(this);
   job->FinishedWaitingForThread();
   thread_->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&Job::Run, job, base::MessageLoopProxy::current()));
+      FROM_HERE, base::Bind(&Job::Run, job, base::MessageLoopProxy::current()));
 }
 
 void MultiThreadedProxyResolver::Executor::OnJobCompleted(Job* job) {
   DCHECK_EQ(job, outstanding_job_.get());
   outstanding_job_ = NULL;
   coordinator_->OnExecutorReady(this);
 }
 
 void MultiThreadedProxyResolver::Executor::Destroy() {
   DCHECK(coordinator_);
@@ skipping 42 matching lines @@
   DCHECK_GE(max_num_threads, 1u);
 }
 
 MultiThreadedProxyResolver::~MultiThreadedProxyResolver() {
   // We will cancel all outstanding requests.
   pending_jobs_.clear();
   ReleaseAllExecutors();
 }
 
 int MultiThreadedProxyResolver::GetProxyForURL(
-    const GURL& url, ProxyInfo* results, const CompletionCallback& callback,
-    RequestHandle* request, const BoundNetLog& net_log) {
+    const GURL& url,
+    ProxyInfo* results,
+    const CompletionCallback& callback,
+    RequestHandle* request,
+    const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
   DCHECK(current_script_data_.get())
       << "Resolver is un-initialized. Must call SetPacScript() first!";
 
   scoped_refptr<GetProxyForURLJob> job(
       new GetProxyForURLJob(url, results, callback, net_log));
 
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |request|.
@@ skipping 47 matching lines @@
 LoadState MultiThreadedProxyResolver::GetLoadState(RequestHandle req) const {
   DCHECK(CalledOnValidThread());
   DCHECK(req);
   return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
 }
 
 void MultiThreadedProxyResolver::CancelSetPacScript() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(0u, pending_jobs_.size());
   DCHECK_EQ(1u, executors_.size());
-  DCHECK_EQ(Job::TYPE_SET_PAC_SCRIPT,
-            executors_[0]->outstanding_job()->type());
+  DCHECK_EQ(Job::TYPE_SET_PAC_SCRIPT, executors_[0]->outstanding_job()->type());
 
   // Defensively clear some data which shouldn't be getting used
   // anymore.
   current_script_data_ = NULL;
 
   ReleaseAllExecutors();
 }
 
 int MultiThreadedProxyResolver::SetPacScript(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
-    const CompletionCallback&callback) {
+    const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   // Save the script details, so we can provision new executors later.
   current_script_data_ = script_data;
 
   // The user should not have any outstanding requests when they call
   // SetPacScript().
   CheckNoOutstandingUserRequests();
 
   // Destroy all of the current threads and their proxy resolvers.
   ReleaseAllExecutors();
 
   // Provision a new executor, and run the SetPacScript request. On completion
   // notification will be sent through |callback|.
   Executor* executor = AddNewExecutor();
   executor->StartJob(new SetPacScriptJob(script_data, callback));
   return ERR_IO_PENDING;
 }
 
 void MultiThreadedProxyResolver::CheckNoOutstandingUserRequests() const {
   DCHECK(CalledOnValidThread());
   CHECK_EQ(0u, pending_jobs_.size());
 
   for (ExecutorList::const_iterator it = executors_.begin();
-       it != executors_.end(); ++it) {
+       it != executors_.end();
+       ++it) {
     const Executor* executor = it->get();
     Job* job = executor->outstanding_job();
     // The "has_user_callback()" is to exclude jobs for which the callback
     // has already been invoked, or was not user-initiated (as in the case of
     // lazy thread provisions). User-initiated jobs may !has_user_callback()
     // when the callback has already been run. (Since we only clear the
     // outstanding job AFTER the callback has been invoked, it is possible
     // for a new request to be started from within the callback).
     CHECK(!job || job->was_cancelled() || !job->has_user_callback());
   }
 }
 
 void MultiThreadedProxyResolver::ReleaseAllExecutors() {
   DCHECK(CalledOnValidThread());
-  for (ExecutorList::iterator it = executors_.begin();
-       it != executors_.end(); ++it) {
+  for (ExecutorList::iterator it = executors_.begin(); it != executors_.end();
+       ++it) {
     Executor* executor = it->get();
     executor->Destroy();
   }
   executors_.clear();
 }
 
 MultiThreadedProxyResolver::Executor*
 MultiThreadedProxyResolver::FindIdleExecutor() {
   DCHECK(CalledOnValidThread());
-  for (ExecutorList::iterator it = executors_.begin();
-       it != executors_.end(); ++it) {
+  for (ExecutorList::iterator it = executors_.begin(); it != executors_.end();
+       ++it) {
     Executor* executor = it->get();
     if (!executor->outstanding_job())
       return executor;
   }
   return NULL;
 }
 
 MultiThreadedProxyResolver::Executor*
 MultiThreadedProxyResolver::AddNewExecutor() {
   DCHECK(CalledOnValidThread());
   DCHECK_LT(executors_.size(), max_num_threads_);
   // The "thread number" is used to give the thread a unique name.
   int thread_number = executors_.size();
   ProxyResolver* resolver = resolver_factory_->CreateProxyResolver();
-  Executor* executor = new Executor(
-      this, resolver, thread_number);
+  Executor* executor = new Executor(this, resolver, thread_number);
   executors_.push_back(make_scoped_refptr(executor));
   return executor;
 }
 
 void MultiThreadedProxyResolver::OnExecutorReady(Executor* executor) {
   DCHECK(CalledOnValidThread());
   if (pending_jobs_.empty())
     return;
 
   // Get the next job to process (FIFO). Transfer it from the pending queue
   // to the executor.
   scoped_refptr<Job> job = pending_jobs_.front();
   pending_jobs_.pop_front();
   executor->StartJob(job.get());
 }
 
 }  // namespace net