Encouraging ThreadTaskRunnerHandle usage in net/dns module

net/dns/host_resolver_impl.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/dns/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
 #endif
 
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/address_family.h"
 #include "net/base/address_list.h"
 #include "net/base/dns_reloader.h"
 #include "net/base/dns_util.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
@@ skipping 525 matching lines @@
   typedef base::Callback<void(int net_error,
                               const AddressList& addr_list)> Callback;
 
   ProcTask(const Key& key,
            const ProcTaskParams& params,
            const Callback& callback,
            const BoundNetLog& job_net_log)
       : key_(key),
         params_(params),
         callback_(callback),
-        origin_loop_(base::MessageLoopProxy::current()),
+        task_runner_(base::ThreadTaskRunnerHandle::Get()),
         attempt_number_(0),
         completed_attempt_number_(0),
         completed_attempt_error_(ERR_UNEXPECTED),
         had_non_speculative_request_(false),
         net_log_(job_net_log) {
     if (!params_.resolver_proc.get())
       params_.resolver_proc = HostResolverProc::GetDefault();
     // If default is unset, use the system proc.
     if (!params_.resolver_proc.get())
       params_.resolver_proc = new SystemHostResolverProc();
   }
 
   void Start() {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
     net_log_.BeginEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK);
     StartLookupAttempt();
   }
 
   // Cancels this ProcTask. It will be orphaned. Any outstanding resolve
   // attempts running on worker threads will continue running. Only once all the
   // attempts complete will the final reference to this ProcTask be released.
   void Cancel() {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
 
     if (was_canceled() || was_completed())
       return;
 
     callback_.Reset();
     net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK);
   }
 
   void set_had_non_speculative_request() {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
     had_non_speculative_request_ = true;
   }
 
   bool was_canceled() const {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
     return callback_.is_null();
   }
 
   bool was_completed() const {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
     return completed_attempt_number_ > 0;
   }
 
  private:
   friend class base::RefCountedThreadSafe<ProcTask>;
   ~ProcTask() {}
 
   void StartLookupAttempt() {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
     base::TimeTicks start_time = base::TimeTicks::Now();
     ++attempt_number_;
     // Dispatch the lookup attempt to a worker thread.
     if (!base::WorkerPool::PostTask(
             FROM_HERE,
             base::Bind(&ProcTask::DoLookup, this, start_time, attempt_number_),
             true)) {
       NOTREACHED();
 
       // Since we could be running within Resolve() right now, we can't just
       // call OnLookupComplete().  Instead we must wait until Resolve() has
       // returned (IO_PENDING).
-      origin_loop_->PostTask(
-          FROM_HERE,
-          base::Bind(&ProcTask::OnLookupComplete, this, AddressList(),
-                     start_time, attempt_number_, ERR_UNEXPECTED, 0));
+      task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&ProcTask::OnLookupComplete,
+                                        this,
+                                        AddressList(),
+                                        start_time,
+                                        attempt_number_,
+                                        ERR_UNEXPECTED,
+                                        0));
       return;
     }
 
     net_log_.AddEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_ATTEMPT_STARTED,
         NetLog::IntegerCallback("attempt_number", attempt_number_));
 
     // If we don't get the results within a given time, RetryIfNotComplete
     // will start a new attempt on a different worker thread if none of our
     // outstanding attempts have completed yet.
     if (attempt_number_ <= params_.max_retry_attempts) {
-      origin_loop_->PostDelayedTask(
+      task_runner_->PostDelayedTask(
           FROM_HERE,
           base::Bind(&ProcTask::RetryIfNotComplete, this),
           params_.unresponsive_delay);
     }
   }
 
   // WARNING: This code runs inside a worker pool. The shutdown code cannot
   // wait for it to finish, so we must be very careful here about using other
   // objects (like MessageLoops, Singletons, etc). During shutdown these objects
   // may no longer exist. Multiple DoLookups() could be running in parallel, so
@@ skipping 13 matching lines @@
     // block of kIcanNameCollisionIp for details on why.
     for (const auto& it : results) {
       const IPAddressNumber& cur = it.address();
       if (cur.size() == arraysize(kIcanNameCollisionIp) &&
           0 == memcmp(&cur.front(), kIcanNameCollisionIp, cur.size())) {
         error = ERR_ICANN_NAME_COLLISION;
         break;
       }
     }
 
-    origin_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&ProcTask::OnLookupComplete, this, results, start_time,
-                   attempt_number, error, os_error));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&ProcTask::OnLookupComplete,
+                                      this,
+                                      results,
+                                      start_time,
+                                      attempt_number,
+                                      error,
+                                      os_error));
   }
 
-  // Makes next attempt if DoLookup() has not finished (runs on origin thread).
+  // Makes next attempt if DoLookup() has not finished (runs on task runner
+  // thread).
   void RetryIfNotComplete() {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
 
     if (was_completed() || was_canceled())
       return;
 
     params_.unresponsive_delay *= params_.retry_factor;
     StartLookupAttempt();
   }
 
-  // Callback for when DoLookup() completes (runs on origin thread).
+  // Callback for when DoLookup() completes (runs on task runner thread).
   void OnLookupComplete(const AddressList& results,
                         const base::TimeTicks& start_time,
                         const uint32 attempt_number,
                         int error,
                         const int os_error) {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
     // If results are empty, we should return an error.
     bool empty_list_on_ok = (error == OK && results.empty());
     UMA_HISTOGRAM_BOOLEAN("DNS.EmptyAddressListAndNoError", empty_list_on_ok);
     if (empty_list_on_ok)
       error = ERR_NAME_NOT_RESOLVED;
 
     bool was_retry_attempt = attempt_number > 1;
 
     // Ideally the following code would be part of host_resolver_proc.cc,
     // however it isn't safe to call NetworkChangeNotifier from worker threads.
@@ skipping 46 matching lines @@
     }
     net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK,
                       net_log_callback);
 
     callback_.Run(error, results_);
   }
 
   void RecordPerformanceHistograms(const base::TimeTicks& start_time,
                                    const int error,
                                    const int os_error) const {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
     enum Category {  // Used in UMA_HISTOGRAM_ENUMERATION.
       RESOLVE_SUCCESS,
       RESOLVE_FAIL,
       RESOLVE_SPECULATIVE_SUCCESS,
       RESOLVE_SPECULATIVE_FAIL,
       RESOLVE_MAX,  // Bounding value.
     };
     int category = RESOLVE_MAX;  // Illegal value for later DCHECK only.
 
     base::TimeDelta duration = base::TimeTicks::Now() - start_time;
@@ skipping 46 matching lines @@
     }
     DCHECK_LT(category, static_cast<int>(RESOLVE_MAX));  // Be sure it was set.
 
     UMA_HISTOGRAM_ENUMERATION("DNS.ResolveCategory", category, RESOLVE_MAX);
   }
 
   void RecordAttemptHistograms(const base::TimeTicks& start_time,
                                const uint32 attempt_number,
                                const int error,
                                const int os_error) const {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
     bool first_attempt_to_complete =
         completed_attempt_number_ == attempt_number;
     bool is_first_attempt = (attempt_number == 1);
 
     if (first_attempt_to_complete) {
       // If this was first attempt to complete, then record the resolution
       // status of the attempt.
       if (completed_attempt_error_ == OK) {
         UMA_HISTOGRAM_ENUMERATION(
             "DNS.AttemptFirstSuccess", attempt_number, 100);
@@ skipping 26 matching lines @@
         UMA_HISTOGRAM_ENUMERATION("DNS.AttemptCancelled", attempt_number, 100);
     }
 
     base::TimeDelta duration = base::TimeTicks::Now() - start_time;
     if (error == OK)
       DNS_HISTOGRAM("DNS.AttemptSuccessDuration", duration);
     else
       DNS_HISTOGRAM("DNS.AttemptFailDuration", duration);
   }
 
-  // Set on the origin thread, read on the worker thread.
+  // Set on the task runner thread, read on the worker thread.
   Key key_;
 
   // Holds an owning reference to the HostResolverProc that we are going to use.
   // This may not be the current resolver procedure by the time we call
   // ResolveAddrInfo, but that's OK... we'll use it anyways, and the owning
   // reference ensures that it remains valid until we are done.
   ProcTaskParams params_;
 
   // The listener to the results of this ProcTask.
   Callback callback_;
 
-  // Used to post ourselves onto the origin thread.
-  scoped_refptr<base::MessageLoopProxy> origin_loop_;
+  // Used to post ourselves onto the task runner thread.

[asanka, 2015/05/14 18:38:40]

.. on to the originating thread.

[anujsharma, 2015/05/20 13:13:16]

Done.

+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // Keeps track of the number of attempts we have made so far to resolve the
   // host. Whenever we start an attempt to resolve the host, we increase this
   // number.
   uint32 attempt_number_;
 
   // The index of the attempt which finished first (or 0 if the job is still in
   // progress).
   uint32 completed_attempt_number_;
 
@@ skipping 41 matching lines @@
   void DoProbe() {
     result_ = HaveOnlyLoopbackAddresses();
   }
 
   void OnProbeComplete() {
     if (!resolver_.get())
       return;
     resolver_->SetHaveOnlyLoopbackAddresses(result_);
   }
 
-  // Used/set only on origin thread.
+  // Used/set only on task runner thread.
   base::WeakPtr<HostResolverImpl> resolver_;
 
   bool result_;
 
   DISALLOW_COPY_AND_ASSIGN(LoopbackProbeJob);
 };
 
 //-----------------------------------------------------------------------------
 
 // Resolves the hostname using DnsTransaction.
@@ skipping 1412 matching lines @@
     dns_client_->SetConfig(dns_config);
     num_dns_failures_ = 0;
     if (dns_client_->GetConfig())
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
   }
 
   AbortDnsTasks();
 }
 
 }  // namespace net