[net/proxy] Usage of ThreadTaskRunnerHandle & SingleThreadTaskRunner instead of MLP

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 <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver.h"
 
 namespace net {
 namespace {
@@ skipping 168 matching lines @@
 
   // 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;
+  // |origin_runner|.
+  virtual void Run(
+      scoped_refptr<base::SingleThreadTaskRunner> origin_runner) = 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());
@@ skipping 19 matching lines @@
 // Runs on the worker thread to call ProxyResolverFactory::CreateProxyResolver.
 class CreateResolverJob : public Job {
  public:
   CreateResolverJob(const scoped_refptr<ProxyResolverScriptData>& script_data,
                     ProxyResolverFactory* factory)
       : Job(TYPE_CREATE_RESOLVER, CompletionCallback()),
         script_data_(script_data),
         factory_(factory) {}
 
   // Runs on the worker thread.
-  void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) override {
+  void Run(scoped_refptr<base::SingleThreadTaskRunner> origin_runner) override {
     scoped_ptr<ProxyResolverFactory::Request> request;
     int rv = factory_->CreateProxyResolver(script_data_, &resolver_,
                                            CompletionCallback(), &request);
 
     DCHECK_NE(rv, ERR_IO_PENDING);
-    origin_loop->PostTask(
+    origin_runner->PostTask(
         FROM_HERE, base::Bind(&CreateResolverJob::RequestComplete, this, rv));
   }
 
  protected:
   ~CreateResolverJob() override {}
 
  private:
   // Runs the completion callback on the origin thread.
   void RequestComplete(int result_code) {
     // The task may have been cancelled after it was started.
@@ skipping 40 matching lines @@
     if (was_waiting_for_thread_) {
       net_log_.EndEvent(NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD);
     }
 
     net_log_.AddEvent(
         NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD,
         NetLog::IntegerCallback("thread_number", executor()->thread_number()));
   }
 
   // Runs on the worker thread.
-  void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) override {
+  void Run(scoped_refptr<base::SingleThreadTaskRunner> origin_runner) override {
     ProxyResolver* resolver = executor()->resolver();
     DCHECK(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));
+    origin_runner->PostTask(
+        FROM_HERE, base::Bind(&GetProxyForURLJob::QueryComplete, this, rv));
   }
 
  protected:
   ~GetProxyForURLJob() override {}
 
  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 32 matching lines @@
 void 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()));
+      base::Bind(&Job::Run, job, base::ThreadTaskRunnerHandle::Get()));
 }
 
 void Executor::OnJobCompleted(Job* job) {
   DCHECK_EQ(job, outstanding_job_.get());
   outstanding_job_ = NULL;
   coordinator_->OnExecutorReady(this);
 }
 
 void Executor::Destroy() {
   DCHECK(coordinator_);
@@ skipping 251 matching lines @@
   return ERR_IO_PENDING;
 }
 
 void MultiThreadedProxyResolverFactory::RemoveJob(
     MultiThreadedProxyResolverFactory::Job* job) {
   size_t erased = jobs_.erase(job);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace net