Split ProxyResolverV8Tracing into an implementation and a wrapper.

net/proxy/proxy_resolver_v8_tracing_wrapper_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 "net/proxy/proxy_resolver_v8_tracing_wrapper.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"
@@ skipping 10 matching lines @@
 #include "net/log/test_net_log_util.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 ProxyResolverV8TracingTest : public testing::Test {
+class ProxyResolverV8TracingWrapperTest : 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) {
@@ skipping 19 matching lines @@
     scoped_ptr<ProxyResolverErrorObserver> error_observer) {
   return error_observer;
 }
 
 scoped_ptr<ProxyResolver> CreateResolver(
     NetLog* net_log,
     HostResolver* host_resolver,
     scoped_ptr<ProxyResolverErrorObserver> error_observer,
     const char* filename) {
   scoped_ptr<ProxyResolver> resolver;
-  ProxyResolverFactoryV8Tracing factory(
-      host_resolver, net_log, ProxyResolver::LoadStateChangedCallback(),
+  ProxyResolverFactoryV8TracingWrapper factory(
+      host_resolver, net_log,
       base::Bind(&ReturnErrorObserver, base::Passed(&error_observer)));
   TestCompletionCallback 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,
                                    base::UTF16ToASCII(error).c_str());
     }
     event_.Signal();
   }
 
   std::string GetOutput() {
     base::AutoLock l(lock_);
     return output;
   }
 
-  void WaitForOutput() {
-    event_.Wait();
-  }
+  void WaitForOutput() { event_.Wait(); }
 
  private:
   base::Lock lock_;
   std::string output;
 
   base::WaitableEvent event_;
 };
 
-TEST_F(ProxyResolverV8TracingTest, Simple) {
+TEST_F(ProxyResolverV8TracingWrapperTest, Simple) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       &log, &host_resolver, make_scoped_ptr(error_observer), "simple.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
@@ skipping 10 matching lines @@
   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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, JavascriptError) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   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());
 
   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());
+  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
   // were output to both the global log, and per-request log.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(2u, entries.size());
-    EXPECT_TRUE(
-        LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                         NetLog::PHASE_NONE));
-    EXPECT_TRUE(
-        LogContainsEvent(entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
-                         NetLog::PHASE_NONE));
+    EXPECT_TRUE(LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+                                 NetLog::PHASE_NONE));
+    EXPECT_TRUE(LogContainsEvent(entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
+                                 NetLog::PHASE_NONE));
 
     EXPECT_EQ("{\"message\":\"Prepare to DIE!\"}", entries[0].GetParamsJson());
-    EXPECT_EQ("{\"line_number\":5,\"message\":\"Uncaught TypeError: Cannot "
-              "read property 'split' of null\"}", entries[1].GetParamsJson());
+    EXPECT_EQ(
+        "{\"line_number\":5,\"message\":\"Uncaught TypeError: Cannot "
+        "read property 'split' of null\"}",
+        entries[1].GetParamsJson());
   }
 }
 
-TEST_F(ProxyResolverV8TracingTest, TooManyAlerts) {
+TEST_F(ProxyResolverV8TracingWrapperTest, TooManyAlerts) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   scoped_ptr<ProxyResolver> resolver =
       CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
                      "too_many_alerts.js");
 
   TestCompletionCallback callback;
@@ skipping 19 matching lines @@
   // Check the NetLogs -- the script generated 50 alerts, which were mirrored
   // to both the global and per-request logs.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(50u, entries.size());
     for (size_t i = 0; i < entries.size(); ++i) {
-      ASSERT_TRUE(
-          LogContainsEvent(entries, i, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                           NetLog::PHASE_NONE));
+      ASSERT_TRUE(LogContainsEvent(
+          entries, i, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, NetLog::PHASE_NONE));
     }
   }
 }
 
 // Verify that buffered alerts cannot grow unboundedly, even when the message is
 // empty string.
-TEST_F(ProxyResolverV8TracingTest, TooManyEmptyAlerts) {
+TEST_F(ProxyResolverV8TracingWrapperTest, TooManyEmptyAlerts) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   scoped_ptr<ProxyResolver> resolver =
       CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
                      "too_many_empty_alerts.js");
 
   TestCompletionCallback callback;
@@ skipping 16 matching lines @@
   // Check the NetLogs -- the script generated 50 alerts, which were mirrored
   // to both the global and per-request logs.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(1000u, entries.size());
     for (size_t i = 0; i < entries.size(); ++i) {
-      ASSERT_TRUE(
-          LogContainsEvent(entries, i, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                           NetLog::PHASE_NONE));
+      ASSERT_TRUE(LogContainsEvent(
+          entries, i, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, NetLog::PHASE_NONE));
     }
   }
 }
 
 // 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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, Dns) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
-  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()->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()->AddRuleForAddressFamily("*", ADDRESS_FAMILY_IPV4,
+                                                 "122.133.144.155");
   host_resolver.rules()->AddRule("*", "133.122.100.200");
 
   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());
 
   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('')
-    "__1_192.168.1.1-"  // dnsResolveEx('host1')
-    "null-"  // dnsResolve('host2')
-    "166.155.144.33-"  // dnsResolve('host3')
-    "122.133.144.155-"  // myIpAddress()
-    "166.155.144.33-"  // dnsResolve('host3')
-    "__1_192.168.1.1-"  // dnsResolveEx('host1')
-    "122.133.144.155-"  // myIpAddress()
-    "null-"  // dnsResolve('host2')
-    "-"  // dnsResolveEx('host6')
-    "133.122.100.200-"  // myIpAddressEx()
-    "166.155.144.44"  // dnsResolve('host1')
-    ":99";
+      "122.133.144.155-"  // myIpAddress()
+      "null-"             // dnsResolve('')
+      "__1_192.168.1.1-"  // dnsResolveEx('host1')
+      "null-"             // dnsResolve('host2')
+      "166.155.144.33-"   // dnsResolve('host3')
+      "122.133.144.155-"  // myIpAddress()
+      "166.155.144.33-"   // dnsResolve('host3')
+      "__1_192.168.1.1-"  // dnsResolveEx('host1')
+      "122.133.144.155-"  // myIpAddress()
+      "null-"             // dnsResolve('host2')
+      "-"                 // dnsResolveEx('host6')
+      "133.122.100.200-"  // myIpAddressEx()
+      "166.155.144.44"    // dnsResolve('host1')
+      ":99";
 
   EXPECT_EQ(kExpectedResult, proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- the script generated 1 alert, mirrored to both
   // the per-request and global logs.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(1u, entries.size());
-    EXPECT_TRUE(
-        LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                         NetLog::PHASE_NONE));
+    EXPECT_TRUE(LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+                                 NetLog::PHASE_NONE));
     EXPECT_EQ("{\"message\":\"iteration: 7\"}", entries[0].GetParamsJson());
   }
 }
 
 // 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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, DnsChecksCache) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddRule("foopy", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       &log, &host_resolver, make_scoped_ptr(error_observer), "simple_dns.js");
@@ skipping 30 matching lines @@
   // 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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, FallBackToSynchronous1) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   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");
 
   scoped_ptr<ProxyResolver> resolver =
@@ skipping 22 matching lines @@
 
   // Check the NetLogs -- the script generated 1 alert, mirrored to both
   // the per-request and global logs.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(1u, entries.size());
-    EXPECT_TRUE(
-        LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                         NetLog::PHASE_NONE));
+    EXPECT_TRUE(LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+                                 NetLog::PHASE_NONE));
     EXPECT_EQ("{\"message\":\"iteration: 4\"}", entries[0].GetParamsJson());
   }
 }
 
 // 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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, FallBackToSynchronous2) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   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");
@@ skipping 20 matching lines @@
 
   // 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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, InfiniteDNSSequence) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddRule("host*", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   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());
   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-"
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
-      "null:21", proxy_info.proxy_server().ToURI());
+      "null:21",
+      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());
 }
 
 // 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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, InfiniteDNSSequence2) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddRule("host*", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   scoped_ptr<ProxyResolver> resolver =
       CreateResolver(&log, &host_resolver, make_scoped_ptr(error_observer),
@@ skipping 58 matching lines @@
 
   EXPECT_EQ("91.13.12.1-91.13.12.2-145.88.13.3-137.89.8.45:99",
             proxy_info.proxy_server().ToURI());
 
   // Check the NetLogs -- the script generated 2 alerts during initialization.
   EXPECT_EQ(0u, request_log.GetSize());
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
 
   ASSERT_EQ(2u, entries.size());
-  EXPECT_TRUE(
-      LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                       NetLog::PHASE_NONE));
-  EXPECT_TRUE(
-      LogContainsEvent(entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                       NetLog::PHASE_NONE));
+  EXPECT_TRUE(LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+                               NetLog::PHASE_NONE));
+  EXPECT_TRUE(LogContainsEvent(entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+                               NetLog::PHASE_NONE));
 
   EXPECT_EQ("{\"message\":\"Watsup\"}", entries[0].GetParamsJson());
   EXPECT_EQ("{\"message\":\"Watsup2\"}", entries[1].GetParamsJson());
 }
 
 // Tests a PAC script which does DNS resolves during initialization.
-TEST_F(ProxyResolverV8TracingTest, DnsDuringInit) {
+TEST_F(ProxyResolverV8TracingWrapperTest, DnsDuringInit) {
   // Test with both both a host resolver that always completes asynchronously,
   // and then again with one that completes synchronously.
   DnsDuringInitHelper(false);
   DnsDuringInitHelper(true);
 }
 
 void CrashCallback(int) {
   // Be extra sure that if the callback ever gets invoked, the test will fail.
   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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, CancelAll) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   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());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   for (size_t i = 0; i < kNumRequests; ++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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, CancelSome) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
@@ skipping 10 matching lines @@
                                 callback.callback(), &request2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhilePendingCompletionTask) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "error.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
@@ skipping 23 matching lines @@
   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());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
-  EXPECT_EQ("i-approve-this-message:42",
-            proxy_info3.proxy_server().ToURI());
+  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.
 class BlockableHostResolver : public HostResolver {
  public:
   BlockableHostResolver()
       : num_cancelled_requests_(0), waiting_for_resolve_(false) {}
 
   int Resolve(const RequestInfo& info,
@@ skipping 27 matching lines @@
                        const BoundNetLog& net_log) override {
     NOTREACHED();
     return ERR_DNS_CACHE_MISS;
   }
 
   void CancelRequest(RequestHandle req) override {
     EXPECT_EQ(reinterpret_cast<RequestHandle*>(1), req);
     num_cancelled_requests_++;
   }
 
-  void SetAction(const base::Callback<void(void)>& action) {
-    action_ = action;
-  }
+  void SetAction(const base::Callback<void(void)>& action) { action_ = action; }
 
   // Waits until Resolve() has been called.
   void WaitUntilRequestIsReceived() {
     waiting_for_resolve_ = true;
     base::MessageLoop::current()->Run();
     DCHECK(waiting_for_resolve_);
     waiting_for_resolve_ = false;
   }
 
-  int num_cancelled_requests() const {
-    return num_cancelled_requests_;
-  }
+  int num_cancelled_requests() const { return num_cancelled_requests_; }
 
  private:
   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) {
+TEST_F(ProxyResolverV8TracingWrapperTest,
+       CancelWhileOutstandingNonBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   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;
@@ skipping 30 matching lines @@
 
   // 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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   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());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   host_resolver.SetAction(
       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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns2) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   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());
 
   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);
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 }
 
-TEST_F(ProxyResolverV8TracingTest,
+TEST_F(ProxyResolverV8TracingWrapperTest,
        CancelCreateResolverWhileOutstandingBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
-  ProxyResolverFactoryV8Tracing factory(
-      &host_resolver, nullptr, ProxyResolver::LoadStateChangedCallback(),
+  ProxyResolverFactoryV8TracingWrapper factory(
+      &host_resolver, nullptr,
       base::Bind(&ReturnErrorObserver,
                  base::Passed(make_scoped_ptr(error_observer))));
 
   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();
 
   request.reset();
   EXPECT_EQ(1, host_resolver.num_cancelled_requests());
 }
 
-TEST_F(ProxyResolverV8TracingTest, DeleteFactoryWhileOutstandingBlockingDns) {
+TEST_F(ProxyResolverV8TracingWrapperTest,
+       DeleteFactoryWhileOutstandingBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   scoped_ptr<ProxyResolver> resolver;
   scoped_ptr<ProxyResolverFactory::Request> request;
   {
-    ProxyResolverFactoryV8Tracing factory(
-        &host_resolver, nullptr, ProxyResolver::LoadStateChangedCallback(),
+    ProxyResolverFactoryV8TracingWrapper factory(
+        &host_resolver, nullptr,
         base::Bind(&ReturnErrorObserver,
                    base::Passed(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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, ErrorLoadingScript) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
-  ProxyResolverFactoryV8Tracing factory(
-      &host_resolver, nullptr, ProxyResolver::LoadStateChangedCallback(),
+  ProxyResolverFactoryV8TracingWrapper factory(
+      &host_resolver, nullptr,
       base::Bind(&ReturnErrorObserver,
                  base::Passed(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) {
+TEST_F(ProxyResolverV8TracingWrapperTest, Terminate) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddRule("host1", "182.111.0.222");
   host_resolver.rules()->AddRule("host2", "111.33.44.55");
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       &log, &host_resolver, make_scoped_ptr(error_observer), "terminate.js");
@@ skipping 13 matching lines @@
 
   EXPECT_EQ("foopy:3", proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   EXPECT_EQ(0u, log.GetSize());
   EXPECT_EQ(0u, request_log.GetSize());
 }
 
-// Tests that multiple instances of ProxyResolverV8Tracing can coexist and run
-// correctly at the same time. This is relevant because at the moment (time
-// this test was written) each ProxyResolverV8Tracing creates its own thread to
-// run V8 on, however each thread is operating on the same v8::Isolate.
-TEST_F(ProxyResolverV8TracingTest, MultipleResolvers) {
+// Tests that multiple instances of ProxyResolverV8TracingWrapper can coexist
+// and run correctly at the same time. This is relevant because at the moment
+// (time this test was written) each ProxyResolverV8TracingWrapper creates its
+// own thread to run V8 on, however each thread is operating on the same
+// v8::Isolate.
+TEST_F(ProxyResolverV8TracingWrapperTest, MultipleResolvers) {
   // ------------------------
   // Setup resolver0
   // ------------------------
   MockHostResolver host_resolver0;
-  host_resolver0.rules()->AddRuleForAddressFamily(
-      "host1", ADDRESS_FAMILY_IPV4, "166.155.144.44");
-  host_resolver0.rules()
-      ->AddIPLiteralRule("host1", "::1,192.168.1.1", std::string());
+  host_resolver0.rules()->AddRuleForAddressFamily("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()->AddRuleForAddressFamily("*", ADDRESS_FAMILY_IPV4,
+                                                  "122.133.144.155");
   host_resolver0.rules()->AddRule("*", "133.122.100.200");
   scoped_ptr<ProxyResolver> resolver0 =
       CreateResolver(nullptr, &host_resolver0,
                      make_scoped_ptr(new MockErrorObserver), "dns.js");
 
   // ------------------------
   // Setup resolver1
   // ------------------------
   scoped_ptr<ProxyResolver> resolver1 =
       CreateResolver(nullptr, &host_resolver0,
@@ skipping 35 matching lines @@
         GURL("http://foo/"), &proxy_info[i], callback[i].callback(), NULL,
         BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   // ------------------------
   // Verify all of the results.
   // ------------------------
 
   const char* kExpectedForDnsJs =
-    "122.133.144.155-"  // myIpAddress()
-    "null-"  // dnsResolve('')
-    "__1_192.168.1.1-"  // dnsResolveEx('host1')
-    "null-"  // dnsResolve('host2')
-    "166.155.144.33-"  // dnsResolve('host3')
-    "122.133.144.155-"  // myIpAddress()
-    "166.155.144.33-"  // dnsResolve('host3')
-    "__1_192.168.1.1-"  // dnsResolveEx('host1')
-    "122.133.144.155-"  // myIpAddress()
-    "null-"  // dnsResolve('host2')
-    "-"  // dnsResolveEx('host6')
-    "133.122.100.200-"  // myIpAddressEx()
-    "166.155.144.44"  // dnsResolve('host1')
-    ":99";
+      "122.133.144.155-"  // myIpAddress()
+      "null-"             // dnsResolve('')
+      "__1_192.168.1.1-"  // dnsResolveEx('host1')
+      "null-"             // dnsResolve('host2')
+      "166.155.144.33-"   // dnsResolve('host3')
+      "122.133.144.155-"  // myIpAddress()
+      "166.155.144.33-"   // dnsResolve('host3')
+      "__1_192.168.1.1-"  // dnsResolveEx('host1')
+      "122.133.144.155-"  // myIpAddress()
+      "null-"             // dnsResolve('host2')
+      "-"                 // dnsResolveEx('host6')
+      "133.122.100.200-"  // myIpAddressEx()
+      "166.155.144.44"    // dnsResolve('host1')
+      ":99";
 
   for (size_t i = 0; i < kNumResults; ++i) {
     size_t resolver_i = i % kNumResolvers;
     EXPECT_EQ(OK, callback[i].WaitForResult());
 
     std::string proxy_uri = proxy_info[i].proxy_server().ToURI();
 
     if (resolver_i == 0 || resolver_i == 1) {
       EXPECT_EQ(kExpectedForDnsJs, proxy_uri);
     } else if (resolver_i == 2) {
       EXPECT_EQ("foo:99", proxy_uri);
     } else if (resolver_i == 3) {
       EXPECT_EQ("166.155.144.33:",
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net