Make the v8 Isolate used in the proxy resolver explicit.

chrome/browser/net/connection_tester.cc

 // Copyright (c) 2012 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 "chrome/browser/net/connection_tester.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 69 matching lines @@
             net::ProxyConfig::CreateDirect()));
         return net::OK;
       default:
         NOTREACHED();
         return net::ERR_UNEXPECTED;
     }
   }
 
   int Init(const ConnectionTester::Experiment& experiment,
            scoped_ptr<net::ProxyConfigService>* proxy_config_service,
+           v8::Isolate* v8_default_isolate,
            net::NetLog* net_log) {
     int rv;
 
     // Create a custom HostResolver for this experiment.
     scoped_ptr<net::HostResolver> host_resolver_tmp;
     rv = CreateHostResolver(experiment.host_resolver_experiment,
                             &host_resolver_tmp);
     if (rv != net::OK)
       return rv;  // Failure.
     storage_.set_host_resolver(host_resolver_tmp.Pass());
 
     // Create a custom ProxyService for this this experiment.
     scoped_ptr<net::ProxyService> experiment_proxy_service;
     rv = CreateProxyService(experiment.proxy_settings_experiment,
-                            proxy_config_service, &experiment_proxy_service);
+                            proxy_config_service, &experiment_proxy_service,
+                            v8_default_isolate);
     if (rv != net::OK)
       return rv;  // Failure.
     storage_.set_proxy_service(experiment_proxy_service.release());
 
     // The rest of the dependencies are standard, and don't depend on the
     // experiment being run.
     storage_.set_cert_verifier(net::CertVerifier::CreateDefault());
 #if !defined(DISABLE_FTP_SUPPORT)
     storage_.set_ftp_transaction_factory(
         new net::FtpNetworkLayer(host_resolver()));
@@ skipping 62 matching lines @@
     host_resolver->swap(resolver);
     return net::OK;
   }
 
   // Creates a proxy service for |experiment|. On success returns net::OK
   // and fills |experiment_proxy_service| with a new pointer. Otherwise returns
   // a network error code.
   int CreateProxyService(
       ConnectionTester::ProxySettingsExperiment experiment,
       scoped_ptr<net::ProxyConfigService>* proxy_config_service,
-      scoped_ptr<net::ProxyService>* experiment_proxy_service) {
+      scoped_ptr<net::ProxyService>* experiment_proxy_service,
+      v8::Isolate* v8_default_isolate) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kSingleProcess)) {
       // We can't create a standard proxy resolver in single-process mode.
       // Rather than falling-back to some other implementation, fail.
       return net::ERR_NOT_IMPLEMENTED;
     }
 
     net::DhcpProxyScriptFetcherFactory dhcp_factory;
     if (CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kDisableDhcpWpad)) {
       dhcp_factory.set_enabled(false);
     }
 
 #if defined(OS_IOS)
     experiment_proxy_service->reset(
         net::ProxyService::CreateUsingSystemProxyResolver(
             proxy_config_service->release(), 0u, NULL));
 #else
     experiment_proxy_service->reset(
         net::CreateProxyServiceUsingV8ProxyResolver(
             proxy_config_service->release(),
             0u,
             new net::ProxyScriptFetcherImpl(proxy_request_context_),
             dhcp_factory.Create(proxy_request_context_),
             host_resolver(),
             NULL,
-            NULL));
+            NULL,
+            v8_default_isolate));
 #endif
 
     return net::OK;
   }
 
   // Creates a proxy config service that pulls from the system proxy settings.
   // On success returns net::OK and fills |config_service| with a new pointer.
   // Otherwise returns a network error code.
   int CreateSystemProxyConfigService(
       scoped_ptr<net::ProxyConfigService>* config_service) {
@@ skipping 178 matching lines @@
   tester_->OnExperimentCompleted(result);
 }
 
 void ConnectionTester::TestRunner::ProxyConfigServiceCreated(
     const Experiment& experiment,
     scoped_ptr<net::ProxyConfigService>* proxy_config_service,
     int status) {
   if (status == net::OK)
     status = request_context_->Init(experiment,
                                     proxy_config_service,
+                                    tester_->v8_default_isolate_,
                                     net_log_);
   if (status != net::OK) {
     tester_->OnExperimentCompleted(status);
     return;
   }
   // Fetch a request using the experimental context.
   request_.reset(request_context_->CreateRequest(experiment.url, this));
   request_->Start();
 }
 
@@ skipping 12 matching lines @@
       proxy_config_service, config_service_callback);
   if (rv != net::ERR_IO_PENDING)
     ProxyConfigServiceCreated(experiment, proxy_config_service, rv);
 }
 
 // ConnectionTester ----------------------------------------------------------
 
 ConnectionTester::ConnectionTester(
     Delegate* delegate,
     net::URLRequestContext* proxy_request_context,
-    net::NetLog* net_log)
+    net::NetLog* net_log,
+    v8::Isolate* v8_default_isolate)
     : delegate_(delegate),
       proxy_request_context_(proxy_request_context),
-      net_log_(net_log) {
+      net_log_(net_log),
+      v8_default_isolate_(v8_default_isolate) {
   DCHECK(delegate);
   DCHECK(proxy_request_context);
+  DCHECK(v8_default_isolate);
 }
 
 ConnectionTester::~ConnectionTester() {
   // Cancellation happens automatically by deleting test_runner_.
 }
 
 void ConnectionTester::RunAllTests(const GURL& url) {
   // Select all possible experiments to run. (In no particular order).
   // It is possible that some of these experiments are actually duplicates.
   GetAllPossibleExperimentCombinations(url, &remaining_experiments_);
@@ skipping 77 matching lines @@
 
   // Notify the delegate of completion.
   delegate_->OnCompletedConnectionTestExperiment(current, result);
 
   if (remaining_experiments_.empty()) {
     delegate_->OnCompletedConnectionTestSuite();
   } else {
     StartNextExperiment();
   }
 }