Add ProxyResolverFactoryV8Tracing.

net/proxy/proxy_resolver_v8_tracing_unittest.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 <string>
+
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/log/captured_net_log_entry.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_unittest.h"
 #include "net/log/test_net_log.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
+class SingleShotProxyResolverFactoryV8Tracing
+    : public ProxyResolverFactoryV8Tracing {
+ public:
+  SingleShotProxyResolverFactoryV8Tracing(
+      HostResolver* host_resolver,
+      NetLog* net_log,
+      const ProxyResolver::LoadStateChangedCallback& callback,
+      scoped_ptr<ProxyResolverErrorObserver> error_observer)
+      : ProxyResolverFactoryV8Tracing(host_resolver, net_log, callback),
+        error_observer_(error_observer.Pass()) {}
+
+ private:
+  scoped_ptr<ProxyResolverErrorObserver> CreateErrorObserver() override {
+    return error_observer_.Pass();
+  }
+
+  scoped_ptr<ProxyResolverErrorObserver> error_observer_;
+};
+
 class ProxyResolverV8TracingTest : public testing::Test {
  public:
   void TearDown() override {
     // Drain any pending messages, which may be left over from cancellation.
     // This way they get reliably run as part of the current test, rather than
     // spilling into the next test's execution.
     base::MessageLoop::current()->RunUntilIdle();
   }
 };
 
 scoped_refptr<ProxyResolverScriptData> LoadScriptData(const char* filename) {
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   path = path.AppendASCII("net");
   path = path.AppendASCII("data");
   path = path.AppendASCII("proxy_resolver_v8_tracing_unittest");
   path = path.AppendASCII(filename);
 
   // Try to read the file from disk.
   std::string file_contents;
   bool ok = base::ReadFileToString(path, &file_contents);
 
   // If we can't load the file from disk, something is misconfigured.
   EXPECT_TRUE(ok) << "Failed to read file: " << path.value();
 
   // Load the PAC script into the ProxyResolver.
   return ProxyResolverScriptData::FromUTF8(file_contents);
 }
 
-void InitResolver(ProxyResolverV8Tracing* resolver, const char* filename) {
+scoped_ptr<ProxyResolver> CreateResolver(
+    NetLog* net_log,
+    HostResolver* host_resolver,
+    scoped_ptr<ProxyResolverErrorObserver> error_observer,
+    const char* filename) {
+  scoped_ptr<ProxyResolver> resolver;
+  SingleShotProxyResolverFactoryV8Tracing factory(
+      host_resolver, net_log, ProxyResolver::LoadStateChangedCallback(),
+      error_observer.Pass());
   TestCompletionCallback callback;
-  int rv =
-      resolver->SetPacScript(LoadScriptData(filename), callback.callback());
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  int rv = factory.CreateProxyResolver(LoadScriptData(filename), &resolver,
+                                       callback.callback(), &request);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_TRUE(resolver);
+  return resolver.Pass();
 }
 
 class MockErrorObserver : public ProxyResolverErrorObserver {
  public:
   MockErrorObserver() : event_(true, false) {}
 
   void OnPACScriptError(int line_number, const base::string16& error) override {
     {
       base::AutoLock l(lock_);
       output += base::StringPrintf("Error: line %d: %s\n", line_number,
@@ skipping 16 matching lines @@
   std::string output;
 
   base::WaitableEvent event_;
 };
 
 TEST_F(ProxyResolverV8TracingTest, Simple) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
-  InitResolver(&resolver, "simple.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      &log, &host_resolver, make_scoped_ptr(error_observer), "simple.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info, callback.callback(),
-      NULL, request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ("foo:99", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 
   // There were no errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- nothing was logged.
   EXPECT_EQ(0u, log.GetSize());
   EXPECT_EQ(0u, request_log.GetSize());
 }
 
 TEST_F(ProxyResolverV8TracingTest, JavascriptError) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
-  InitResolver(&resolver, "error.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      &log, &host_resolver, make_scoped_ptr(error_observer), "error.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://throw-an-error/"), &proxy_info, callback.callback(), NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://throw-an-error/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult());
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 
   EXPECT_EQ("Error: line 5: Uncaught TypeError: Cannot read property 'split' "
             "of null\n", error_observer->GetOutput());
 
   // Check the NetLogs -- there was 1 alert and 1 javascript error, and they
@@ skipping 16 matching lines @@
     EXPECT_EQ("{\"line_number\":5,\"message\":\"Uncaught TypeError: Cannot "
               "read property 'split' of null\"}", entries[1].GetParamsJson());
   }
 }
 
 TEST_F(ProxyResolverV8TracingTest, TooManyAlerts) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
-  InitResolver(&resolver, "too_many_alerts.js");
+  scoped_ptr<ProxyResolver> resolver =
+      CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
+                     "too_many_alerts.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"),
-      &proxy_info,
-      callback.callback(),
-      NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Iteration1 does a DNS resolve
   // Iteration2 exceeds the alert buffer
   // Iteration3 runs in blocking mode and completes
   EXPECT_EQ("foo:3", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(1u, host_resolver.num_resolve());
@@ skipping 18 matching lines @@
   }
 }
 
 // Verify that buffered alerts cannot grow unboundedly, even when the message is
 // empty string.
 TEST_F(ProxyResolverV8TracingTest, TooManyEmptyAlerts) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
-  InitResolver(&resolver, "too_many_empty_alerts.js");
+  scoped_ptr<ProxyResolver> resolver =
+      CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
+                     "too_many_empty_alerts.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"),
-      &proxy_info,
-      callback.callback(),
-      NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ("foo:3", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(1u, host_resolver.num_resolve());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
@@ skipping 16 matching lines @@
 }
 
 // This test runs a PAC script that issues a sequence of DNS resolves. The test
 // verifies the final result, and that the underlying DNS resolver received
 // the correct set of queries.
 TEST_F(ProxyResolverV8TracingTest, Dns) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRuleForAddressFamily(
       "host1", ADDRESS_FAMILY_IPV4, "166.155.144.44");
   host_resolver.rules()
       ->AddIPLiteralRule("host1", "::1,192.168.1.1", std::string());
   host_resolver.rules()->AddSimulatedFailure("host2");
   host_resolver.rules()->AddRule("host3", "166.155.144.33");
   host_resolver.rules()->AddRule("host5", "166.155.144.55");
   host_resolver.rules()->AddSimulatedFailure("host6");
   host_resolver.rules()->AddRuleForAddressFamily(
       "*", ADDRESS_FAMILY_IPV4, "122.133.144.155");
   host_resolver.rules()->AddRule("*", "133.122.100.200");
 
-  InitResolver(&resolver, "dns.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      &log, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"),
-      &proxy_info,
-      callback.callback(),
-      NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // The test does 13 DNS resolution, however only 7 of them are unique.
   EXPECT_EQ(7u, host_resolver.num_resolve());
 
   const char* kExpectedResult =
     "122.133.144.155-"  // myIpAddress()
     "null-"  // dnsResolve('')
@@ skipping 32 matching lines @@
 }
 
 // This test runs a PAC script that does "myIpAddress()" followed by
 // "dnsResolve()". This requires 2 restarts. However once the HostResolver's
 // cache is warmed, subsequent calls should take 0 restarts.
 TEST_F(ProxyResolverV8TracingTest, DnsChecksCache) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("foopy", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
-  InitResolver(&resolver, "simple_dns.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      &log, &host_resolver, make_scoped_ptr(error_observer), "simple_dns.js");
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foopy/req1"),
-      &proxy_info,
-      callback1.callback(),
-      NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
+                               callback1.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback1.WaitForResult());
 
   // The test does 2 DNS resolutions.
   EXPECT_EQ(2u, host_resolver.num_resolve());
 
   // The first request took 2 restarts, hence on g_iteration=3.
   EXPECT_EQ("166.155.144.11:3", proxy_info.proxy_server().ToURI());
 
-  rv = resolver.GetProxyForURL(
-      GURL("http://foopy/req2"),
-      &proxy_info,
-      callback2.callback(),
-      NULL,
-      request_log.bound());
+  rv =
+      resolver->GetProxyForURL(GURL("http://foopy/req2"), &proxy_info,
+                               callback2.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback2.WaitForResult());
 
   EXPECT_EQ(4u, host_resolver.num_resolve());
 
   // This time no restarts were required, so g_iteration incremented by 1.
   EXPECT_EQ("166.155.144.11:4", proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   EXPECT_EQ(0u, log.GetSize());
   EXPECT_EQ(0u, request_log.GetSize());
 }
 
 // This test runs a weird PAC script that was designed to defeat the DNS tracing
 // optimization. The proxy resolver should detect the inconsistency and
 // fall-back to synchronous mode execution.
 TEST_F(ProxyResolverV8TracingTest, FallBackToSynchronous1) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host1", "166.155.144.11");
   host_resolver.rules()->AddRule("crazy4", "133.199.111.4");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
-  InitResolver(&resolver, "global_sideffects1.js");
+  scoped_ptr<ProxyResolver> resolver =
+      CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
+                     "global_sideffects1.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info, callback.callback(), NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // The script itself only does 2 DNS resolves per execution, however it
   // constructs the hostname using a global counter which changes on each
   // invocation.
   EXPECT_EQ(3u, host_resolver.num_resolve());
 
   EXPECT_EQ("166.155.144.11-133.199.111.4:100",
             proxy_info.proxy_server().ToURI());
@@ skipping 18 matching lines @@
 }
 
 // This test runs a weird PAC script that was designed to defeat the DNS tracing
 // optimization. The proxy resolver should detect the inconsistency and
 // fall-back to synchronous mode execution.
 TEST_F(ProxyResolverV8TracingTest, FallBackToSynchronous2) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host1", "166.155.144.11");
   host_resolver.rules()->AddRule("host2", "166.155.144.22");
   host_resolver.rules()->AddRule("host3", "166.155.144.33");
   host_resolver.rules()->AddRule("host4", "166.155.144.44");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
-  InitResolver(&resolver, "global_sideffects2.js");
+  scoped_ptr<ProxyResolver> resolver =
+      CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
+                     "global_sideffects2.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info, callback.callback(), NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ(3u, host_resolver.num_resolve());
 
   EXPECT_EQ("166.155.144.44:100", proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- nothing was logged.
   EXPECT_EQ(0u, log.GetSize());
   EXPECT_EQ(0u, request_log.GetSize());
 }
 
 // This test runs a weird PAC script that yields a never ending sequence
 // of DNS resolves when restarting. Running it will hit the maximum
 // DNS resolves per request limit (20) after which every DNS resolve will
 // fail.
 TEST_F(ProxyResolverV8TracingTest, InfiniteDNSSequence) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host*", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
-  InitResolver(&resolver, "global_sideffects3.js");
+  scoped_ptr<ProxyResolver> resolver =
+      CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
+                     "global_sideffects3.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info, callback.callback(), NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ(20u, host_resolver.num_resolve());
 
   EXPECT_EQ(
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
@@ skipping 10 matching lines @@
 
 // This test runs a weird PAC script that yields a never ending sequence
 // of DNS resolves when restarting. Running it will hit the maximum
 // DNS resolves per request limit (20) after which every DNS resolve will
 // fail.
 TEST_F(ProxyResolverV8TracingTest, InfiniteDNSSequence2) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host*", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
-  InitResolver(&resolver, "global_sideffects4.js");
+  scoped_ptr<ProxyResolver> resolver =
+      CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
+                     "global_sideffects4.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info, callback.callback(), NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ(20u, host_resolver.num_resolve());
 
   EXPECT_EQ("null21:34", proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- 1 alert was logged.
   EXPECT_EQ(1u, log.GetSize());
   EXPECT_EQ(1u, request_log.GetSize());
 }
 
 void DnsDuringInitHelper(bool synchronous_host_resolver) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   host_resolver.set_synchronous_mode(synchronous_host_resolver);
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host1", "91.13.12.1");
   host_resolver.rules()->AddRule("host2", "91.13.12.2");
 
-  InitResolver(&resolver, "dns_during_init.js");
+  scoped_ptr<ProxyResolver> resolver =
+      CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
+                     "dns_during_init.js");
 
   // Initialization did 2 dnsResolves.
   EXPECT_EQ(2u, host_resolver.num_resolve());
 
   host_resolver.rules()->ClearRules();
   host_resolver.GetHostCache()->clear();
 
   host_resolver.rules()->AddRule("host1", "145.88.13.3");
   host_resolver.rules()->AddRule("host2", "137.89.8.45");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info, callback.callback(), NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Fetched host1 and host2 again, since the ones done during initialization
   // should not have been cached.
   EXPECT_EQ(4u, host_resolver.num_resolve());
 
   EXPECT_EQ("91.13.12.1-91.13.12.2-145.88.13.3-137.89.8.45:99",
             proxy_info.proxy_server().ToURI());
 
@@ skipping 27 matching lines @@
   CHECK(false);
 }
 
 // Start some requests, cancel them all, and then destroy the resolver.
 // Note the execution order for this test can vary. Since multiple
 // threads are involved, the cancellation may be received a different
 // times.
 TEST_F(ProxyResolverV8TracingTest, CancelAll) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL);
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
-  InitResolver(&resolver, "dns.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   const size_t kNumRequests = 5;
   ProxyInfo proxy_info[kNumRequests];
   ProxyResolver::RequestHandle request[kNumRequests];
 
   for (size_t i = 0; i < kNumRequests; ++i) {
-    int rv = resolver.GetProxyForURL(
-        GURL("http://foo/"), &proxy_info[i],
-        base::Bind(&CrashCallback), &request[i], BoundNetLog());
+    int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info[i],
+                                      base::Bind(&CrashCallback), &request[i],
+                                      BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   for (size_t i = 0; i < kNumRequests; ++i) {
-    resolver.CancelRequest(request[i]);
+    resolver->CancelRequest(request[i]);
   }
 }
 
 // Note the execution order for this test can vary. Since multiple
 // threads are involved, the cancellation may be received a different
 // times.
 TEST_F(ProxyResolverV8TracingTest, CancelSome) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL);
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
-  InitResolver(&resolver, "dns.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
   ProxyResolver::RequestHandle request1;
   ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info1,
-      base::Bind(&CrashCallback), &request1, BoundNetLog());
+  int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info1,
+                                    base::Bind(&CrashCallback), &request1,
+                                    BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info2,
-      callback.callback(), &request2, BoundNetLog());
+  rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info2,
+                                callback.callback(), &request2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  resolver.CancelRequest(request1);
+  resolver->CancelRequest(request1);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Cancel a request after it has finished running on the worker thread, and has
 // posted a task the completion task back to origin thread.
 TEST_F(ProxyResolverV8TracingTest, CancelWhilePendingCompletionTask) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL);
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
-  InitResolver(&resolver, "error.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      nullptr, &host_resolver, make_scoped_ptr(error_observer), "error.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
   ProxyInfo proxy_info3;
   ProxyResolver::RequestHandle request1;
   ProxyResolver::RequestHandle request2;
   ProxyResolver::RequestHandle request3;
   TestCompletionCallback callback;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info1,
-      base::Bind(&CrashCallback), &request1, BoundNetLog());
+  int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info1,
+                                    base::Bind(&CrashCallback), &request1,
+                                    BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  rv = resolver.GetProxyForURL(
-      GURL("http://throw-an-error/"), &proxy_info2,
-      callback.callback(), &request2, BoundNetLog());
+  rv = resolver->GetProxyForURL(GURL("http://throw-an-error/"), &proxy_info2,
+                                callback.callback(), &request2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait until the first request has finished running on the worker thread.
   // (The second request will output an error).
   error_observer->WaitForOutput();
 
   // Cancel the first request, while it has a pending completion task on
   // the origin thread.
-  resolver.CancelRequest(request1);
+  resolver->CancelRequest(request1);
 
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult());
 
   // Start another request, to make sure it is able to complete.
-  rv = resolver.GetProxyForURL(
-      GURL("http://i-have-no-idea-what-im-doing/"), &proxy_info3,
-      callback.callback(), &request3, BoundNetLog());
+  rv = resolver->GetProxyForURL(GURL("http://i-have-no-idea-what-im-doing/"),
+                                &proxy_info3, callback.callback(), &request3,
+                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ("i-approve-this-message:42",
             proxy_info3.proxy_server().ToURI());
 }
 
 // This implementation of HostResolver allows blocking until a resolve request
 // has been received. The resolve requests it receives will never be completed.
@@ skipping 60 matching lines @@
   int num_cancelled_requests_;
   bool waiting_for_resolve_;
   base::Callback<void(void)> action_;
 };
 
 // This cancellation test exercises a more predictable cancellation codepath --
 // when the request has an outstanding DNS request in flight.
 TEST_F(ProxyResolverV8TracingTest, CancelWhileOutstandingNonBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL);
 
-  InitResolver(&resolver, "dns.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
   ProxyResolver::RequestHandle request1;
   ProxyResolver::RequestHandle request2;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/req1"), &proxy_info1,
-      base::Bind(&CrashCallback), &request1, BoundNetLog());
+  int rv = resolver->GetProxyForURL(GURL("http://foo/req1"), &proxy_info1,
+                                    base::Bind(&CrashCallback), &request1,
+                                    BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   host_resolver.WaitUntilRequestIsReceived();
 
-  rv = resolver.GetProxyForURL(
-      GURL("http://foo/req2"), &proxy_info2,
-      base::Bind(&CrashCallback), &request2, BoundNetLog());
+  rv = resolver->GetProxyForURL(GURL("http://foo/req2"), &proxy_info2,
+                                base::Bind(&CrashCallback), &request2,
+                                BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   host_resolver.WaitUntilRequestIsReceived();
 
-  resolver.CancelRequest(request1);
-  resolver.CancelRequest(request2);
+  resolver->CancelRequest(request1);
+  resolver->CancelRequest(request2);
 
   EXPECT_EQ(2, host_resolver.num_cancelled_requests());
 
   // After leaving this scope, the ProxyResolver is destroyed.
   // This should not cause any problems, as the outstanding work
   // should have been cancelled.
 }
 
-void CancelRequestAndPause(ProxyResolverV8Tracing* resolver,
+void CancelRequestAndPause(ProxyResolver* resolver,
                            ProxyResolver::RequestHandle request) {
   resolver->CancelRequest(request);
 
   // Sleep for a little bit. This makes it more likely for the worker
   // thread to have returned from its call, and serves as a regression
   // test for http://crbug.com/173373.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30));
 }
 
 // In non-blocking mode, the worker thread actually does block for
 // a short time to see if the result is in the DNS cache. Test
 // cancellation while the worker thread is waiting on this event.
 TEST_F(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL);
 
-  InitResolver(&resolver, "dns.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
   ProxyResolver::RequestHandle request;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info,
-      base::Bind(&CrashCallback), &request, BoundNetLog());
+  int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                                    base::Bind(&CrashCallback), &request,
+                                    BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   host_resolver.SetAction(
-      base::Bind(CancelRequestAndPause, &resolver, request));
+      base::Bind(CancelRequestAndPause, resolver.get(), request));
 
   host_resolver.WaitUntilRequestIsReceived();
 
   // At this point the host resolver ran Resolve(), and should have cancelled
   // the request.
 
   EXPECT_EQ(1, host_resolver.num_cancelled_requests());
 }
 
 // Cancel the request while there is a pending DNS request, however before
 // the request is sent to the host resolver.
 TEST_F(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns2) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL);
 
-  InitResolver(&resolver, "dns.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
   ProxyResolver::RequestHandle request;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foo/"), &proxy_info,
-      base::Bind(&CrashCallback), &request, BoundNetLog());
+  int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
+                                    base::Bind(&CrashCallback), &request,
+                                    BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait a bit, so the DNS task has hopefully been posted. The test will
   // work whatever the delay is here, but it is most useful if the delay
   // is large enough to allow a task to be posted back.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
-  resolver.CancelRequest(request);
+  resolver->CancelRequest(request);
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 }
 
-TEST_F(ProxyResolverV8TracingTest, CancelSetPacWhileOutstandingBlockingDns) {
+TEST_F(ProxyResolverV8TracingTest,
+       CancelCreateResolverWhileOutstandingBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL);
+  SingleShotProxyResolverFactoryV8Tracing factory(
+      &host_resolver, nullptr, ProxyResolver::LoadStateChangedCallback(),
+      make_scoped_ptr(error_observer));
 
-  int rv =
-      resolver.SetPacScript(LoadScriptData("dns_during_init.js"),
-      base::Bind(&CrashCallback));
+  scoped_ptr<ProxyResolver> resolver;
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  int rv = factory.CreateProxyResolver(LoadScriptData("dns_during_init.js"),
+                                       &resolver, base::Bind(&CrashCallback),
+                                       &request);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   host_resolver.WaitUntilRequestIsReceived();
 
-  resolver.CancelSetPacScript();
+  request.reset();
   EXPECT_EQ(1, host_resolver.num_cancelled_requests());
 }
 
+TEST_F(ProxyResolverV8TracingTest, DeleteFactoryWhileOutstandingBlockingDns) {
+  BlockableHostResolver host_resolver;
+  MockErrorObserver* error_observer = new MockErrorObserver;
+
+  scoped_ptr<ProxyResolver> resolver;
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  {
+    SingleShotProxyResolverFactoryV8Tracing factory(
+        &host_resolver, nullptr, ProxyResolver::LoadStateChangedCallback(),
+        make_scoped_ptr(error_observer));
+
+    int rv = factory.CreateProxyResolver(LoadScriptData("dns_during_init.js"),
+                                         &resolver, base::Bind(&CrashCallback),
+                                         &request);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
+    host_resolver.WaitUntilRequestIsReceived();
+  }
+  EXPECT_EQ(1, host_resolver.num_cancelled_requests());
+}
+
+TEST_F(ProxyResolverV8TracingTest, ErrorLoadingScript) {
+  BlockableHostResolver host_resolver;
+  MockErrorObserver* error_observer = new MockErrorObserver;
+
+  SingleShotProxyResolverFactoryV8Tracing factory(
+      &host_resolver, nullptr, ProxyResolver::LoadStateChangedCallback(),
+      make_scoped_ptr(error_observer));
+
+  scoped_ptr<ProxyResolver> resolver;
+  scoped_ptr<ProxyResolverFactory::Request> request;
+  TestCompletionCallback callback;
+  int rv =
+      factory.CreateProxyResolver(LoadScriptData("error_on_load.js"), &resolver,
+                                  callback.callback(), &request);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult());
+  EXPECT_FALSE(resolver);
+}
+
 // This tests that the execution of a PAC script is terminated when the DNS
 // dependencies are missing. If the test fails, then it will hang.
 TEST_F(ProxyResolverV8TracingTest, Terminate) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
-  ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host1", "182.111.0.222");
   host_resolver.rules()->AddRule("host2", "111.33.44.55");
 
-  InitResolver(&resolver, "terminate.js");
+  scoped_ptr<ProxyResolver> resolver = CreateResolver(
+      &log, &host_resolver, make_scoped_ptr(error_observer), "terminate.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  int rv = resolver.GetProxyForURL(
-      GURL("http://foopy/req1"),
-      &proxy_info,
-      callback.callback(),
-      NULL,
-      request_log.bound());
+  int rv =
+      resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // The test does 2 DNS resolutions.
   EXPECT_EQ(2u, host_resolver.num_resolve());
 
   EXPECT_EQ("foopy:3", proxy_info.proxy_server().ToURI());
 
   // No errors.
@@ skipping 16 matching lines @@
       "host1", ADDRESS_FAMILY_IPV4, "166.155.144.44");
   host_resolver0.rules()
       ->AddIPLiteralRule("host1", "::1,192.168.1.1", std::string());
   host_resolver0.rules()->AddSimulatedFailure("host2");
   host_resolver0.rules()->AddRule("host3", "166.155.144.33");
   host_resolver0.rules()->AddRule("host5", "166.155.144.55");
   host_resolver0.rules()->AddSimulatedFailure("host6");
   host_resolver0.rules()->AddRuleForAddressFamily(
       "*", ADDRESS_FAMILY_IPV4, "122.133.144.155");
   host_resolver0.rules()->AddRule("*", "133.122.100.200");
-  ProxyResolverV8Tracing resolver0(
-      &host_resolver0, new MockErrorObserver, NULL);
-  InitResolver(&resolver0, "dns.js");
+  scoped_ptr<ProxyResolver> resolver0 =
+      CreateResolver(nullptr, &host_resolver0,
+                     make_scoped_ptr(new MockErrorObserver), "dns.js");
 
   // ------------------------
   // Setup resolver1
   // ------------------------
-  ProxyResolverV8Tracing resolver1(
-      &host_resolver0, new MockErrorObserver, NULL);
-  InitResolver(&resolver1, "dns.js");
+  scoped_ptr<ProxyResolver> resolver1 =
+      CreateResolver(nullptr, &host_resolver0,
+                     make_scoped_ptr(new MockErrorObserver), "dns.js");
 
   // ------------------------
   // Setup resolver2
   // ------------------------
-  ProxyResolverV8Tracing resolver2(
-      &host_resolver0, new MockErrorObserver, NULL);
-  InitResolver(&resolver2, "simple.js");
+  scoped_ptr<ProxyResolver> resolver2 =
+      CreateResolver(nullptr, &host_resolver0,
+                     make_scoped_ptr(new MockErrorObserver), "simple.js");
 
   // ------------------------
   // Setup resolver3
   // ------------------------
   MockHostResolver host_resolver3;
   host_resolver3.rules()->AddRule("foo", "166.155.144.33");
-  ProxyResolverV8Tracing resolver3(
-      &host_resolver3, new MockErrorObserver, NULL);
-  InitResolver(&resolver3, "simple_dns.js");
+  scoped_ptr<ProxyResolver> resolver3 =
+      CreateResolver(nullptr, &host_resolver3,
+                     make_scoped_ptr(new MockErrorObserver), "simple_dns.js");
 
   // ------------------------
   // Queue up work for each resolver (which will be running in parallel).
   // ------------------------
 
-  ProxyResolverV8Tracing* resolver[] = {
-    &resolver0, &resolver1, &resolver2, &resolver3,
+  ProxyResolver* resolver[] = {
+      resolver0.get(), resolver1.get(), resolver2.get(), resolver3.get(),
   };
 
   const size_t kNumResolvers = arraysize(resolver);
   const size_t kNumIterations = 20;
   const size_t kNumResults = kNumResolvers * kNumIterations;
   TestCompletionCallback callback[kNumResults];
   ProxyInfo proxy_info[kNumResults];
 
   for (size_t i = 0; i < kNumResults; ++i) {
     size_t resolver_i = i % kNumResolvers;
@@ skipping 38 matching lines @@
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net