Create base::WorkerPoolJob. Use it for HostResolverImpl and DirectoryLister.

net/base/host_resolver_impl.cc

 // Copyright (c) 2010 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/base/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
 #endif
 
 #include <cmath>
 #include <deque>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "base/worker_pool.h"
+#include "base/worker_pool_job.h"
 #include "net/base/address_list.h"
 #include "net/base/address_list_net_log_param.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/host_resolver_proc.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
@@ skipping 290 matching lines @@
 
 //------------------------------------------------------------------------------
 
 // Provide a common macro to simplify code and readability. We must use a
 // macros as the underlying HISTOGRAM macro creates static varibles.
 #define DNS_HISTOGRAM(name, time) UMA_HISTOGRAM_CUSTOM_TIMES(name, time, \
     base::TimeDelta::FromMicroseconds(1), base::TimeDelta::FromHours(1), 100)
 
 // This class represents a request to the worker pool for a "getaddrinfo()"
 // call.
-class HostResolverImpl::Job
-    : public base::RefCountedThreadSafe<HostResolverImpl::Job> {
+class HostResolverImpl::Job : public base::WorkerPoolJob {
  public:
   Job(int id,
       HostResolverImpl* resolver,
       const Key& key,
       const BoundNetLog& source_net_log,
       NetLog* net_log)
      : id_(id),
        key_(key),
        resolver_(resolver),
-       origin_loop_(MessageLoop::current()),
        resolver_proc_(resolver->effective_resolver_proc()),
        error_(OK),
        os_error_(0),
        had_non_speculative_request_(false),
        net_log_(BoundNetLog::Make(net_log,
                                   NetLog::SOURCE_HOST_RESOLVER_IMPL_JOB)) {
     net_log_.BeginEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
         make_scoped_refptr(
             new JobCreationParameters(key.hostname, source_net_log.source())));
@@ skipping 11 matching lines @@
     requests_.push_back(req);
 
     if (!req->info().is_speculative())
       had_non_speculative_request_ = true;
   }
 
   // Called from origin loop.
   void Start() {
     start_time_ = base::TimeTicks::Now();
 
-    // Dispatch the job to a worker thread.
-    if (!WorkerPool::PostTask(FROM_HERE,
-            NewRunnableMethod(this, &Job::DoLookup), 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).
-      error_ = ERR_UNEXPECTED;
-      MessageLoop::current()->PostTask(
-          FROM_HERE, NewRunnableMethod(this, &Job::OnLookupComplete));
-    }
+    StartJob();
   }
 
   // Cancels the current job. Callable from origin thread.
   void Cancel() {
+    if (canceled())
+      return;
+
+    CancelJob();
+
     net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
 
-    HostResolver* resolver = resolver_;
-    resolver_ = NULL;
-
-    // Mark the job as cancelled, so when worker thread completes it will
-    // not try to post completion to origin loop.
-    {
-      AutoLock locked(origin_loop_lock_);
-      origin_loop_ = NULL;
-    }
-
     // End here to prevent issues when a Job outlives the HostResolver that
     // spawned it.
     net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB, NULL);
 
     // We will call HostResolverImpl::CancelRequest(Request*) on each one
     // in order to notify any observers.
     for (RequestsList::const_iterator it = requests_.begin();
          it != requests_.end(); ++it) {
       HostResolverImpl::Request* req = *it;
       if (!req->was_cancelled())
-        resolver->CancelRequest(req);
+        resolver_->CancelRequest(req);
     }
   }
 
   // Called from origin thread.
-  bool was_cancelled() const {
-    return resolver_ == NULL;
-  }
-
-  // Called from origin thread.
   const Key& key() const {
     return key_;
   }
 
   int id() const {
     return id_;
   }
 
   base::TimeTicks start_time() const {
     return start_time_;
   }
 
   // Called from origin thread.
   const RequestsList& requests() const {
     return requests_;
   }
 
   // Returns the first request attached to the job.
   const Request* initial_request() const {
-    DCHECK_EQ(origin_loop_, MessageLoop::current());
     DCHECK(!requests_.empty());
     return requests_[0];
   }
 
   // Returns true if |req_info| can be fulfilled by this job.
   bool CanServiceRequest(const RequestInfo& req_info) const {
     return key_ == resolver_->GetEffectiveKeyForRequest(req_info);
   }
 
+  // TODO(willchan): Eliminate the need for this.
+  using WorkerPoolJob::canceled;
+
  private:
   friend class base::RefCountedThreadSafe<HostResolverImpl::Job>;
 
   ~Job() {
     // Free the requests attached to this job.
     STLDeleteElements(&requests_);
   }
 
   // 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.
-  void DoLookup() {
+  virtual void RunJob() {
     // Running on the worker thread
     error_ = ResolveAddrInfo(resolver_proc_,
                              key_.hostname,
                              key_.address_family,
                              key_.host_resolver_flags,
                              &results_,
                              &os_error_);
-
-    // The origin loop could go away while we are trying to post to it, so we
-    // need to call its PostTask method inside a lock.  See ~HostResolver.
-    {
-      AutoLock locked(origin_loop_lock_);
-      if (origin_loop_) {
-        origin_loop_->PostTask(FROM_HERE,
-                               NewRunnableMethod(this, &Job::OnLookupComplete));
-      }
-    }
   }
 
-  // Callback for when DoLookup() completes (runs on origin thread).
-  void OnLookupComplete() {
-    // Should be running on origin loop.
-    // TODO(eroman): this is being hit by URLRequestTest.CancelTest*,
-    // because MessageLoop::current() == NULL.
-    //DCHECK_EQ(origin_loop_, MessageLoop::current());
+  // Callback for when RunJob() completes (runs on origin thread).
+  virtual void CompleteJob() {
     DCHECK(error_ || results_.head());
 
     // Ideally the following code would be part of host_resolver_proc.cc,
     // however it isn't safe to call NetworkChangeNotifier from worker
     // threads. So we do it here on the IO thread instead.
     if (error_ != OK && NetworkChangeNotifier::IsOffline())
       error_ = ERR_INTERNET_DISCONNECTED;
 
     RecordPerformanceHistograms();
 
-    if (was_cancelled())
-      return;
-
     scoped_refptr<NetLog::EventParameters> params;
     if (error_ != OK) {
       params = new HostResolveFailedParams(error_, os_error_);
     } else {
       params = new AddressListNetLogParam(results_);
     }
 
     // End here to prevent issues when a Job outlives the HostResolver that
     // spawned it.
     net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB, params);
@@ skipping 61 matching lines @@
       UMA_HISTOGRAM_ENUMERATION(
           base::FieldTrial::MakeName("DNS.ResolveCategory", "DnsParallelism"),
           category, RESOLVE_MAX);
       if (RESOLVE_SUCCESS == category) {
         DNS_HISTOGRAM(base::FieldTrial::MakeName("DNS.ResolveSuccess",
                                                  "DnsParallelism"), duration);
       }
     }
   }
 
-
-
   // Immutable. Can be read from either thread,
   const int id_;
 
   // Set on the origin thread, read on the worker thread.
   Key key_;
 
   // Only used on the origin thread (where Resolve was called).
   HostResolverImpl* resolver_;
   RequestsList requests_;  // The requests waiting on this job.
 
-  // Used to post ourselves onto the origin thread.
-  Lock origin_loop_lock_;
-  MessageLoop* origin_loop_;
-
   // Hold 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.
   scoped_refptr<HostResolverProc> resolver_proc_;
 
   // Assigned on the worker thread, read on the origin thread.
   int error_;
   int os_error_;
 
@@ skipping 10 matching lines @@
 
   BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 //-----------------------------------------------------------------------------
 
 // This class represents a request to the worker pool for a "probe for IPv6
 // support" call.
-class HostResolverImpl::IPv6ProbeJob
-    : public base::RefCountedThreadSafe<HostResolverImpl::IPv6ProbeJob> {
+class HostResolverImpl::IPv6ProbeJob : public base::WorkerPoolJob {
  public:
   explicit IPv6ProbeJob(HostResolverImpl* resolver)
       : resolver_(resolver),
-        origin_loop_(MessageLoop::current()) {
-    DCHECK(!was_cancelled());
+        address_family_(ADDRESS_FAMILY_UNSPECIFIED) {
+    DCHECK(resolver_);
   }
 
-  void Start() {
-    if (was_cancelled())
-      return;
-    DCHECK(IsOnOriginThread());
-    const bool kIsSlow = true;
-    WorkerPool::PostTask(
-        FROM_HERE, NewRunnableMethod(this, &IPv6ProbeJob::DoProbe), kIsSlow);
-  }
-
-  // Cancels the current job.
-  void Cancel() {
-    if (was_cancelled())
-      return;
-    DCHECK(IsOnOriginThread());
-    resolver_ = NULL;  // Read/write ONLY on origin thread.
-    {
-      AutoLock locked(origin_loop_lock_);
-      // Origin loop may be destroyed before we can use it!
-      origin_loop_ = NULL;  // Write ONLY on origin thread.
-    }
-  }
+  void Start() { StartJob(); }
+  void Cancel() { CancelJob(); }
 
  private:
   friend class base::RefCountedThreadSafe<HostResolverImpl::IPv6ProbeJob>;
 
   ~IPv6ProbeJob() {
   }
 
-  // Should be run on |orgin_thread_|, but that may not be well defined now.
-  bool was_cancelled() const {
-    if (!resolver_ || !origin_loop_) {
-      DCHECK(!resolver_);
-      DCHECK(!origin_loop_);
-      return true;
-    }
-    return false;
-  }
-
   // Run on worker thread.
-  void DoProbe() {
+  virtual void RunJob() {
     // Do actual testing on this thread, as it takes 40-100ms.
-    AddressFamily family = IPv6Supported() ? ADDRESS_FAMILY_UNSPECIFIED
-                                           : ADDRESS_FAMILY_IPV4;
-
-    Task* reply = NewRunnableMethod(this, &IPv6ProbeJob::OnProbeComplete,
-                                    family);
-
-    // The origin loop could go away while we are trying to post to it, so we
-    // need to call its PostTask method inside a lock.  See ~HostResolver.
-    {
-      AutoLock locked(origin_loop_lock_);
-      if (origin_loop_) {
-        origin_loop_->PostTask(FROM_HERE, reply);
-        return;
-      }
-    }
-
-    // We didn't post, so delete the reply.
-    delete reply;
+    address_family_ = IPv6Supported() ? ADDRESS_FAMILY_UNSPECIFIED
+                                      : ADDRESS_FAMILY_IPV4;
   }
 
   // Callback for when DoProbe() completes (runs on origin thread).
-  void OnProbeComplete(AddressFamily address_family) {
-    if (was_cancelled())
-      return;
-    DCHECK(IsOnOriginThread());
-    resolver_->IPv6ProbeSetDefaultAddressFamily(address_family);
-  }
-
-  bool IsOnOriginThread() const {
-    return !MessageLoop::current() || origin_loop_ == MessageLoop::current();
+  virtual void CompleteJob() {
+    resolver_->IPv6ProbeSetDefaultAddressFamily(address_family_);
   }
 
   // Used/set only on origin thread.
-  HostResolverImpl* resolver_;
+  HostResolverImpl* const resolver_;
 
-  // Used to post ourselves onto the origin thread.
-  Lock origin_loop_lock_;
-  MessageLoop* origin_loop_;
+  AddressFamily address_family_;
 
   DISALLOW_COPY_AND_ASSIGN(IPv6ProbeJob);
 };
 
 //-----------------------------------------------------------------------------
 
 // We rely on the priority enum values being sequential having starting at 0,
 // and increasing for lower priorities.
 COMPILE_ASSERT(HIGHEST == 0u &&
                LOWEST > HIGHEST &&
@@ skipping 486 matching lines @@
           NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_ATTACH, NULL);
 
       // Update the net log and notify registered observers.
       OnFinishRequest(req->source_net_log(), req->request_net_log(), req->id(),
                       req->info(), net_error, os_error);
 
       req->OnComplete(net_error, addrlist);
 
       // Check if the job was cancelled as a result of running the callback.
       // (Meaning that |this| was deleted).
-      if (job->was_cancelled())
+      if (job->canceled())
         return;
     }
   }
 
   cur_completing_job_ = NULL;
 }
 
 void HostResolverImpl::OnStartRequest(const BoundNetLog& source_net_log,
                                       const BoundNetLog& request_net_log,
                                       int request_id,
@@ skipping 208 matching lines @@
     job_pools_[i]->ResetNumOutstandingJobs();
   JobMap jobs;
   jobs.swap(jobs_);
   for (JobMap::iterator it = jobs.begin(); it != jobs.end(); ++it) {
     AbortJob(it->second);
     it->second->Cancel();
   }
 }
 
 }  // namespace net