Add ProxyResolverFactoryV8Tracing.

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 <map>
+#include <string>
+#include <vector>
+
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/waitable_event.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"
@@ skipping 39 matching lines @@
 // Returns event parameters for a PAC error message (line number + message).
 base::Value* NetLogErrorCallback(int line_number,
                                  const base::string16* message,
                                  NetLogCaptureMode /* capture_mode */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("line_number", line_number);
   dict->SetString("message", *message);
   return dict;
 }
 
-}  // namespace
-
 // The Job class is responsible for executing GetProxyForURL() and
 // SetPacScript(), since both of these operations share similar code.

[eroman, 2015/05/05 00:04:55]

SetPacScript() no longer applies. please change this comment.

[Sam McNally, 2015/05/05 01:31:36]

Done.

 //
 // The DNS for these operations can operate in either blocking or
 // non-blocking mode. Blocking mode is used as a fallback when the PAC script
 // seems to be misbehaving under the tracing optimization.
 //
 // Note that this class runs on both the origin thread and a worker
 // thread. Most methods are expected to be used exclusively on one thread
 // or the other.
 //
 // The lifetime of Jobs does not exceed that of the ProxyResolverV8Tracing that
 // spawned it. Destruction might happen on either the origin thread or the
 // worker thread.
-class ProxyResolverV8Tracing::Job
-    : public base::RefCountedThreadSafe<ProxyResolverV8Tracing::Job>,
-      public ProxyResolverV8::JSBindings {
+class Job : public base::RefCountedThreadSafe<Job>,
+            public ProxyResolverV8::JSBindings {
  public:
+  struct Params {
+    Params(
+        const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
+        HostResolver* host_resolver,
+        ProxyResolverErrorObserver* error_observer,
+        NetLog* net_log,
+        ProxyResolver::LoadStateChangedCallback on_load_state_changed,
+        int* num_outstanding_callbacks)
+        : v8_resolver(nullptr),
+          worker_task_runner(worker_task_runner),
+          host_resolver(host_resolver),
+          error_observer(error_observer),
+          net_log(net_log),
+          on_load_state_changed(on_load_state_changed),
+          num_outstanding_callbacks(num_outstanding_callbacks) {}
+
+    ProxyResolverV8* v8_resolver;
+    scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner;
+    HostResolver* host_resolver;
+    ProxyResolverErrorObserver* error_observer;
+    NetLog* net_log;
+    ProxyResolver::LoadStateChangedCallback on_load_state_changed;
+    int* num_outstanding_callbacks;
+  };
   // |parent| is non-owned. It is the ProxyResolverV8Tracing that spawned this
   // Job, and must oulive it.
-  explicit Job(ProxyResolverV8Tracing* parent);
+  explicit Job(const Params* params);
 
   // Called from origin thread.
-  void StartSetPacScript(
+  void StartCreateV8Resolver(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
+      scoped_ptr<ProxyResolverV8>* resolver,
       const CompletionCallback& callback);
 
   // Called from origin thread.
   void StartGetProxyForURL(const GURL& url,
                            ProxyInfo* results,
                            const BoundNetLog& net_log,
                            const CompletionCallback& callback);
 
   // Called from origin thread.
   void Cancel();
 
   // Called from origin thread.
   LoadState GetLoadState() const;
 
  private:
   typedef std::map<std::string, std::string> DnsCache;
-  friend class base::RefCountedThreadSafe<ProxyResolverV8Tracing::Job>;
+  friend class base::RefCountedThreadSafe<Job>;
 
   enum Operation {
-    SET_PAC_SCRIPT,
+    CREATE_V8_RESOLVER,
     GET_PROXY_FOR_URL,
   };
 
   struct AlertOrError {
     bool is_alert;
     int line_number;
     base::string16 message;
   };
 
   ~Job() override;
 
   void CheckIsOnWorkerThread() const;
   void CheckIsOnOriginThread() const;
 
   void SetCallback(const CompletionCallback& callback);
   void ReleaseCallback();
 
   ProxyResolverV8* v8_resolver();
-  base::MessageLoop* worker_loop();
+  const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner();
   HostResolver* host_resolver();
   ProxyResolverErrorObserver* error_observer();
   NetLog* net_log();
 
   // Invokes the user's callback.
   void NotifyCaller(int result);
   void NotifyCallerOnOriginLoop(int result);
 
   void Start(Operation op, bool blocking_dns,
              const CompletionCallback& callback);
@@ skipping 55 matching lines @@
   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_;
 
   // The ProxyResolverV8Tracing which spawned this Job.
   // Initialized on origin thread and then accessed from both threads.
-  ProxyResolverV8Tracing* parent_;
+  const Params* const params_;
 
   // 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.
   base::CancellationFlag cancelled_;
 
   // The operation that this Job is running.
   // Initialized on origin thread and then accessed from both threads.
@@ skipping 10 matching lines @@
 
   // Map of DNS operations completed so far. Written into on the origin thread
   // and read on the worker thread.
   DnsCache dns_cache_;
 
   // The job holds a reference to itself to ensure that it remains alive until
   // either completion or cancellation.
   scoped_refptr<Job> owned_self_reference_;
 
   // -------------------------------------------------------
-  // State specific to SET_PAC_SCRIPT.
+  // State specific to CREATE_V8_RESOLVER.
   // -------------------------------------------------------
 
   scoped_refptr<ProxyResolverScriptData> script_data_;
+  scoped_ptr<ProxyResolverV8>* resolver_out_;
 
   // -------------------------------------------------------
   // State specific to GET_PROXY_FOR_URL.
   // -------------------------------------------------------
 
   ProxyInfo* user_results_;  // Owned by caller, lives on origin thread.
   GURL url_;
   ProxyInfo results_;
   BoundNetLog bound_net_log_;
 
@@ skipping 35 matching lines @@
   // These are the inputs to DoDnsOperation(). Written on the worker thread,
   // 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)
+class ProxyResolverV8Tracing : public ProxyResolver,
+                               public base::NonThreadSafe {
+ public:
+  // Constructs a ProxyResolver that will issue DNS requests through
+  // |job_params->host_resolver|, forward Javascript errors through
+  // |error_observer|, and log Javascript errors and alerts to
+  // |job_params->net_log|. When the LoadState for a request changes,
+  // |job_params->on_load_state_changed| will be invoked with the RequestHandle
+  // for that request with the new LoadState.
+  //
+  // Note that the constructor takes ownership of |error_observer|, whereas
+  // |job_params->host_resolver| and |job_params->net_log| are expected to
+  // outlive |this|.
+  ProxyResolverV8Tracing(scoped_ptr<ProxyResolverErrorObserver> error_observer,
+                         scoped_ptr<base::Thread> thread,
+                         scoped_ptr<ProxyResolverV8> resolver,
+                         scoped_ptr<Job::Params> job_params);
+
+  ~ProxyResolverV8Tracing() override;
+
+  // ProxyResolver implementation:
+  int GetProxyForURL(const GURL& url,
+                     ProxyInfo* results,
+                     const CompletionCallback& callback,
+                     RequestHandle* request,
+                     const BoundNetLog& net_log) override;
+  void CancelRequest(RequestHandle request) override;
+  LoadState GetLoadState(RequestHandle request) const override;
+  void CancelSetPacScript() override;
+  int SetPacScript(const scoped_refptr<ProxyResolverScriptData>& script_data,
+                   const CompletionCallback& callback) override;
+
+ private:
+  // The worker thread on which the ProxyResolverV8 will be run.
+  scoped_ptr<base::Thread> thread_;
+  scoped_ptr<ProxyResolverV8> v8_resolver_;
+
+  scoped_ptr<ProxyResolverErrorObserver> error_observer_;
+
+  scoped_ptr<Job::Params> job_params_;
+
+  // The number of outstanding (non-cancelled) jobs.
+  int num_outstanding_callbacks_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProxyResolverV8Tracing);
+};
+
+Job::Job(const Job::Params* params)
     : origin_loop_(base::MessageLoopProxy::current()),
-      parent_(parent),
+      params_(params),
       event_(true, false),
       last_num_dns_(0),
       pending_dns_(NULL) {
   CheckIsOnOriginThread();
 }
 
-void ProxyResolverV8Tracing::Job::StartSetPacScript(
+void Job::StartCreateV8Resolver(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
+    scoped_ptr<ProxyResolverV8>* resolver,
     const CompletionCallback& callback) {
   CheckIsOnOriginThread();
 
+  resolver_out_ = resolver;
   script_data_ = script_data;
 
   // Script initialization uses blocking DNS since there isn't any
   // advantage to using non-blocking mode here. That is because the
   // parent ProxyService can't submit any ProxyResolve requests until
   // initialization has completed successfully!
-  Start(SET_PAC_SCRIPT, true /*blocking*/, callback);
+  Start(CREATE_V8_RESOLVER, true /*blocking*/, callback);
 }
 
-void ProxyResolverV8Tracing::Job::StartGetProxyForURL(
-    const GURL& url,
-    ProxyInfo* results,
-    const BoundNetLog& net_log,
-    const CompletionCallback& callback) {
+void Job::StartGetProxyForURL(const GURL& url,
+                              ProxyInfo* results,
+                              const BoundNetLog& net_log,
+                              const CompletionCallback& callback) {
   CheckIsOnOriginThread();
 
   url_ = url;
   user_results_ = results;
   bound_net_log_ = net_log;
 
   Start(GET_PROXY_FOR_URL, false /*non-blocking*/, callback);
 }
 
-void ProxyResolverV8Tracing::Job::Cancel() {
+void Job::Cancel() {
   CheckIsOnOriginThread();
 
   // There are several possibilities to consider for cancellation:
   // (a) The job has been posted to the worker thread, however script execution
   //     has not yet started.
   // (b) The script is executing on the worker thread.
   // (c) The script is executing on the worker thread, however is blocked inside
   //     of dnsResolve() waiting for a response from the origin thread.
   // (d) Nothing is running on the worker thread, however the host resolver has
   //     a pending DNS request which upon completion will restart the script
@@ skipping 14 matching lines @@
     host_resolver()->CancelRequest(pending_dns_);
     pending_dns_ = NULL;
   }
 
   // The worker thread might be blocked waiting for DNS.
   event_.Signal();
 
   owned_self_reference_ = NULL;
 }
 
-LoadState ProxyResolverV8Tracing::Job::GetLoadState() const {
+LoadState Job::GetLoadState() const {
   CheckIsOnOriginThread();
 
   if (pending_dns_)
     return LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT;
 
   return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
 }
 
-ProxyResolverV8Tracing::Job::~Job() {
+Job::~Job() {
   DCHECK(!pending_dns_);
   DCHECK(callback_.is_null());
 }
 
-void ProxyResolverV8Tracing::Job::CheckIsOnWorkerThread() const {
-  DCHECK_EQ(base::MessageLoop::current(), parent_->thread_->message_loop());
+void Job::CheckIsOnWorkerThread() const {
+  DCHECK(params_->worker_task_runner->BelongsToCurrentThread());
 }
 
-void ProxyResolverV8Tracing::Job::CheckIsOnOriginThread() const {
+void Job::CheckIsOnOriginThread() const {
   DCHECK(origin_loop_->BelongsToCurrentThread());
 }
 
-void ProxyResolverV8Tracing::Job::SetCallback(
-    const CompletionCallback& callback) {
+void Job::SetCallback(const CompletionCallback& callback) {
   CheckIsOnOriginThread();
   DCHECK(callback_.is_null());
-  parent_->num_outstanding_callbacks_++;
+  (*params_->num_outstanding_callbacks)++;
   callback_ = callback;
 }
 
-void ProxyResolverV8Tracing::Job::ReleaseCallback() {
+void Job::ReleaseCallback() {
   CheckIsOnOriginThread();
   DCHECK(!callback_.is_null());
-  CHECK_GT(parent_->num_outstanding_callbacks_, 0);
-  parent_->num_outstanding_callbacks_--;
+  CHECK_GT(*params_->num_outstanding_callbacks, 0);
+  (*params_->num_outstanding_callbacks)--;
   callback_.Reset();
 
   // For good measure, clear this other user-owned pointer.
   user_results_ = NULL;
 }
 
-ProxyResolverV8* ProxyResolverV8Tracing::Job::v8_resolver() {
-  return parent_->v8_resolver_.get();
+ProxyResolverV8* Job::v8_resolver() {
+  return params_->v8_resolver;
 }
 
-base::MessageLoop* ProxyResolverV8Tracing::Job::worker_loop() {
-  return parent_->thread_->message_loop();
+const scoped_refptr<base::SingleThreadTaskRunner>& Job::worker_task_runner() {
+  return params_->worker_task_runner;
 }
 
-HostResolver* ProxyResolverV8Tracing::Job::host_resolver() {
-  return parent_->host_resolver_;
+HostResolver* Job::host_resolver() {
+  return params_->host_resolver;
 }
 
-ProxyResolverErrorObserver* ProxyResolverV8Tracing::Job::error_observer() {
-  return parent_->error_observer_.get();
+ProxyResolverErrorObserver* Job::error_observer() {
+  return params_->error_observer;
 }
 
-NetLog* ProxyResolverV8Tracing::Job::net_log() {
-  return parent_->net_log_;
+NetLog* Job::net_log() {
+  return params_->net_log;
 }
 
-void ProxyResolverV8Tracing::Job::NotifyCaller(int result) {
+void Job::NotifyCaller(int result) {
   CheckIsOnWorkerThread();
 
   origin_loop_->PostTask(
       FROM_HERE,
       base::Bind(&Job::NotifyCallerOnOriginLoop, this, result));
 }
 
-void ProxyResolverV8Tracing::Job::NotifyCallerOnOriginLoop(int result) {
+void Job::NotifyCallerOnOriginLoop(int result) {
   CheckIsOnOriginThread();
 
   if (cancelled_.IsSet())
     return;
 
   DCHECK(!callback_.is_null());
   DCHECK(!pending_dns_);
 
   if (operation_ == GET_PROXY_FOR_URL) {
     *user_results_ = results_;
   }
 
-  // There is only ever 1 outstanding SET_PAC_SCRIPT job. It needs to be
-  // tracked to support cancellation.
-  if (operation_ == SET_PAC_SCRIPT) {
-    DCHECK_EQ(parent_->set_pac_script_job_.get(), this);
-    parent_->set_pac_script_job_ = NULL;
-  }
-
   CompletionCallback callback = callback_;
   ReleaseCallback();
   callback.Run(result);
 
   owned_self_reference_ = NULL;
 }
 
-void ProxyResolverV8Tracing::Job::Start(Operation op, bool blocking_dns,
-                                        const CompletionCallback& callback) {
+void Job::Start(Operation op,
+                bool blocking_dns,
+                const CompletionCallback& callback) {
   CheckIsOnOriginThread();
 
   operation_ = op;
   blocking_dns_ = blocking_dns;
   SetCallback(callback);
 
   owned_self_reference_ = this;
 
-  worker_loop()->PostTask(FROM_HERE,
-      blocking_dns_ ? base::Bind(&Job::ExecuteBlocking, this) :
-                      base::Bind(&Job::ExecuteNonBlocking, this));
+  worker_task_runner()->PostTask(
+      FROM_HERE, blocking_dns_ ? base::Bind(&Job::ExecuteBlocking, this)
+                               : base::Bind(&Job::ExecuteNonBlocking, this));
 }
 
-void ProxyResolverV8Tracing::Job::ExecuteBlocking() {
+void Job::ExecuteBlocking() {
   CheckIsOnWorkerThread();
   DCHECK(blocking_dns_);
 
   if (cancelled_.IsSet())
     return;
 
   NotifyCaller(ExecuteProxyResolver());
 }
 
-void ProxyResolverV8Tracing::Job::ExecuteNonBlocking() {
+void Job::ExecuteNonBlocking() {
   CheckIsOnWorkerThread();
   DCHECK(!blocking_dns_);
 
   if (cancelled_.IsSet())
     return;
 
   // Reset state for the current execution.
   abandoned_ = false;
   num_dns_ = 0;
   alerts_and_errors_.clear();
@@ skipping 10 matching lines @@
     return;
   }
 
   if (abandoned_)
     return;
 
   DispatchBufferedAlertsAndErrors();
   NotifyCaller(result);
 }
 
-int ProxyResolverV8Tracing::Job::ExecuteProxyResolver() {
-  JSBindings* prev_bindings = v8_resolver()->js_bindings();
-  v8_resolver()->set_js_bindings(this);
-
+int Job::ExecuteProxyResolver() {
   int result = ERR_UNEXPECTED;  // Initialized to silence warnings.
 
   switch (operation_) {
-    case SET_PAC_SCRIPT:
-      result = v8_resolver()->SetPacScript(
-          script_data_, CompletionCallback());
+    case CREATE_V8_RESOLVER: {
+      scoped_ptr<ProxyResolverV8> resolver(new ProxyResolverV8);
+      resolver->set_js_bindings(this);
+      result = resolver->SetPacScript(script_data_, CompletionCallback());
+      resolver->set_js_bindings(nullptr);
+      if (result == OK)
+        *resolver_out_ = resolver.Pass();
       break;
-    case GET_PROXY_FOR_URL:
+    }
+    case GET_PROXY_FOR_URL: {
+      JSBindings* prev_bindings = v8_resolver()->js_bindings();
+      v8_resolver()->set_js_bindings(this);
+
       result = v8_resolver()->GetProxyForURL(
         url_,
         // Important: Do not write directly into |user_results_|, since if the
         // request were to be cancelled from the origin thread, must guarantee
         // that |user_results_| is not accessed anymore.
         &results_,
         CompletionCallback(),
         NULL,
         bound_net_log_);
+      v8_resolver()->set_js_bindings(prev_bindings);
       break;
+    }
   }
 
-  v8_resolver()->set_js_bindings(prev_bindings);
-
   return result;
 }
 
-bool ProxyResolverV8Tracing::Job::ResolveDns(const std::string& host,
-                                             ResolveDnsOperation op,
-                                             std::string* output,
-                                             bool* terminate) {
+bool Job::ResolveDns(const std::string& host,
+                     ResolveDnsOperation op,
+                     std::string* output,
+                     bool* terminate) {
   if (cancelled_.IsSet()) {
     *terminate = true;
     return false;
   }
 
   if ((op == DNS_RESOLVE || op == DNS_RESOLVE_EX) && host.empty()) {
     // a DNS resolve with an empty hostname is considered an error.
     return false;
   }
 
   return blocking_dns_ ?
       ResolveDnsBlocking(host, op, output) :
       ResolveDnsNonBlocking(host, op, output, terminate);
 }
 
-void ProxyResolverV8Tracing::Job::Alert(const base::string16& message) {
+void Job::Alert(const base::string16& message) {
   HandleAlertOrError(true, -1, message);
 }
 
-void ProxyResolverV8Tracing::Job::OnError(int line_number,
-                                          const base::string16& error) {
+void Job::OnError(int line_number, const base::string16& error) {
   HandleAlertOrError(false, line_number, error);
 }
 
-bool ProxyResolverV8Tracing::Job::ResolveDnsBlocking(const std::string& host,
-                                                     ResolveDnsOperation op,
-                                                     std::string* output) {
+bool Job::ResolveDnsBlocking(const std::string& host,
+                             ResolveDnsOperation op,
+                             std::string* output) {
   CheckIsOnWorkerThread();
 
   // Check if the DNS result for this host has already been cached.
   bool rv;
   if (GetDnsFromLocalCache(host, op, output, &rv)) {
     // Yay, cache hit!
     return rv;
   }
 
   if (dns_cache_.size() >= kMaxUniqueResolveDnsPerExec) {
     // Safety net for scripts with unexpectedly many DNS calls.
     // We will continue running to completion, but will fail every
     // subsequent DNS request.
     return false;
   }
 
   if (!PostDnsOperationAndWait(host, op, NULL))
     return false;  // Was cancelled.
 
   CHECK(GetDnsFromLocalCache(host, op, output, &rv));
   return rv;
 }
 
-bool ProxyResolverV8Tracing::Job::ResolveDnsNonBlocking(const std::string& host,
-                                                        ResolveDnsOperation op,
-                                                        std::string* output,
-                                                        bool* terminate) {
+bool Job::ResolveDnsNonBlocking(const std::string& host,
+                                ResolveDnsOperation op,
+                                std::string* output,
+                                bool* terminate) {
   CheckIsOnWorkerThread();
 
   if (abandoned_) {
     // If this execution was already abandoned can fail right away. Only 1 DNS
     // dependency will be traced at a time (for more predictable outcomes).
     return false;
   }
 
   num_dns_ += 1;
 
@@ skipping 29 matching lines @@
 
   // Otherwise if the result was not in the cache, then a DNS request has
   // been started. Abandon this invocation of FindProxyForURL(), it will be
   // restarted once the DNS request completes.
   abandoned_ = true;
   *terminate = true;
   last_num_dns_ = num_dns_;
   return false;
 }
 
-bool ProxyResolverV8Tracing::Job::PostDnsOperationAndWait(
-    const std::string& host, ResolveDnsOperation op,
-    bool* completed_synchronously) {
-
+bool 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));
 
   event_.Wait();
   event_.Reset();
 
   if (cancelled_.IsSet())
     return false;
 
   if (completed_synchronously)
     *completed_synchronously = pending_dns_completed_synchronously_;
 
   return true;
 }
 
-void ProxyResolverV8Tracing::Job::DoDnsOperation() {
+void Job::DoDnsOperation() {
   CheckIsOnOriginThread();
   DCHECK(!pending_dns_);
 
   if (cancelled_.IsSet())
     return;
 
   HostResolver::RequestHandle dns_request = NULL;
   int result = host_resolver()->Resolve(
       MakeDnsRequestInfo(pending_dns_host_, pending_dns_op_),
       DEFAULT_PRIORITY,
@@ skipping 11 matching lines @@
     if (!pending_dns_completed_synchronously_)
       host_resolver()->CancelRequest(dns_request);
     return;
   }
 
   if (pending_dns_completed_synchronously_) {
     OnDnsOperationComplete(result);
   } else {
     DCHECK(dns_request);
     pending_dns_ = dns_request;
-    if (!parent_->on_load_state_changed_.is_null()) {
-      parent_->on_load_state_changed_.Run(
+    if (!params_->on_load_state_changed.is_null()) {
+      params_->on_load_state_changed.Run(
           this, LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT);
     }
     // OnDnsOperationComplete() will be called by host resolver on completion.
   }
 
   if (!blocking_dns_) {
     // The worker thread always blocks waiting to see if the result can be
     // serviced from cache before restarting.
     event_.Signal();
   }
 }
 
-void ProxyResolverV8Tracing::Job::OnDnsOperationComplete(int result) {
+void Job::OnDnsOperationComplete(int result) {
   CheckIsOnOriginThread();
 
   DCHECK(!cancelled_.IsSet());
   DCHECK(pending_dns_completed_synchronously_ == (pending_dns_ == NULL));
 
   SaveDnsToLocalCache(pending_dns_host_, pending_dns_op_, result,
                       pending_dns_addresses_);
   pending_dns_ = NULL;
 
-  if (!parent_->on_load_state_changed_.is_null() &&
+  if (!params_->on_load_state_changed.is_null() &&
       !pending_dns_completed_synchronously_ && !cancelled_.IsSet()) {
-    parent_->on_load_state_changed_.Run(this,
-                                        LOAD_STATE_RESOLVING_PROXY_FOR_URL);
+    params_->on_load_state_changed.Run(this,
+                                       LOAD_STATE_RESOLVING_PROXY_FOR_URL);
   }
 
   if (blocking_dns_) {
     event_.Signal();
     return;
   }
 
   if (!blocking_dns_ && !pending_dns_completed_synchronously_) {
     // Restart. This time it should make more progress due to having
     // cached items.
-    worker_loop()->PostTask(FROM_HERE,
-                            base::Bind(&Job::ExecuteNonBlocking, this));
+    worker_task_runner()->PostTask(FROM_HERE,
+                                   base::Bind(&Job::ExecuteNonBlocking, this));
   }
 }
 
-void ProxyResolverV8Tracing::Job::ScheduleRestartWithBlockingDns() {
+void Job::ScheduleRestartWithBlockingDns() {
   CheckIsOnWorkerThread();
 
   DCHECK(!should_restart_with_blocking_dns_);
   DCHECK(!abandoned_);
   DCHECK(!blocking_dns_);
 
   abandoned_ = true;
 
   // The restart will happen after ExecuteNonBlocking() finishes.
   should_restart_with_blocking_dns_ = true;
 }
 
-bool ProxyResolverV8Tracing::Job::GetDnsFromLocalCache(
-    const std::string& host,
-    ResolveDnsOperation op,
-    std::string* output,
-    bool* return_value) {
+bool Job::GetDnsFromLocalCache(const std::string& host,
+                               ResolveDnsOperation op,
+                               std::string* output,
+                               bool* return_value) {
   CheckIsOnWorkerThread();
 
   DnsCache::const_iterator it = dns_cache_.find(MakeDnsCacheKey(host, op));
   if (it == dns_cache_.end())
     return false;
 
   *output = it->second;
   *return_value = !it->second.empty();
   return true;
 }
 
-void ProxyResolverV8Tracing::Job::SaveDnsToLocalCache(
-    const std::string& host,
-    ResolveDnsOperation op,
-    int net_error,
-    const AddressList& addresses) {
+void Job::SaveDnsToLocalCache(const std::string& host,
+                              ResolveDnsOperation op,
+                              int net_error,
+                              const AddressList& addresses) {
   CheckIsOnOriginThread();
 
   // Serialize the result into a string to save to the cache.
   std::string cache_value;
   if (net_error != OK) {
     cache_value = std::string();
   } else if (op == DNS_RESOLVE || op == MY_IP_ADDRESS) {
     // dnsResolve() and myIpAddress() are expected to return a single IP
     // address.
     cache_value = addresses.front().ToStringWithoutPort();
   } else {
     // The *Ex versions are expected to return a semi-colon separated list.
     for (AddressList::const_iterator iter = addresses.begin();
          iter != addresses.end(); ++iter) {
       if (!cache_value.empty())
         cache_value += ";";
       cache_value += iter->ToStringWithoutPort();
     }
   }
 
   dns_cache_[MakeDnsCacheKey(host, op)] = cache_value;
 }
 
 // static
-HostResolver::RequestInfo ProxyResolverV8Tracing::Job::MakeDnsRequestInfo(
-    const std::string& host, ResolveDnsOperation op) {
+HostResolver::RequestInfo Job::MakeDnsRequestInfo(const std::string& host,
+                                                  ResolveDnsOperation op) {
   HostPortPair host_port = HostPortPair(host, 80);
   if (op == MY_IP_ADDRESS || op == MY_IP_ADDRESS_EX) {
     host_port.set_host(GetHostName());
   }
 
   HostResolver::RequestInfo info(host_port);
   // Flag myIpAddress requests.
   if (op == MY_IP_ADDRESS || op == MY_IP_ADDRESS_EX) {
     // TODO: Provide a RequestInfo construction mechanism that does not
     // require a hostname and sets is_my_ip_address to true instead of this.
     info.set_is_my_ip_address(true);
   }
   // The non-ex flavors are limited to IPv4 results.
   if (op == MY_IP_ADDRESS || op == DNS_RESOLVE) {
     info.set_address_family(ADDRESS_FAMILY_IPV4);
   }
 
   return info;
 }
 
-std::string ProxyResolverV8Tracing::Job::MakeDnsCacheKey(
-    const std::string& host, ResolveDnsOperation op) {
+std::string Job::MakeDnsCacheKey(const std::string& host,
+                                 ResolveDnsOperation op) {
   return base::StringPrintf("%d:%s", op, host.c_str());
 }
 
-void ProxyResolverV8Tracing::Job::HandleAlertOrError(
-    bool is_alert,
-    int line_number,
-    const base::string16& message) {
+void Job::HandleAlertOrError(bool is_alert,
+                             int line_number,
+                             const base::string16& message) {
   CheckIsOnWorkerThread();
 
   if (cancelled_.IsSet())
     return;
 
   if (blocking_dns_) {
     // In blocking DNS mode the events can be dispatched immediately.
     DispatchAlertOrError(is_alert, line_number, message);
     return;
   }
@@ skipping 11 matching lines @@
   // Avoid this by falling back to blocking mode.
   if (alerts_and_errors_byte_cost_ > kMaxAlertsAndErrorsBytes) {
     ScheduleRestartWithBlockingDns();
     return;
   }
 
   AlertOrError entry = {is_alert, line_number, message};
   alerts_and_errors_.push_back(entry);
 }
 
-void ProxyResolverV8Tracing::Job::DispatchBufferedAlertsAndErrors() {
+void Job::DispatchBufferedAlertsAndErrors() {
   CheckIsOnWorkerThread();
   DCHECK(!blocking_dns_);
   DCHECK(!abandoned_);
 
   for (size_t i = 0; i < alerts_and_errors_.size(); ++i) {
     const AlertOrError& x = alerts_and_errors_[i];
     DispatchAlertOrError(x.is_alert, x.line_number, x.message);
   }
 }
 
-void ProxyResolverV8Tracing::Job::DispatchAlertOrError(
-    bool is_alert, int line_number, const base::string16& message) {
+void Job::DispatchAlertOrError(bool is_alert,
+                               int line_number,
+                               const base::string16& message) {
   CheckIsOnWorkerThread();
 
   // Note that the handling of cancellation is racy with regard to
   // alerts/errors. The request might get cancelled shortly after this
   // check! (There is no lock being held to guarantee otherwise).
   //
   // If this happens, then some information will get written to the NetLog
   // needlessly, however the NetLog will still be alive so it shouldn't cause
   // problems.
   if (cancelled_.IsSet())
@@ skipping 21 matching lines @@
     // Send the error to the NetLog.
     LogEventToCurrentRequestAndGlobally(
         NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
         base::Bind(&NetLogErrorCallback, line_number, &message));
 
     if (error_observer())
       error_observer()->OnPACScriptError(line_number, message);
   }
 }
 
-void ProxyResolverV8Tracing::Job::LogEventToCurrentRequestAndGlobally(
+void Job::LogEventToCurrentRequestAndGlobally(
     NetLog::EventType type,
     const NetLog::ParametersCallback& parameters_callback) {
   CheckIsOnWorkerThread();
   bound_net_log_.AddEvent(type, parameters_callback);
 
   // Emit to the global NetLog event stream.
   if (net_log())
     net_log()->AddGlobalEntry(type, parameters_callback);
 }
 
 ProxyResolverV8Tracing::ProxyResolverV8Tracing(
-    HostResolver* host_resolver,
-    ProxyResolverErrorObserver* error_observer,
-    NetLog* net_log)
-    : ProxyResolverV8Tracing(host_resolver,
-                             error_observer,
-                             net_log,
-                             LoadStateChangedCallback()) {
-}
-
-ProxyResolverV8Tracing::ProxyResolverV8Tracing(
-    HostResolver* host_resolver,
-    ProxyResolverErrorObserver* error_observer,
-    NetLog* net_log,
-    const LoadStateChangedCallback& on_load_state_changed)
+    scoped_ptr<ProxyResolverErrorObserver> error_observer,
+    scoped_ptr<base::Thread> thread,
+    scoped_ptr<ProxyResolverV8> resolver,
+    scoped_ptr<Job::Params> job_params)
     : ProxyResolver(true /*expects_pac_bytes*/),
-      host_resolver_(host_resolver),
-      error_observer_(error_observer),
-      net_log_(net_log),
-      num_outstanding_callbacks_(0),
-      on_load_state_changed_(on_load_state_changed) {
-  DCHECK(host_resolver);
-  // Start up the thread.
-  thread_.reset(new base::Thread("Proxy resolver"));
-  base::Thread::Options options;
-  options.timer_slack = base::TIMER_SLACK_MAXIMUM;
-  CHECK(thread_->StartWithOptions(options));
-
-  v8_resolver_.reset(new ProxyResolverV8);
+      thread_(thread.Pass()),
+      v8_resolver_(resolver.Pass()),
+      error_observer_(error_observer.Pass()),
+      job_params_(job_params.Pass()),
+      num_outstanding_callbacks_(0) {
+  job_params_->num_outstanding_callbacks = &num_outstanding_callbacks_;
 }
 
 ProxyResolverV8Tracing::~ProxyResolverV8Tracing() {
   // Note, all requests should have been cancelled.
-  CHECK(!set_pac_script_job_.get());
   CHECK_EQ(0, num_outstanding_callbacks_);
 
-  // Join the worker thread. See http://crbug.com/69710. Note that we call
-  // Stop() here instead of simply clearing thread_ since there may be pending
-  // callbacks on the worker thread which want to dereference thread_.
+  // Join the worker thread. See http://crbug.com/69710.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
-  thread_->Stop();
+  thread_.reset();
 }
 
 int ProxyResolverV8Tracing::GetProxyForURL(const GURL& url,
                                            ProxyInfo* results,
                                            const CompletionCallback& callback,
                                            RequestHandle* request,
                                            const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
-  DCHECK(!set_pac_script_job_.get());
 
-  scoped_refptr<Job> job = new Job(this);
+  scoped_refptr<Job> job = new Job(job_params_.get());
 
   if (request)
     *request = job.get();
 
   job->StartGetProxyForURL(url, results, net_log, callback);
   return ERR_IO_PENDING;
 }
 
 void ProxyResolverV8Tracing::CancelRequest(RequestHandle request) {
   Job* job = reinterpret_cast<Job*>(request);
   job->Cancel();
 }
 
 LoadState ProxyResolverV8Tracing::GetLoadState(RequestHandle request) const {
   Job* job = reinterpret_cast<Job*>(request);
   return job->GetLoadState();
 }
 
 void ProxyResolverV8Tracing::CancelSetPacScript() {
-  DCHECK(set_pac_script_job_.get());
-  set_pac_script_job_->Cancel();
-  set_pac_script_job_ = NULL;
+  NOTREACHED();
 }
 
 int ProxyResolverV8Tracing::SetPacScript(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!callback.is_null());
+  NOTREACHED();
+  return ERR_NOT_IMPLEMENTED;
+}
 
-  // Note that there should not be any outstanding (non-cancelled) Jobs when
-  // setting the PAC script (ProxyService should guarantee this). If there are,
-  // then they might complete in strange ways after the new script is set.
-  DCHECK(!set_pac_script_job_.get());
-  CHECK_EQ(0, num_outstanding_callbacks_);
+}  // namespace
 
-  set_pac_script_job_ = new Job(this);
-  set_pac_script_job_->StartSetPacScript(script_data, callback);
+class ProxyResolverFactoryV8Tracing::CreateJob
+    : public ProxyResolverFactory::Request {
+ public:
+  CreateJob(ProxyResolverFactoryV8Tracing* factory,
+            HostResolver* host_resolver,
+            scoped_ptr<ProxyResolverErrorObserver> error_observer,
+            NetLog* net_log,
+            const ProxyResolver::LoadStateChangedCallback&
+                load_state_changed_callback,
+            const scoped_refptr<ProxyResolverScriptData>& pac_script,
+            scoped_ptr<ProxyResolver>* resolver_out,
+            const CompletionCallback& callback)
+      : factory_(factory),
+        thread_(new base::Thread("Proxy Resolver")),
+        error_observer_(error_observer.Pass()),
+        resolver_out_(resolver_out),
+        callback_(callback),
+        num_outstanding_callbacks_(0) {
+    // Start up the thread.
+    base::Thread::Options options;
+    options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+    CHECK(thread_->StartWithOptions(options));
+    job_params_.reset(new Job::Params(
+        thread_->task_runner(), host_resolver, error_observer_.get(), net_log,
+        load_state_changed_callback, &num_outstanding_callbacks_));
+    create_resolver_job_ = new Job(job_params_.get());
+    create_resolver_job_->StartCreateV8Resolver(
+        pac_script, &v8_resolver_,
+        base::Bind(
+            &ProxyResolverFactoryV8Tracing::CreateJob::OnV8ResolverCreated,
+            base::Unretained(this)));
+  }
 
+  ~CreateJob() override {
+    if (factory_) {
+      factory_->RemoveJob(this);
+      DCHECK(create_resolver_job_);
+      create_resolver_job_->Cancel();
+      StopWorkerThread();
+    }
+    DCHECK_EQ(0, num_outstanding_callbacks_);
+  }
+
+  void FactoryDestroyed() {
+    factory_ = nullptr;
+    create_resolver_job_->Cancel();
+    create_resolver_job_ = nullptr;
+    StopWorkerThread();
+  }
+
+ private:
+  void OnV8ResolverCreated(int error) {
+    DCHECK(factory_);
+    if (error == OK) {
+      job_params_->v8_resolver = v8_resolver_.get();
+      resolver_out_->reset(
+          new ProxyResolverV8Tracing(error_observer_.Pass(), thread_.Pass(),
+                                     v8_resolver_.Pass(), job_params_.Pass()));
+    } else {
+      StopWorkerThread();
+    }
+
+    factory_->RemoveJob(this);
+    factory_ = nullptr;
+    create_resolver_job_ = nullptr;
+    callback_.Run(error);
+  }
+
+  void StopWorkerThread() {
+    // Join the worker thread. See http://crbug.com/69710.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    thread_.reset();
+  }
+
+  ProxyResolverFactoryV8Tracing* factory_;
+  scoped_ptr<base::Thread> thread_;
+  scoped_ptr<ProxyResolverErrorObserver> error_observer_;
+  scoped_ptr<Job::Params> job_params_;
+  scoped_refptr<Job> create_resolver_job_;
+  scoped_ptr<ProxyResolverV8> v8_resolver_;
+  scoped_ptr<ProxyResolver>* resolver_out_;
+  const CompletionCallback callback_;
+  int num_outstanding_callbacks_;
+
+  DISALLOW_COPY_AND_ASSIGN(CreateJob);
+};
+
+ProxyResolverFactoryV8Tracing::ProxyResolverFactoryV8Tracing(
+    HostResolver* host_resolver,
+    NetLog* net_log,
+    const ProxyResolver::LoadStateChangedCallback& callback)
+    : ProxyResolverFactory(true),
+      host_resolver_(host_resolver),
+      net_log_(net_log),
+      load_state_changed_callback_(callback) {
+}
+
+ProxyResolverFactoryV8Tracing::~ProxyResolverFactoryV8Tracing() {
+  for (auto job : jobs_) {
+    job->FactoryDestroyed();
+  }
+}
+
+// ProxyResolverFactory override.
+int ProxyResolverFactoryV8Tracing::CreateProxyResolver(
+    const scoped_refptr<ProxyResolverScriptData>& pac_script,
+    scoped_ptr<ProxyResolver>* resolver,
+    const CompletionCallback& callback,
+    scoped_ptr<Request>* request) {
+  scoped_ptr<CreateJob> job(new CreateJob(
+      this, host_resolver_, CreateErrorObserver(), net_log_,
+      load_state_changed_callback_, pac_script, resolver, callback));
+  jobs_.insert(job.get());
+  *request = job.Pass();
   return ERR_IO_PENDING;
 }
 
+void ProxyResolverFactoryV8Tracing::RemoveJob(
+    ProxyResolverFactoryV8Tracing::CreateJob* job) {
+  size_t erased = jobs_.erase(job);
+  DCHECK_EQ(1u, erased);
+}
+
 }  // namespace net