Start moving responsibility for setting PAC script into ProxyResolverFactory.

This is the first part of refactoring ProxyResolverFactory to return
ready-to-resolve ProxyResolver instances. It:
- changes ProxyResolverFactory::Create to be asynchronous and take
  ProxyResolverScriptData;
- adds a LegacyProxyResolverFactory implentation that adapts the old
  ProxyResolverFactory interface; and
- changes ProxyService and the trivial ProxyResolver implementations in
  proxy_service.cc to use the new ProxyResolverFactory interface.

BUG=467403

Review URL: https://codereview.chromium.org/1086413004

Cr-Commit-Position: refs/heads/master@{#325984}

13 files changed, 342 insertions, 58 deletions

diff --git a/net/net.gypi b/net/net.gypi
index 8faf632..a122009 100644
--- a/net/net.gypi
+++ b/net/net.gypi
@@ -1455,6 +1455,7 @@
       'proxy/proxy_info_unittest.cc',
       'proxy/proxy_list_unittest.cc',
       'proxy/proxy_resolver_mojo_unittest.cc',
+      'proxy/proxy_resolver_factory_unittest.cc',
       'proxy/proxy_resolver_v8_tracing_unittest.cc',
       'proxy/proxy_resolver_v8_unittest.cc',
       'proxy/proxy_script_decider_unittest.cc',
diff --git a/net/proxy/mock_proxy_resolver.cc b/net/proxy/mock_proxy_resolver.cc
index 16ebc82..2ff0900 100644
--- a/net/proxy/mock_proxy_resolver.cc
+++ b/net/proxy/mock_proxy_resolver.cc
@@ -144,7 +144,8 @@ int ForwardingProxyResolver::SetPacScript(
 
 ForwardingProxyResolverFactory::ForwardingProxyResolverFactory(
     ProxyResolver* resolver)
-    : ProxyResolverFactory(resolver->expects_pac_bytes()), resolver_(resolver) {
+    : LegacyProxyResolverFactory(resolver->expects_pac_bytes()),
+      resolver_(resolver) {
 }
 
 scoped_ptr<ProxyResolver>
diff --git a/net/proxy/mock_proxy_resolver.h b/net/proxy/mock_proxy_resolver.h
index 024c1e8..024a083 100644
--- a/net/proxy/mock_proxy_resolver.h
+++ b/net/proxy/mock_proxy_resolver.h
@@ -127,11 +127,11 @@ class MockAsyncProxyResolverExpectsBytes : public MockAsyncProxyResolverBase {
 // This factory returns ProxyResolvers that forward all requests to
 // |resolver|. |resolver| must remain so long as any value returned from
 // CreateProxyResolver remains in use.
-class ForwardingProxyResolverFactory : public ProxyResolverFactory {
+class ForwardingProxyResolverFactory : public LegacyProxyResolverFactory {
  public:
   explicit ForwardingProxyResolverFactory(ProxyResolver* resolver);
 
-  // ProxyResolverFactory override.
+  // LegacyProxyResolverFactory override.
   scoped_ptr<ProxyResolver> CreateProxyResolver() override;
 
  private:
diff --git a/net/proxy/multi_threaded_proxy_resolver.cc b/net/proxy/multi_threaded_proxy_resolver.cc
index e301997..b8fea44 100644
--- a/net/proxy/multi_threaded_proxy_resolver.cc
+++ b/net/proxy/multi_threaded_proxy_resolver.cc
@@ -356,9 +356,9 @@ MultiThreadedProxyResolver::Executor::~Executor() {
 // MultiThreadedProxyResolver --------------------------------------------------
 
 MultiThreadedProxyResolver::MultiThreadedProxyResolver(
-    ProxyResolverFactory* resolver_factory,
+    LegacyProxyResolverFactory* resolver_factory,
     size_t max_num_threads)
-    : ProxyResolver(resolver_factory->resolvers_expect_pac_bytes()),
+    : ProxyResolver(resolver_factory->expects_pac_bytes()),
       resolver_factory_(resolver_factory),
       max_num_threads_(max_num_threads) {
   DCHECK_GE(max_num_threads, 1u);
diff --git a/net/proxy/multi_threaded_proxy_resolver.h b/net/proxy/multi_threaded_proxy_resolver.h
index 8eb8911..a83c273 100644
--- a/net/proxy/multi_threaded_proxy_resolver.h
+++ b/net/proxy/multi_threaded_proxy_resolver.h
@@ -20,7 +20,7 @@ class Thread;
 }  // namespace base
 
 namespace net {
-class ProxyResolverFactory;
+class LegacyProxyResolverFactory;
 
 // MultiThreadedProxyResolver is a ProxyResolver implementation that runs
 // synchronous ProxyResolver implementations on worker threads.
@@ -65,7 +65,7 @@ class NET_EXPORT_PRIVATE MultiThreadedProxyResolver
   // prior to destruction.
   //
   // The constructor takes ownership of |resolver_factory|.
-  MultiThreadedProxyResolver(ProxyResolverFactory* resolver_factory,
+  MultiThreadedProxyResolver(LegacyProxyResolverFactory* resolver_factory,
                              size_t max_num_threads);
 
   ~MultiThreadedProxyResolver() override;
@@ -109,7 +109,7 @@ class NET_EXPORT_PRIVATE MultiThreadedProxyResolver
   // Starts the next job from |pending_jobs_| if possible.
   void OnExecutorReady(Executor* executor);
 
-  const scoped_ptr<ProxyResolverFactory> resolver_factory_;
+  const scoped_ptr<LegacyProxyResolverFactory> resolver_factory_;
   const size_t max_num_threads_;
   PendingJobsQueue pending_jobs_;
   ExecutorList executors_;
diff --git a/net/proxy/multi_threaded_proxy_resolver_unittest.cc b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
index eb70c1df..618aa14 100644
--- a/net/proxy/multi_threaded_proxy_resolver_unittest.cc
+++ b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
@@ -151,9 +151,9 @@ class BlockableProxyResolver : public MockProxyResolver {
 };
 
 // This factory returns new instances of BlockableProxyResolver.
-class BlockableProxyResolverFactory : public ProxyResolverFactory {
+class BlockableProxyResolverFactory : public LegacyProxyResolverFactory {
  public:
-  BlockableProxyResolverFactory() : ProxyResolverFactory(true) {}
+  BlockableProxyResolverFactory() : LegacyProxyResolverFactory(true) {}
 
   ~BlockableProxyResolverFactory() override { STLDeleteElements(&resolvers_); }
 
diff --git a/net/proxy/proxy_resolver_factory.cc b/net/proxy/proxy_resolver_factory.cc
index 140f153..8866b4b 100644
--- a/net/proxy/proxy_resolver_factory.cc
+++ b/net/proxy/proxy_resolver_factory.cc
@@ -4,13 +4,100 @@
 
 #include "net/proxy/proxy_resolver_factory.h"
 
+#include "net/base/net_errors.h"
+#include "net/proxy/proxy_resolver.h"
+
 namespace net {
+namespace {
+
+class Job : public ProxyResolverFactory::Request {
+ public:
+  Job(const scoped_refptr<ProxyResolverScriptData>& pac_script,
+      scoped_ptr<ProxyResolver> resolver,
+      scoped_ptr<ProxyResolver>* resolver_out,
+      const net::CompletionCallback& callback);
+  ~Job() override;
+  int Start();
+
+ private:
+  void OnSetPacScriptDone(int error);
+
+  const scoped_refptr<ProxyResolverScriptData> pac_script_;
+  scoped_ptr<ProxyResolver> resolver_;
+  scoped_ptr<ProxyResolver>* resolver_out_;
+  const net::CompletionCallback callback_;
+  bool in_progress_;
+};
+
+Job::Job(const scoped_refptr<ProxyResolverScriptData>& pac_script,
+         scoped_ptr<ProxyResolver> resolver,
+         scoped_ptr<ProxyResolver>* resolver_out,
+         const net::CompletionCallback& callback)
+    : pac_script_(pac_script),
+      resolver_(resolver.Pass()),
+      resolver_out_(resolver_out),
+      callback_(callback),
+      in_progress_(false) {
+}
+
+Job::~Job() {
+  if (in_progress_)
+    resolver_->CancelSetPacScript();
+}
+
+int Job::Start() {
+  int error = resolver_->SetPacScript(
+      pac_script_,
+      base::Bind(&Job::OnSetPacScriptDone, base::Unretained(this)));
+  if (error != ERR_IO_PENDING) {
+    if (error == OK)
+      *resolver_out_ = resolver_.Pass();
+    return error;
+  }
+
+  in_progress_ = true;
+  return ERR_IO_PENDING;
+}
 
-ProxyResolverFactory::ProxyResolverFactory(bool resolvers_expect_pac_bytes)
-    : resolvers_expect_pac_bytes_(resolvers_expect_pac_bytes) {
+void Job::OnSetPacScriptDone(int error) {
+  if (error == OK)
+    *resolver_out_ = resolver_.Pass();
+
+  CompletionCallback callback = callback_;
+  in_progress_ = false;
+  if (!callback.is_null())
+    callback.Run(error);
+}
+
+}  // namespace
+
+ProxyResolverFactory::ProxyResolverFactory(bool expects_pac_bytes)
+    : expects_pac_bytes_(expects_pac_bytes) {
 }
 
 ProxyResolverFactory::~ProxyResolverFactory() {
 }
 
+LegacyProxyResolverFactory::LegacyProxyResolverFactory(bool expects_pac_bytes)
+    : ProxyResolverFactory(expects_pac_bytes) {
+}
+
+LegacyProxyResolverFactory::~LegacyProxyResolverFactory() {
+}
+
+int LegacyProxyResolverFactory::CreateProxyResolver(
+    const scoped_refptr<ProxyResolverScriptData>& pac_script,
+    scoped_ptr<ProxyResolver>* resolver,
+    const net::CompletionCallback& callback,
+    scoped_ptr<ProxyResolverFactory::Request>* request) {
+  scoped_ptr<Job> job(
+      new Job(pac_script, CreateProxyResolver(), resolver, callback));
+  int error = job->Start();
+  if (error != ERR_IO_PENDING)
+    return error;
+
+  *request = job.Pass();
+  return ERR_IO_PENDING;
+}
+
 }  // namespace net
diff --git a/net/proxy/proxy_resolver_factory.h b/net/proxy/proxy_resolver_factory.h
index 17b3f9b..67a591c 100644
--- a/net/proxy/proxy_resolver_factory.h
+++ b/net/proxy/proxy_resolver_factory.h
@@ -5,8 +5,11 @@
 #ifndef NET_PROXY_PROXY_RESOLVER_FACTORY_H_
 #define NET_PROXY_PROXY_RESOLVER_FACTORY_H_
 
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
+#include "net/proxy/proxy_resolver_script_data.h"
 
 namespace net {
 
@@ -15,24 +18,55 @@ class ProxyResolver;
 // ProxyResolverFactory is an interface for creating ProxyResolver instances.
 class NET_EXPORT ProxyResolverFactory {
  public:
-  explicit ProxyResolverFactory(bool resolvers_expect_pac_bytes);
+  // A handle to a request. Deleting it will cancel the request.
+  class Request {
+   public:
+    virtual ~Request() {}
+  };
+
+  // See |expects_pac_bytes()| for the meaning of |expects_pac_bytes|.
+  explicit ProxyResolverFactory(bool expects_pac_bytes);
 
   virtual ~ProxyResolverFactory();
 
-  // Creates a new ProxyResolver. The caller is responsible for freeing this
-  // object.
-  virtual scoped_ptr<ProxyResolver> CreateProxyResolver() = 0;
+  // Creates a new ProxyResolver. If the request will complete asynchronously,
+  // it returns ERR_IO_PENDING and notifies the result by running |callback|.
+  // If the result is OK, then |resolver| contains the ProxyResolver. In the
+  // case of asynchronous completion |*request| is written to, and can be
+  // deleted to cancel the request.
+  virtual int CreateProxyResolver(
+      const scoped_refptr<ProxyResolverScriptData>& pac_script,
+      scoped_ptr<ProxyResolver>* resolver,
+      const net::CompletionCallback& callback,
+      scoped_ptr<Request>* request) = 0;
 
-  bool resolvers_expect_pac_bytes() const {
-    return resolvers_expect_pac_bytes_;
-  }
+  // The PAC script backend can be specified to the ProxyResolverFactory either
+  // via URL, or via the javascript text itself. If |expects_pac_bytes| is true,
+  // then the ProxyResolverScriptData passed to CreateProxyResolver() should
+  // contain the actual script bytes rather than just the URL.
+  bool expects_pac_bytes() const { return expects_pac_bytes_; }
 
  private:
-  bool resolvers_expect_pac_bytes_;
+  bool expects_pac_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverFactory);
 };
 
+class NET_EXPORT LegacyProxyResolverFactory : public ProxyResolverFactory {
+ public:
+  explicit LegacyProxyResolverFactory(bool expects_pac_bytes);
+
+  ~LegacyProxyResolverFactory() override;
+
+  int CreateProxyResolver(
+      const scoped_refptr<ProxyResolverScriptData>& pac_script,
+      scoped_ptr<ProxyResolver>* resolver,
+      const net::CompletionCallback& callback,
+      scoped_ptr<Request>* request) override;
+
+  virtual scoped_ptr<ProxyResolver> CreateProxyResolver() = 0;
+};
+
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_RESOLVER_FACTORY_H_
diff --git a/net/proxy/proxy_resolver_factory_unittest.cc b/net/proxy/proxy_resolver_factory_unittest.cc
new file mode 100644
index 0000000..6e9708b
--- /dev/null
+++ b/net/proxy/proxy_resolver_factory_unittest.cc
@@ -0,0 +1,151 @@
+// Copyright 2015 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_factory.h"
+
+#include "net/base/net_errors.h"
+#include "net/base/test_completion_callback.h"
+#include "net/proxy/mock_proxy_resolver.h"
+#include "net/proxy/proxy_resolver.h"
+#include "net/proxy/proxy_resolver_script_data.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace {
+
+void Fail(int error) {
+  FAIL() << "Unexpected callback called";
+}
+
+class TestProxyResolver : public MockAsyncProxyResolver {
+ public:
+  int SetPacScript(const scoped_refptr<ProxyResolverScriptData>& script_data,
+                   const CompletionCallback& callback) override {
+    int result = MockAsyncProxyResolver::SetPacScript(script_data, callback);
+    if (synchronous_)
+      return error_to_return_;
+
+    return result;
+  }
+
+  void set_error_to_return(Error error) {
+    synchronous_ = true;
+    error_to_return_ = error;
+  }
+
+ private:
+  bool synchronous_ = false;
+  Error error_to_return_ = OK;
+};
+
+class TestLegacyProxyResolverFactory : public LegacyProxyResolverFactory {
+ public:
+  TestLegacyProxyResolverFactory() : LegacyProxyResolverFactory(false) {}
+
+  // LegacyProxyResolverFactory override.
+  scoped_ptr<ProxyResolver> CreateProxyResolver() override {
+    return make_scoped_ptr(new ForwardingProxyResolver(&resolver_));
+  }
+
+  TestProxyResolver& resolver() { return resolver_; }
+
+ private:
+  TestProxyResolver resolver_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestLegacyProxyResolverFactory);
+};
+
+}  // namespace
+
+class LegacyProxyResolverFactoryTest : public testing::Test {
+ public:
+  ProxyResolverFactory& factory() { return factory_; }
+  TestProxyResolver& mock_resolver() { return factory_.resolver(); }
+
+ private:
+  TestLegacyProxyResolverFactory factory_;
+};
+
+TEST_F(LegacyProxyResolverFactoryTest, Async_Success) {
+  const GURL url("http://proxy");
+  TestCompletionCallback callback;
+  scoped_ptr<ProxyResolver> resolver;
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  EXPECT_EQ(ERR_IO_PENDING, factory().CreateProxyResolver(
+                                ProxyResolverScriptData::FromURL(url),
+                                &resolver, callback.callback(), &request));
+  ASSERT_TRUE(mock_resolver().has_pending_set_pac_script_request());
+  EXPECT_EQ(
+      url,
+      mock_resolver().pending_set_pac_script_request()->script_data()->url());
+  mock_resolver().pending_set_pac_script_request()->CompleteNow(OK);
+  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_TRUE(resolver);
+}
+
+TEST_F(LegacyProxyResolverFactoryTest, Async_Error) {
+  const GURL url("http://proxy");
+  TestCompletionCallback callback;
+  scoped_ptr<ProxyResolver> resolver;
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  EXPECT_EQ(ERR_IO_PENDING, factory().CreateProxyResolver(
+                                ProxyResolverScriptData::FromURL(url),
+                                &resolver, callback.callback(), &request));
+  ASSERT_TRUE(mock_resolver().has_pending_set_pac_script_request());
+  EXPECT_EQ(
+      url,
+      mock_resolver().pending_set_pac_script_request()->script_data()->url());
+  mock_resolver().pending_set_pac_script_request()->CompleteNow(ERR_FAILED);
+  EXPECT_EQ(ERR_FAILED, callback.WaitForResult());
+  EXPECT_FALSE(resolver);
+}
+
+TEST_F(LegacyProxyResolverFactoryTest, Async_Cancel) {
+  const GURL url("http://proxy");
+  scoped_ptr<ProxyResolver> resolver;
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  EXPECT_EQ(ERR_IO_PENDING, factory().CreateProxyResolver(
+                                ProxyResolverScriptData::FromURL(url),
+                                &resolver, base::Bind(&Fail), &request));
+  ASSERT_TRUE(mock_resolver().has_pending_set_pac_script_request());
+  EXPECT_EQ(
+      url,
+      mock_resolver().pending_set_pac_script_request()->script_data()->url());
+  request.reset();
+  EXPECT_FALSE(resolver);
+}
+
+TEST_F(LegacyProxyResolverFactoryTest, Sync_Success) {
+  const GURL url("http://proxy");
+  TestCompletionCallback callback;
+  scoped_ptr<ProxyResolver> resolver;
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  mock_resolver().set_error_to_return(OK);
+  EXPECT_EQ(OK, factory().CreateProxyResolver(
+                    ProxyResolverScriptData::FromURL(url), &resolver,
+                    callback.callback(), &request));
+  ASSERT_TRUE(mock_resolver().has_pending_set_pac_script_request());
+  EXPECT_EQ(
+      url,
+      mock_resolver().pending_set_pac_script_request()->script_data()->url());
+  EXPECT_TRUE(resolver);
+}
+
+TEST_F(LegacyProxyResolverFactoryTest, Sync_Error) {
+  const GURL url("http://proxy");
+  TestCompletionCallback callback;
+  scoped_ptr<ProxyResolver> resolver;
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  mock_resolver().set_error_to_return(ERR_FAILED);
+  EXPECT_EQ(ERR_FAILED, factory().CreateProxyResolver(
+                            ProxyResolverScriptData::FromURL(url), &resolver,
+                            callback.callback(), &request));
+  ASSERT_TRUE(mock_resolver().has_pending_set_pac_script_request());
+  EXPECT_EQ(
+      url,
+      mock_resolver().pending_set_pac_script_request()->script_data()->url());
+  EXPECT_FALSE(resolver);
+}
+
+}  // namespace net
diff --git a/net/proxy/proxy_service.cc b/net/proxy/proxy_service.cc
index fe34f7b..f912d2e 100644
--- a/net/proxy/proxy_service.cc
+++ b/net/proxy/proxy_service.cc
@@ -237,10 +237,10 @@ class ProxyResolverFromPacString : public ProxyResolver {
 };
 
 // Creates ProxyResolvers using a platform-specific implementation.
-class ProxyResolverFactoryForSystem : public ProxyResolverFactory {
+class ProxyResolverFactoryForSystem : public LegacyProxyResolverFactory {
  public:
   explicit ProxyResolverFactoryForSystem(size_t max_num_threads)
-      : ProxyResolverFactory(false /*expects_pac_bytes*/),
+      : LegacyProxyResolverFactory(false /*expects_pac_bytes*/),
         max_num_threads_(max_num_threads) {}
 
   scoped_ptr<ProxyResolver> CreateProxyResolver() override {
@@ -277,9 +277,14 @@ class ProxyResolverFactoryForNullResolver : public ProxyResolverFactory {
  public:
   ProxyResolverFactoryForNullResolver() : ProxyResolverFactory(false) {}
 
-  // ProxyResolverFactory override.
-  scoped_ptr<ProxyResolver> CreateProxyResolver() override {
-    return make_scoped_ptr(new ProxyResolverNull());
+  // ProxyResolverFactory overrides.
+  int CreateProxyResolver(
+      const scoped_refptr<ProxyResolverScriptData>& pac_script,
+      scoped_ptr<ProxyResolver>* resolver,
+      const net::CompletionCallback& callback,
+      scoped_ptr<Request>* request) override {
+    resolver->reset(new ProxyResolverNull());
+    return OK;
   }
 
  private:
@@ -292,8 +297,13 @@ class ProxyResolverFactoryForPacResult : public ProxyResolverFactory {
       : ProxyResolverFactory(false), pac_string_(pac_string) {}
 
   // ProxyResolverFactory override.
-  scoped_ptr<ProxyResolver> CreateProxyResolver() override {
-    return make_scoped_ptr(new ProxyResolverFromPacString(pac_string_));
+  int CreateProxyResolver(
+      const scoped_refptr<ProxyResolverScriptData>& pac_script,
+      scoped_ptr<ProxyResolver>* resolver,
+      const net::CompletionCallback& callback,
+      scoped_ptr<Request>* request) override {
+    resolver->reset(new ProxyResolverFromPacString(pac_string_));
+    return OK;
   }
 
  private:
@@ -377,9 +387,6 @@ class ProxyService::InitProxyResolver {
   ~InitProxyResolver() {
     // Note that the destruction of ProxyScriptDecider will automatically cancel
     // any outstanding work.
-    if (next_state_ == STATE_SET_PAC_SCRIPT_COMPLETE) {
-      (*proxy_resolver_)->CancelSetPacScript();
-    }
   }
 
   // Begins initializing the proxy resolver; calls |callback| when done. A
@@ -430,7 +437,7 @@ class ProxyService::InitProxyResolver {
     if (decider_result != OK)
       return decider_result;
 
-    next_state_ = STATE_SET_PAC_SCRIPT;
+    next_state_ = STATE_CREATE_RESOLVER;
     return DoLoop(OK);
   }
 
@@ -465,8 +472,8 @@ class ProxyService::InitProxyResolver {
     STATE_NONE,
     STATE_DECIDE_PROXY_SCRIPT,
     STATE_DECIDE_PROXY_SCRIPT_COMPLETE,
-    STATE_SET_PAC_SCRIPT,
-    STATE_SET_PAC_SCRIPT_COMPLETE,
+    STATE_CREATE_RESOLVER,
+    STATE_CREATE_RESOLVER_COMPLETE,
   };
 
   int DoLoop(int result) {
@@ -483,12 +490,12 @@ class ProxyService::InitProxyResolver {
         case STATE_DECIDE_PROXY_SCRIPT_COMPLETE:
           rv = DoDecideProxyScriptComplete(rv);
           break;
-        case STATE_SET_PAC_SCRIPT:
+        case STATE_CREATE_RESOLVER:
           DCHECK_EQ(OK, rv);
-          rv = DoSetPacScript();
+          rv = DoCreateResolver();
           break;
-        case STATE_SET_PAC_SCRIPT_COMPLETE:
-          rv = DoSetPacScriptComplete(rv);
+        case STATE_CREATE_RESOLVER_COMPLETE:
+          rv = DoCreateResolverComplete(rv);
           break;
         default:
           NOTREACHED() << "bad state: " << state;
@@ -507,8 +514,7 @@ class ProxyService::InitProxyResolver {
     next_state_ = STATE_DECIDE_PROXY_SCRIPT_COMPLETE;
 
     return decider_->Start(
-        config_, wait_delay_,
-        proxy_resolver_factory_->resolvers_expect_pac_bytes(),
+        config_, wait_delay_, proxy_resolver_factory_->expects_pac_bytes(),
         base::Bind(&InitProxyResolver::OnIOCompletion, base::Unretained(this)));
   }
 
@@ -519,23 +525,21 @@ class ProxyService::InitProxyResolver {
     effective_config_ = decider_->effective_config();
     script_data_ = decider_->script_data();
 
-    next_state_ = STATE_SET_PAC_SCRIPT;
+    next_state_ = STATE_CREATE_RESOLVER;
     return OK;
   }
 
-  int DoSetPacScript() {
+  int DoCreateResolver() {
     DCHECK(script_data_.get());
     // TODO(eroman): Should log this latency to the NetLog.
-    next_state_ = STATE_SET_PAC_SCRIPT_COMPLETE;
-    *proxy_resolver_ = proxy_resolver_factory_->CreateProxyResolver();
-    DCHECK(*proxy_resolver_);
-    return (*proxy_resolver_)
-        ->SetPacScript(script_data_,
-                       base::Bind(&InitProxyResolver::OnIOCompletion,
-                                  base::Unretained(this)));
+    next_state_ = STATE_CREATE_RESOLVER_COMPLETE;
+    return proxy_resolver_factory_->CreateProxyResolver(
+        script_data_, proxy_resolver_,
+        base::Bind(&InitProxyResolver::OnIOCompletion, base::Unretained(this)),
+        &create_resolver_request_);
   }
 
-  int DoSetPacScriptComplete(int result) {
+  int DoCreateResolverComplete(int result) {
     if (result != OK)
       proxy_resolver_->reset();
     return result;
@@ -559,6 +563,7 @@ class ProxyService::InitProxyResolver {
   TimeDelta wait_delay_;
   scoped_ptr<ProxyScriptDecider> decider_;
   ProxyResolverFactory* proxy_resolver_factory_;
+  scoped_ptr<ProxyResolverFactory::Request> create_resolver_request_;
   scoped_ptr<ProxyResolver>* proxy_resolver_;
   CompletionCallback callback_;
   State next_state_;
@@ -1225,7 +1230,7 @@ void ProxyService::OnInitProxyResolverComplete(int result) {
   script_poller_.reset(new ProxyScriptDeciderPoller(
       base::Bind(&ProxyService::InitializeUsingDecidedConfig,
                  base::Unretained(this)),
-      fetched_config_, resolver_factory_->resolvers_expect_pac_bytes(),
+      fetched_config_, resolver_factory_->expects_pac_bytes(),
       proxy_script_fetcher_.get(), dhcp_proxy_script_fetcher_.get(), result,
       init_proxy_resolver_->script_data(), NULL));
   script_poller_->set_quick_check_enabled(quick_check_enabled_);
diff --git a/net/proxy/proxy_service_mojo.cc b/net/proxy/proxy_service_mojo.cc
index b714f03..ea9f2e6 100644
--- a/net/proxy/proxy_service_mojo.cc
+++ b/net/proxy/proxy_service_mojo.cc
@@ -17,16 +17,16 @@
 namespace net {
 namespace {
 
-class ProxyResolverFactoryForMojoResolver : public ProxyResolverFactory {
+class ProxyResolverFactoryForMojoResolver : public LegacyProxyResolverFactory {
  public:
   ProxyResolverFactoryForMojoResolver(
       MojoProxyResolverFactory* mojo_proxy_factory,
       HostResolver* host_resolver)
-      : ProxyResolverFactory(true),
+      : LegacyProxyResolverFactory(true),
         mojo_proxy_factory_(mojo_proxy_factory),
         host_resolver_(host_resolver) {}
 
-  // ProxyResolverFactory override.
+  // LegacyProxyResolverFactory override.
   scoped_ptr<ProxyResolver> CreateProxyResolver() override {
     return make_scoped_ptr(
         new ProxyResolverMojo(mojo_proxy_factory_, host_resolver_));
diff --git a/net/proxy/proxy_service_v8.cc b/net/proxy/proxy_service_v8.cc
index 64df111..eac36ec 100644
--- a/net/proxy/proxy_service_v8.cc
+++ b/net/proxy/proxy_service_v8.cc
@@ -15,17 +15,17 @@
 namespace net {
 namespace {
 
-class ProxyResolverFactoryForV8Resolver : public ProxyResolverFactory {
+class ProxyResolverFactoryForV8Resolver : public LegacyProxyResolverFactory {
  public:
   explicit ProxyResolverFactoryForV8Resolver(HostResolver* host_resolver,
                                              NetLog* net_log,
                                              NetworkDelegate* network_delegate)
-      : ProxyResolverFactory(true),
+      : LegacyProxyResolverFactory(true),
         host_resolver_(host_resolver),
         net_log_(net_log),
         network_delegate_(network_delegate) {}
 
-  // ProxyResolverFactory override.
+  // LegacyProxyResolverFactory override.
   scoped_ptr<ProxyResolver> CreateProxyResolver() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     ProxyResolverErrorObserver* error_observer =
diff --git a/net/url_request/url_request_ftp_job_unittest.cc b/net/url_request/url_request_ftp_job_unittest.cc
index d3397b2..cbbf407 100644
--- a/net/url_request/url_request_ftp_job_unittest.cc
+++ b/net/url_request/url_request_ftp_job_unittest.cc
@@ -33,8 +33,13 @@ namespace {
 class MockProxyResolverFactory : public ProxyResolverFactory {
  public:
   MockProxyResolverFactory() : ProxyResolverFactory(false) {}
-  scoped_ptr<ProxyResolver> CreateProxyResolver() override {
-    return make_scoped_ptr(new MockAsyncProxyResolver());
+  int CreateProxyResolver(
+      const scoped_refptr<ProxyResolverScriptData>& pac_script,
+      scoped_ptr<ProxyResolver>* resolver,
+      const net::CompletionCallback& callback,
+      scoped_ptr<Request>* request) override {
+    resolver->reset(new MockAsyncProxyResolver());
+    return OK;
   }
 };