Stop refcounting URLRequestContext.

chrome/browser/io_thread.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/io_thread.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 179 matching lines @@
 
     net_log_->AddGlobalEntry(net::NetLog::TYPE_NETWORK_IP_ADDRESSES_CHANGED,
                              NULL);
   }
 
  private:
   net::NetLog* net_log_;
   DISALLOW_COPY_AND_ASSIGN(LoggingNetworkChangeObserver);
 };
 
-// Create a separate request context for PAC fetches to avoid reference cycles.
+// TODO(willchan): Remove proxy script fetcher context since it's not necessary
+// now that I got rid of refcounting URLRequestContexts.
 // See IOThread::Globals for details.
-scoped_refptr<net::URLRequestContext>
+net::URLRequestContext*
 ConstructProxyScriptFetcherContext(IOThread::Globals* globals,
                                    net::NetLog* net_log) {
-  scoped_refptr<net::URLRequestContext> context(
-      new URLRequestContextWithUserAgent);
+  net::URLRequestContext* context = new URLRequestContextWithUserAgent;
   context->set_net_log(net_log);
   context->set_host_resolver(globals->host_resolver.get());
   context->set_cert_verifier(globals->cert_verifier.get());
   context->set_transport_security_state(
       globals->transport_security_state.get());
   context->set_http_auth_handler_factory(
       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());
   context->set_ftp_transaction_factory(
       globals->proxy_script_fetcher_ftp_transaction_factory.get());
   context->set_cookie_store(globals->system_cookie_store.get());
   context->set_server_bound_cert_service(
       globals->system_server_bound_cert_service.get());
   context->set_network_delegate(globals->system_network_delegate.get());
   // TODO(rtenneti): We should probably use HttpServerPropertiesManager for the
   // system URLRequestContext too. There's no reason this should be tied to a
   // profile.
   return context;
 }
 
-scoped_refptr<net::URLRequestContext>
+net::URLRequestContext*
 ConstructSystemRequestContext(IOThread::Globals* globals,
                               net::NetLog* net_log) {
-  scoped_refptr<net::URLRequestContext> context(
-      new SystemURLRequestContext);
+  net::URLRequestContext* context = new SystemURLRequestContext;
   context->set_net_log(net_log);
   context->set_host_resolver(globals->host_resolver.get());
   context->set_cert_verifier(globals->cert_verifier.get());
   context->set_transport_security_state(
       globals->transport_security_state.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());
@@ skipping 30 matching lines @@
     IOThread* io_thread)
     : io_thread_(io_thread),
       io_message_loop_proxy_(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)) {
 }
 
 SystemURLRequestContextGetter::~SystemURLRequestContextGetter() {}
 
 net::URLRequestContext* SystemURLRequestContextGetter::GetURLRequestContext() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(io_thread_->globals()->system_request_context);
+  DCHECK(io_thread_->globals()->system_request_context.get());
 
-  return io_thread_->globals()->system_request_context;
+  return io_thread_->globals()->system_request_context.get();
 }
 
 scoped_refptr<base::MessageLoopProxy>
 SystemURLRequestContextGetter::GetIOMessageLoopProxy() const {
   return io_message_loop_proxy_;
 }
 
 IOThread::Globals::
 SystemRequestContextLeakChecker::SystemRequestContextLeakChecker(
     Globals* globals)
@@ skipping 152 matching lines @@
 
   globals_->throttler_manager.reset(new net::URLRequestThrottlerManager());
   // Always done in production, disabled only for unit tests.
   globals_->throttler_manager->set_enable_thread_checks(true);
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableExtensionsHttpThrottling)) {
     globals_->throttler_manager->set_enforce_throttling(false);
   }
   globals_->throttler_manager->set_net_log(net_log_);
 
-  globals_->proxy_script_fetcher_context =
-      ConstructProxyScriptFetcherContext(globals_, net_log_);
+  globals_->proxy_script_fetcher_context.reset(
+      ConstructProxyScriptFetcherContext(globals_, net_log_));
 
   sdch_manager_ = new net::SdchManager();
 
   // InitSystemRequestContext turns right around and posts a task back
   // to the IO thread, so we can't let it run until we know the IO
   // thread has started.
   //
   // Note that since we are at BrowserThread::Init time, the UI thread
   // is blocked waiting for the thread to start.  Therefore, posting
   // this task to the main thread's message loop here is guaranteed to
@@ skipping 124 matching lines @@
 
 void IOThread::InitSystemRequestContextOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!globals_->system_proxy_service.get());
   DCHECK(system_proxy_config_service_.get());
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   globals_->system_proxy_service.reset(
       ProxyServiceFactory::CreateProxyService(
           net_log_,
-          globals_->proxy_script_fetcher_context,
+          globals_->proxy_script_fetcher_context.get(),
           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.server_bound_cert_service =
       globals_->system_server_bound_cert_service.get();
   system_params.transport_security_state =
       globals_->transport_security_state.get();
   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.http_server_properties = globals_->http_server_properties.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_ftp_transaction_factory.reset(
       new net::FtpNetworkLayer(globals_->host_resolver.get()));
-  globals_->system_request_context =
-      ConstructSystemRequestContext(globals_, net_log_);
+  globals_->system_request_context.reset(
+      ConstructSystemRequestContext(globals_, net_log_));
 
   sdch_manager_->set_sdch_fetcher(
       new SdchDictionaryFetcher(system_url_request_context_getter_.get()));
 }