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

net/proxy/proxy_resolver_v8_tracing.cc

 // Copyright (c) 2013 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/proxy_resolver_v8_tracing.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/dns/host_resolver.h"
 #include "net/log/net_log.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 #include "net/proxy/proxy_resolver_v8.h"
@@ skipping 171 matching lines @@
   void DispatchBufferedAlertsAndErrors();
   void DispatchAlertOrError(bool is_alert, int line_number,
                             const base::string16& message);
 
   void LogEventToCurrentRequestAndGlobally(
       NetLog::EventType type,
       const NetLog::ParametersCallback& parameters_callback);
 
   // The thread which called into ProxyResolverV8Tracing, and on which the
   // completion callback is expected to run.
-  scoped_refptr<base::MessageLoopProxy> origin_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> origin_runner_;
 
   // The ProxyResolverV8Tracing which spawned this Job.
   // Initialized on origin thread and then accessed from both threads.
   ProxyResolverV8Tracing* parent_;
 
   // The callback to run (on the origin thread) when the Job finishes.
   // Should only be accessed from origin thread.
   CompletionCallback callback_;
 
   // Flag to indicate whether the request has been cancelled.
@@ skipping 74 matching lines @@
   // read by the origin thread.
   std::string pending_dns_host_;
   ResolveDnsOperation pending_dns_op_;
 
   // This contains the resolved address list that DoDnsOperation() fills in.
   // Used exclusively on the origin thread.
   AddressList pending_dns_addresses_;
 };
 
 ProxyResolverV8Tracing::Job::Job(ProxyResolverV8Tracing* parent)
-    : origin_loop_(base::MessageLoopProxy::current()),
+    : origin_runner_(base::ThreadTaskRunnerHandle::Get()),
       parent_(parent),
       event_(true, false),
       last_num_dns_(0),
       pending_dns_(NULL) {
   CheckIsOnOriginThread();
 }
 
 void ProxyResolverV8Tracing::Job::StartSetPacScript(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     const CompletionCallback& callback) {
@@ skipping 69 matching lines @@
 ProxyResolverV8Tracing::Job::~Job() {
   DCHECK(!pending_dns_);
   DCHECK(callback_.is_null());
 }
 
 void ProxyResolverV8Tracing::Job::CheckIsOnWorkerThread() const {
   DCHECK_EQ(base::MessageLoop::current(), parent_->thread_->message_loop());
 }
 
 void ProxyResolverV8Tracing::Job::CheckIsOnOriginThread() const {
-  DCHECK(origin_loop_->BelongsToCurrentThread());
+  DCHECK(origin_runner_->BelongsToCurrentThread());
 }
 
 void ProxyResolverV8Tracing::Job::SetCallback(
     const CompletionCallback& callback) {
   CheckIsOnOriginThread();
   DCHECK(callback_.is_null());
   parent_->num_outstanding_callbacks_++;
   callback_ = callback;
 }
 
@@ skipping 24 matching lines @@
   return parent_->error_observer_.get();
 }
 
 NetLog* ProxyResolverV8Tracing::Job::net_log() {
   return parent_->net_log_;
 }
 
 void ProxyResolverV8Tracing::Job::NotifyCaller(int result) {
   CheckIsOnWorkerThread();
 
-  origin_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&Job::NotifyCallerOnOriginLoop, this, result));
+  origin_runner_->PostTask(
+      FROM_HERE, base::Bind(&Job::NotifyCallerOnOriginLoop, this, result));
 }
 
 void ProxyResolverV8Tracing::Job::NotifyCallerOnOriginLoop(int result) {
   CheckIsOnOriginThread();
 
   if (cancelled_.IsSet())
     return;
 
   DCHECK(!callback_.is_null());
   DCHECK(!pending_dns_);
@@ skipping 209 matching lines @@
 }
 
 bool ProxyResolverV8Tracing::Job::PostDnsOperationAndWait(
     const std::string& host, ResolveDnsOperation op,
     bool* completed_synchronously) {
 
   // Post the DNS request to the origin thread.
   DCHECK(!pending_dns_);
   pending_dns_host_ = host;
   pending_dns_op_ = op;
-  origin_loop_->PostTask(FROM_HERE, base::Bind(&Job::DoDnsOperation, this));
+  origin_runner_->PostTask(FROM_HERE, base::Bind(&Job::DoDnsOperation, this));
 
   event_.Wait();
   event_.Reset();
 
   if (cancelled_.IsSet())
     return false;
 
   if (completed_synchronously)
     *completed_synchronously = pending_dns_completed_synchronously_;
 
@@ skipping 349 matching lines @@
   DCHECK(!set_pac_script_job_.get());
   CHECK_EQ(0, num_outstanding_callbacks_);
 
   set_pac_script_job_ = new Job(this);
   set_pac_script_job_->StartSetPacScript(script_data, callback);
 
   return ERR_IO_PENDING;
 }
 
 }  // namespace net