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/extensions/extension_event_router_forwarder.h"
 #include "chrome/browser/net/chrome_network_delegate.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/net/proxy_service_factory.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 "content/browser/browser_thread.h"
 #include "content/browser/gpu_process_host.h"
 #include "content/browser/in_process_webkit/indexed_db_key_utility_client.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/cookie_monster.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.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));
   context->set_network_delegate(globals->system_network_delegate.get());
   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
 
+class SystemURLRequestContextGetter : public URLRequestContextGetter {
+ public:
+  explicit SystemURLRequestContextGetter(IOThread* io_thread);
+  virtual ~SystemURLRequestContextGetter();
+
+  // Implementation for UrlRequestContextGetter.
+  virtual net::URLRequestContext* GetURLRequestContext();
+  virtual scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() const;
+
+ private:
+  IOThread* const io_thread_;  // Weak pointer, owned by BrowserProcess.
+  scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
+
+  base::debug::LeakTracker<SystemURLRequestContextGetter> leak_tracker_;
+};
+
+SystemURLRequestContextGetter::SystemURLRequestContextGetter(
+    IOThread* io_thread)
+    : io_thread_(io_thread),
+      io_message_loop_proxy_(io_thread->message_loop_proxy()) {
+}
+
+SystemURLRequestContextGetter::~SystemURLRequestContextGetter() {}
+
+net::URLRequestContext* SystemURLRequestContextGetter::GetURLRequestContext() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!io_thread_->globals()->system_request_context)
+    io_thread_->InitSystemRequestContext();
+
+  return io_thread_->globals()->system_request_context;
+}
+
+scoped_refptr<base::MessageLoopProxy>
+SystemURLRequestContextGetter::GetIOMessageLoopProxy() const {
+  return io_message_loop_proxy_;
+}
+
 // 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() {}
 
 // |local_state| is passed in explicitly in order to (1) reduce implicit
 // dependencies and (2) make IOThread more flexible for testing.
@@ skipping 12 matching lines @@
   RegisterPrefs(local_state);
   auth_schemes_ = local_state->GetString(prefs::kAuthSchemes);
   negotiate_disable_cname_lookup_ = local_state->GetBoolean(
       prefs::kDisableAuthNegotiateCnameLookup);
   negotiate_enable_port_ = local_state->GetBoolean(
       prefs::kEnableAuthNegotiatePort);
   auth_server_whitelist_ = local_state->GetString(prefs::kAuthServerWhitelist);
   auth_delegate_whitelist_ = local_state->GetString(
       prefs::kAuthNegotiateDelegateWhitelist);
   gssapi_library_name_ = local_state->GetString(prefs::kGSSAPILibraryName);
+  pref_proxy_config_tracker_ = new PrefProxyConfigTracker(local_state);
 }
 
 IOThread::~IOThread() {
+  if (pref_proxy_config_tracker_)
+    pref_proxy_config_tracker_->DetachFromPrefService();
   // We cannot rely on our base class to stop the thread since we want our
   // CleanUp function to run.
   Stop();
   DCHECK(!globals_);
 }
 
 IOThread::Globals* IOThread::globals() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return globals_;
 }
@@ skipping 46 matching lines @@
 
 void IOThread::ChangedToOnTheRecord() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(
           this,
           &IOThread::ChangedToOnTheRecordOnIOThread));
 }
 
+scoped_refptr<URLRequestContextGetter>
+IOThread::system_url_request_context_getter() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!system_url_request_context_getter_) {
+    system_proxy_config_service_.reset(
+        ProxyServiceFactory::CreateProxyConfigService(
+            pref_proxy_config_tracker_));
+    system_url_request_context_getter_ =
+        new SystemURLRequestContextGetter(this);
+  }
+  return system_url_request_context_getter_;
+}
+
 void IOThread::ClearNetworkingHistory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ClearHostCache();
   // Discard acrued data used to speculate in the future.
   chrome_browser_net::DiscardInitialNavigationHistory();
   if (predictor_)
     predictor_->DiscardAllResults();
 }
 
 void IOThread::Init() {
@@ skipping 79 matching lines @@
        it != url_request_context_getters.end(); ++it) {
     ChromeURLRequestContextGetter* getter = *it;
     // Stop all pending certificate provenance check uploads
     net::DnsCertProvenanceChecker* checker =
         getter->GetURLRequestContext()->dns_cert_checker();
     if (checker)
       checker->Shutdown();
     getter->ReleaseURLRequestContext();
   }
 
+  system_url_request_context_getter_ = NULL;
+
   // Step 2: Release objects that the net::URLRequestContext could have been
   // pointing to.
 
   // This must be reset before the ChromeNetLog is destroyed.
   network_change_observer_.reset();
 
   // Not initialized in Init().  May not be initialized.
   if (predictor_) {
     predictor_->Shutdown();
 
     // TODO(willchan): Stop reference counting Predictor.  It's owned by
     // IOThread now.
     predictor_->Release();
     predictor_ = NULL;
     chrome_browser_net::FreePredictorResources();
   }
 
   // Deletion will unregister this interceptor.
   delete speculative_interceptor_;
   speculative_interceptor_ = NULL;
 
   // TODO(eroman): hack for http://crbug.com/15513
   if (globals_->host_resolver->GetAsHostResolverImpl()) {
     globals_->host_resolver.get()->GetAsHostResolverImpl()->Shutdown();
   }
 
+  system_proxy_config_service_.reset();
+
   delete globals_;
   globals_ = NULL;
 
   // net::URLRequest instances must NOT outlive the IO thread.
   base::debug::LeakTracker<net::URLRequest>::CheckForLeaks();
 
   // This will delete the |notification_service_|.  Make sure it's done after
   // anything else can reference it.
+  BrowserProcessSubThread::CleanUpAfterMessageLoopDestruction();
+
+  // net::URLRequest instances must NOT outlive the IO thread.
+  //
+  // To allow for URLRequests to be deleted from
+  // MessageLoop::DestructionObserver this check has to happen after CleanUp
+  // (which runs before DestructionObservers).
+  base::debug::LeakTracker<net::URLRequest>::CheckForLeaks();
+
+  base::debug::LeakTracker<SystemURLRequestContextGetter>::CheckForLeaks();
+
   BrowserProcessSubThread::CleanUp();
 }
 
 // static
 void IOThread::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterStringPref(prefs::kAuthSchemes,
                                   "basic,digest,ntlm,negotiate");
   local_state->RegisterBooleanPref(prefs::kDisableAuthNegotiateCnameLookup,
                                    false);
   local_state->RegisterBooleanPref(prefs::kEnableAuthNegotiatePort, false);
@@ skipping 77 matching lines @@
 void IOThread::ClearHostCache() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (globals_->host_resolver->GetAsHostResolverImpl()) {
     net::HostCache* host_cache =
         globals_->host_resolver.get()->GetAsHostResolverImpl()->cache();
     if (host_cache)
       host_cache->clear();
   }
 }
+
+void IOThread::InitSystemRequestContext() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!globals_->system_proxy_service);
+  DCHECK(system_proxy_config_service_.get());
+
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  globals_->system_proxy_service =
+      ProxyServiceFactory::CreateProxyService(
+          net_log_,
+          globals_->proxy_script_fetcher_context,
+          system_proxy_config_service_.release(),
+          command_line);
+  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_->system_network_delegate.get();
+  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_);
+}