Create a URLRequestContext for PAC fetching.

chrome/browser/net/connection_tester.cc

 // Copyright (c) 2010 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/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/importer/firefox_proxy_settings.h"
-#include "chrome/browser/io_thread.h"
 #include "chrome/common/chrome_switches.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/dnsrr_resolver.h"
 #include "net/base/host_resolver.h"
 #include "net/base/host_resolver_impl.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/proxy/proxy_config_service_fixed.h"
+#include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 namespace {
 
 // ExperimentURLRequestContext ------------------------------------------------
 
 // An instance of ExperimentURLRequestContext is created for each experiment
 // run by ConnectionTester. The class initializes network dependencies according
 // to the specified "experiment".
 class ExperimentURLRequestContext : public URLRequestContext {
  public:
-  explicit ExperimentURLRequestContext(IOThread* io_thread)
-      : io_thread_(io_thread) {}
+  explicit ExperimentURLRequestContext(URLRequestContext* proxy_request_context)
+      : proxy_request_context_(proxy_request_context) {}
 
   int Init(const ConnectionTester::Experiment& experiment) {
     int rv;
 
     // Create a custom HostResolver for this experiment.
     rv = CreateHostResolver(experiment.host_resolver_experiment,
                             &host_resolver_);
     if (rv != net::OK)
       return rv;  // Failure.
 
@@ skipping 68 matching lines @@
         return net::ERR_UNEXPECTED;
     }
   }
 
   // Creates a proxy config service for |experiment|. On success returns net::OK
   // and fills |config_service| with a new pointer. Otherwise returns a network
   // error code.
   int CreateProxyConfigService(
       ConnectionTester::ProxySettingsExperiment experiment,
       scoped_ptr<net::ProxyConfigService>* config_service) {
+    scoped_ptr<base::ThreadRestrictions::ScopedAllowIO> allow_io;
     switch (experiment) {
       case ConnectionTester::PROXY_EXPERIMENT_USE_SYSTEM_SETTINGS:
         return CreateSystemProxyConfigService(config_service);
       case ConnectionTester::PROXY_EXPERIMENT_USE_FIREFOX_SETTINGS:
+        // http://crbug.com/67664: This call can lead to blocking IO on the IO
+        // thread.  This is a bug and should be fixed.
+        allow_io.reset(new base::ThreadRestrictions::ScopedAllowIO);
         return CreateFirefoxProxyConfigService(config_service);
       case ConnectionTester::PROXY_EXPERIMENT_USE_AUTO_DETECT:
         config_service->reset(new net::ProxyConfigServiceFixed(
             net::ProxyConfig::CreateAutoDetect()));
         return net::OK;
       case ConnectionTester::PROXY_EXPERIMENT_USE_DIRECT:
         config_service->reset(new net::ProxyConfigServiceFixed(
             net::ProxyConfig::CreateDirect()));
         return net::OK;
       default:
@@ skipping 17 matching lines @@
     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;
     }
 
     *proxy_service = net::ProxyService::CreateUsingV8ProxyResolver(
         config_service.release(),
         0u,
-        io_thread_->CreateAndRegisterProxyScriptFetcher(this),
+        new net::ProxyScriptFetcherImpl(proxy_request_context_),
         host_resolver(),
         NULL);
 
     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(
@@ skipping 26 matching lines @@
 
     net::ProxyConfig config;
     if (firefox_settings.ToProxyConfig(&config)) {
       config_service->reset(new net::ProxyConfigServiceFixed(config));
       return net::OK;
     }
 
     return net::ERR_FAILED;
   }
 
-  IOThread* io_thread_;
+  const scoped_refptr<URLRequestContext> proxy_request_context_;
 };
 
 }  // namespace
 
 // ConnectionTester::TestRunner ----------------------------------------------
 
 // TestRunner is a helper class for running an individual experiment. It can
 // be deleted any time after it is started, and this will abort the request.
 class ConnectionTester::TestRunner : public net::URLRequest::Delegate {
  public:
@@ skipping 67 matching lines @@
   if (!request->status().is_success()) {
     DCHECK_NE(net::ERR_IO_PENDING, request->status().os_error());
     result = request->status().os_error();
   }
   tester_->OnExperimentCompleted(result);
 }
 
 void ConnectionTester::TestRunner::Run(const Experiment& experiment) {
   // Try to create a URLRequestContext for this experiment.
   scoped_refptr<ExperimentURLRequestContext> context(
-      new ExperimentURLRequestContext(tester_->io_thread_));
+      new ExperimentURLRequestContext(tester_->proxy_request_context_));
   int rv = context->Init(experiment);
   if (rv != net::OK) {
     // Complete the experiment with a failure.
     tester_->OnExperimentCompleted(rv);
     return;
   }
 
   // Fetch a request using the experimental context.
   request_.reset(new net::URLRequest(experiment.url, this));
   request_->set_context(context);
   request_->Start();
 }
 
 // ConnectionTester ----------------------------------------------------------
 
-ConnectionTester::ConnectionTester(Delegate* delegate, IOThread* io_thread)
-    : delegate_(delegate), io_thread_(io_thread) {
+ConnectionTester::ConnectionTester(Delegate* delegate,
+                                   URLRequestContext* proxy_request_context)
+    : delegate_(delegate), proxy_request_context_(proxy_request_context) {
   DCHECK(delegate);
-  DCHECK(io_thread);
+  DCHECK(proxy_request_context);
 }
 
 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();
   }
 }