base::Bind: Convert net/proxy.

net/proxy/multi_threaded_proxy_resolver.cc

 // Copyright (c) 2011 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/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "base/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
@@ skipping 76 matching lines @@
 class MultiThreadedProxyResolver::Job
     : public base::RefCountedThreadSafe<MultiThreadedProxyResolver::Job> {
  public:
   // Identifies the subclass of Job (only being used for debugging purposes).
   enum Type {
     TYPE_GET_PROXY_FOR_URL,
     TYPE_SET_PAC_SCRIPT,
     TYPE_SET_PAC_SCRIPT_INTERNAL,
   };
 
-  Job(Type type, OldCompletionCallback* user_callback)
+  Job(Type type, const CompletionCallback& callback)
       : type_(type),
-        user_callback_(user_callback),
+        callback_(callback),
         executor_(NULL),
         was_cancelled_(false) {
   }
 
   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
@@ skipping 10 matching lines @@
   // 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).
   //
   // Otherwise jobs that correspond with user-initiated work will
-  // have a non-NULL callback up until the callback is run.
-  bool has_user_callback() const { return user_callback_ != NULL; }
+  // have a non-null callback up until the callback is run.
+  bool has_user_callback() const { return !callback_.is_null(); }
 
   // This method is called when the job is inserted into a wait queue
   // because no executors were ready to accept it.
   virtual void WaitingForThread() {}
 
   // This method is called just before the job is posted to the work thread.
   virtual void FinishedWaitingForThread() {}
 
   // This method is called on the worker thread to do the job's work. On
   // completion, implementors are expected to call OnJobCompleted() on
   // |origin_loop|.
   virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) = 0;
 
  protected:
   void OnJobCompleted() {
     // |executor_| will be NULL if the executor has already been deleted.
     if (executor_)
       executor_->OnJobCompleted(this);
   }
 
   void RunUserCallback(int result) {
     DCHECK(has_user_callback());
-    OldCompletionCallback* callback = user_callback_;
-    // Null the callback so has_user_callback() will now return false.
-    user_callback_ = NULL;
-    callback->Run(result);
+    CompletionCallback callback = callback_;
+    // Reset the callback so has_user_callback() will now return false.
+    callback_.Reset();
+    callback.Run(result);
   }
 
   friend class base::RefCountedThreadSafe<MultiThreadedProxyResolver::Job>;
 
   virtual ~Job() {}
 
  private:
   const Type type_;
-  OldCompletionCallback* user_callback_;
+  CompletionCallback callback_;
   Executor* executor_;
   bool was_cancelled_;
 };
 
 // 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,
-                  OldCompletionCallback* callback)
-    : Job(callback ? TYPE_SET_PAC_SCRIPT : TYPE_SET_PAC_SCRIPT_INTERNAL,
+                  const CompletionCallback& callback)
+    : 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_, NULL);
+    int rv = resolver->SetPacScript(script_data_, CompletionCallback());
 
     DCHECK_NE(rv, ERR_IO_PENDING);
     origin_loop->PostTask(
         FROM_HERE,
-        NewRunnableMethod(this, &SetPacScriptJob::RequestComplete, rv));
+        base::Bind(&SetPacScriptJob::RequestComplete, this, rv));
   }
 
  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()) {
       RunUserCallback(result_code);
     }
     OnJobCompleted();
   }
 
   const scoped_refptr<ProxyResolverScriptData> script_data_;
 };
 
 // MultiThreadedProxyResolver::GetProxyForURLJob ------------------------------
 
 class MultiThreadedProxyResolver::GetProxyForURLJob
     : public MultiThreadedProxyResolver::Job {
  public:
   // |url|         -- the URL of the query.
   // |results|     -- the structure to fill with proxy resolve results.
   GetProxyForURLJob(const GURL& url,
                     ProxyInfo* results,
-                    OldCompletionCallback* callback,
+                    const CompletionCallback& callback,
                     const BoundNetLog& net_log)
       : Job(TYPE_GET_PROXY_FOR_URL, callback),
         results_(results),
         net_log_(net_log),
         url_(url),
         was_waiting_for_thread_(false) {
-    DCHECK(callback);
+    DCHECK(!callback.is_null());
   }
 
   BoundNetLog* net_log() { return &net_log_; }
 
   virtual void WaitingForThread() OVERRIDE {
     was_waiting_for_thread_ = true;
     net_log_.BeginEvent(
         NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD, NULL);
   }
 
   virtual void FinishedWaitingForThread() OVERRIDE {
     DCHECK(executor());
 
     if (was_waiting_for_thread_) {
       net_log_.EndEvent(
           NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD, NULL);
     }
 
     net_log_.AddEvent(
         NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD,
         make_scoped_refptr(new NetLogIntegerParameter(
             "thread_number", executor()->thread_number())));
   }
 
   // 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_, NULL, NULL, net_log_);
+        url_, &results_buf_, CompletionCallback(), NULL, net_log_);
     DCHECK_NE(rv, ERR_IO_PENDING);
 
     origin_loop->PostTask(
         FROM_HERE,
-        NewRunnableMethod(this, &GetProxyForURLJob::QueryComplete, rv));
+        base::Bind(&GetProxyForURLJob::QueryComplete, this, rv));
   }
 
  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()) {
       if (result_code >= OK) {  // Note: unit-tests use values > 0.
         results_->Use(results_buf_);
       }
@@ skipping 38 matching lines @@
 void MultiThreadedProxyResolver::Executor::StartJob(Job* job) {
   DCHECK(!outstanding_job_);
   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,
-      NewRunnableMethod(job, &Job::Run,
-                        base::MessageLoopProxy::current()));
+      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 24 matching lines @@
 
   // Null some stuff as a precaution.
   coordinator_ = NULL;
   outstanding_job_ = NULL;
 }
 
 void MultiThreadedProxyResolver::Executor::PurgeMemory() {
   scoped_refptr<PurgeMemoryTask> helper(new PurgeMemoryTask(resolver_.get()));
   thread_->message_loop()->PostTask(
       FROM_HERE,
-      NewRunnableMethod(helper.get(), &PurgeMemoryTask::PurgeMemory));
+      base::Bind(&PurgeMemoryTask::PurgeMemory, helper.get()));
 }
 
 MultiThreadedProxyResolver::Executor::~Executor() {
   // The important cleanup happens as part of Destroy(), which should always be
   // called first.
   DCHECK(!coordinator_) << "Destroy() was not called";
   DCHECK(!thread_.get());
   DCHECK(!resolver_.get());
   DCHECK(!outstanding_job_);
 }
 
 // MultiThreadedProxyResolver --------------------------------------------------
 
 MultiThreadedProxyResolver::MultiThreadedProxyResolver(
     ProxyResolverFactory* resolver_factory,
     size_t max_num_threads)
     : ProxyResolver(resolver_factory->resolvers_expect_pac_bytes()),
       resolver_factory_(resolver_factory),
       max_num_threads_(max_num_threads) {
   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,
-                                               OldCompletionCallback* callback,
-                                               RequestHandle* request,
-                                               const BoundNetLog& net_log) {
+int MultiThreadedProxyResolver::GetProxyForURL(
+    const GURL& url, ProxyInfo* results, const CompletionCallback& callback,
+    RequestHandle* request, const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
-  DCHECK(callback);
+  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|.
   if (request)
     *request = reinterpret_cast<RequestHandle>(job.get());
 
   // If there is an executor that is ready to run this request, submit it!
   Executor* executor = FindIdleExecutor();
   if (executor) {
     DCHECK_EQ(0u, pending_jobs_.size());
     executor->StartJob(job);
     return ERR_IO_PENDING;
   }
 
   // Otherwise queue this request. (We will schedule it to a thread once one
   // becomes available).
   job->WaitingForThread();
   pending_jobs_.push_back(job);
 
   // If we haven't already reached the thread limit, provision a new thread to
   // drain the requests more quickly.
   if (executors_.size() < max_num_threads_) {
     executor = AddNewExecutor();
     executor->StartJob(
-        new SetPacScriptJob(current_script_data_, NULL));
+        new SetPacScriptJob(current_script_data_, CompletionCallback()));
   }
 
   return ERR_IO_PENDING;
 }
 
 void MultiThreadedProxyResolver::CancelRequest(RequestHandle req) {
   DCHECK(CalledOnValidThread());
   DCHECK(req);
 
   Job* job = reinterpret_cast<Job*>(req);
@@ skipping 46 matching lines @@
   DCHECK(CalledOnValidThread());
   for (ExecutorList::iterator it = executors_.begin();
        it != executors_.end(); ++it) {
     Executor* executor = *it;
     executor->PurgeMemory();
   }
 }
 
 int MultiThreadedProxyResolver::SetPacScript(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
-    OldCompletionCallback* callback) {
+    const CompletionCallback&callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(callback);
+  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();
@@ skipping 64 matching lines @@
     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);
 }
 
 }  // namespace net