Extended: Add "system" URLRequestContext

chrome/browser/io_thread.cc

 // Copyright (c) 2011 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/io_thread.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/leak_tracker.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/proxy_config_service_impl.h"
+#endif  // defined(OS_CHROMEOS)
 #include "chrome/browser/gpu_process_host.h"
 #include "chrome/browser/in_process_webkit/indexed_db_key_utility_client.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/net/passive_log_collector.h"
 #include "chrome/browser/net/predictor_api.h"
+#include "chrome/browser/net/pref_proxy_config_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/raw_host_resolver_proc.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "chrome/common/pref_names.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/dnsrr_resolver.h"
 #include "net/base/host_cache.h"
 #include "net/base/host_resolver.h"
 #include "net/base/host_resolver_impl.h"
 #include "net/base/mapped_host_resolver.h"
 #include "net/base/net_util.h"
+#include "net/proxy/proxy_config_service_fixed.h"
 #include "net/http/http_auth_filter.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #if defined(USE_NSS)
 #include "net/ocsp/nss_ocsp.h"
 #endif  // defined(USE_NSS)
 #include "net/proxy/proxy_script_fetcher_impl.h"
 
 namespace {
@@ skipping 140 matching lines @@
       globals->http_auth_handler_factory.get());
   context->set_proxy_service(globals->proxy_script_fetcher_proxy_service.get());
   context->set_http_transaction_factory(
       globals->proxy_script_fetcher_http_transaction_factory.get());
   // In-memory cookie store.
   context->set_cookie_store(new net::CookieMonster(NULL, NULL));
   // TODO(mpcomplete): give it a SystemNetworkDelegate.
   return context;
 }
 
+scoped_refptr<net::URLRequestContext>
+ConstructSystemRequestContext(IOThread::Globals* globals,
+                              net::NetLog* net_log) {
+  scoped_refptr<net::URLRequestContext> context(new net::URLRequestContext);
+  context->set_net_log(net_log);
+  context->set_host_resolver(globals->host_resolver.get());
+  context->set_cert_verifier(globals->cert_verifier.get());
+  context->set_dnsrr_resolver(globals->dnsrr_resolver.get());
+  context->set_http_auth_handler_factory(
+      globals->http_auth_handler_factory.get());
+  context->set_proxy_service(globals->system_proxy_service.get());
+  context->set_http_transaction_factory(
+      globals->system_http_transaction_factory.get());
+  // In-memory cookie store.
+  context->set_cookie_store(new net::CookieMonster(NULL, NULL));
+  return context;
+}
+
 }  // namespace
 
 // The IOThread object must outlive any tasks posted to the IO thread before the
 // Quit task.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(IOThread);
 
 IOThread::Globals::Globals() {}
 
 IOThread::Globals::~Globals() {}
 
@@ skipping 28 matching lines @@
 
 IOThread::Globals* IOThread::globals() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return globals_;
 }
 
 ChromeNetLog* IOThread::net_log() {
   return net_log_;
 }
 
+void IOThread::InitSystemRequestContext(
+    net::ProxyConfigService* config_service) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  message_loop()->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(
+          this,
+          &IOThread::InitSystemRequestContextOnIOThread,
+          config_service));
+}
+
+void IOThread::InitSystemRequestContextOnIOThread(
+    net::ProxyConfigService* config_service) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  size_t num_pac_threads = 0u;  // Use default number of threads.
+  globals_->system_proxy_service =

[willchan no longer on Chromium, 2011/02/08 22:52:04]

I think this code when I wrote it was a bit off. We need to be careful not to
use v8 if we're running in single process mode, so we don't collide with the v8
instance used by the renderer.

[battre, 2011/02/14 18:22:05]

I don't see a code path that could instantiate a V8 Proxy Resolver. Should I add
this feature? (like ::CreateProxyService in chrome_url_request_context.cc)

[willchan no longer on Chromium, 2011/02/15 01:05:58]

Yes. Perhaps you could refactor them both to share the same code?

+      net::ProxyService::CreateUsingSystemProxyResolver(
+          config_service, num_pac_threads, net_log_);
+  net::HttpNetworkSession::Params system_params;
+  system_params.host_resolver = globals_->host_resolver.get();
+  system_params.cert_verifier = globals_->cert_verifier.get();
+  system_params.dnsrr_resolver = globals_->dnsrr_resolver.get();
+  system_params.dns_cert_checker = NULL;
+  system_params.ssl_host_info_factory = NULL;
+  system_params.proxy_service = globals_->system_proxy_service.get();
+  system_params.ssl_config_service = globals_->ssl_config_service.get();
+  system_params.http_auth_handler_factory =
+      globals_->http_auth_handler_factory.get();
+  system_params.network_delegate = &globals_->network_delegate;
+  system_params.net_log = net_log_;
+  globals_->system_http_transaction_factory.reset(
+      new net::HttpNetworkLayer(
+          new net::HttpNetworkSession(system_params)));
+  globals_->system_request_context =
+      ConstructSystemRequestContext(globals_, net_log_);
+}
+
 void IOThread::InitNetworkPredictor(
     bool prefetching_enabled,
     base::TimeDelta max_dns_queue_delay,
     size_t max_speculative_parallel_resolves,
     const chrome_common_net::UrlList& startup_urls,
     ListValue* referral_list,
     bool preconnect_enabled) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   message_loop()->PostTask(
       FROM_HERE,
@@ skipping 251 matching lines @@
     net::HostCache* host_cache =
         globals_->host_resolver.get()->GetAsHostResolverImpl()->cache();
     if (host_cache)
       host_cache->clear();
   }
   // Clear all of the passively logged data.
   // TODO(eroman): this is a bit heavy handed, really all we need to do is
   //               clear the data pertaining to off the record context.
   net_log_->ClearAllPassivelyCapturedEvents();
 }