Create a URLRequestContext for PAC fetching.

chrome/browser/io_thread.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/io_thread.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/leak_tracker.h"
@@ skipping 19 matching lines @@
 #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/http/http_auth_filter.h"
 #include "net/http/http_auth_handler_factory.h"
+#include "net/http/http_cache.h"

[eroman, 2010/12/23 01:40:59]

Is this header still needed?

[willchan no longer on Chromium, 2010/12/23 23:51:58]

Done.

+#include "net/http/http_network_layer.h"
 #if defined(USE_NSS)
 #include "net/ocsp/nss_ocsp.h"
 #endif  // defined(USE_NSS)
 #include "net/proxy/proxy_script_fetcher_impl.h"
+#include "net/socket/client_socket_factory.h"
+#include "net/spdy/spdy_session_pool.h"
 
 namespace {
 
 net::HostResolver* CreateGlobalHostResolver(net::NetLog* net_log) {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   size_t parallelism = net::HostResolver::kDefaultParallelism;
 
   // Use the concurrency override from the command-line, if any.
   if (command_line.HasSwitch(switches::kHostResolverParallelism)) {
@@ skipping 113 matching lines @@
                        net::NetLog::Source(),
                        net::NetLog::PHASE_NONE,
                        NULL);
   }
 
  private:
   net::NetLog* net_log_;
   DISALLOW_COPY_AND_ASSIGN(LoggingNetworkChangeObserver);
 };
 
+scoped_refptr<URLRequestContext>
+ConstructProxyScriptFetcherContext(IOThread::Globals* globals,
+                                   net::NetLog* net_log) {
+  scoped_refptr<URLRequestContext> context(new 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->proxy_script_fetcher_proxy_service.get());
+  context->set_http_transaction_factory(
+      new net::HttpNetworkLayer(
+          globals->client_socket_factory,
+          globals->host_resolver.get(),
+          globals->cert_verifier.get(),
+          globals->dnsrr_resolver.get(),
+          NULL /* dns_cert_checker */,
+          NULL /* ssl_host_info_factory */,
+          globals->proxy_script_fetcher_proxy_service.get(),
+          globals->ssl_config_service.get(),
+          new net::SpdySessionPool(globals->ssl_config_service.get()),

[eroman, 2010/12/23 01:40:59]

Does HttpNetworkLayer take ownership of the session pool, or will this leak?

[willchan no longer on Chromium, 2010/12/23 23:51:58]

Takes ownership.  It's sort of weird.  I'm hoping to fix these semantics later
on.  I want ProfileIOData or IOThread::Globals to own it.

+          globals->http_auth_handler_factory.get(),
+          &globals->network_delegate,
+          net_log));
+  // In-memory cookie store.
+  context->set_cookie_store(new net::CookieMonster(NULL, NULL));
+  return context;
+}
+
 }  // namespace
 
-// This is a wrapper class around ProxyScriptFetcherImpl that will
-// keep track of live instances.
-class IOThread::ManagedProxyScriptFetcher
-    : public net::ProxyScriptFetcherImpl {
- public:
-  ManagedProxyScriptFetcher(URLRequestContext* context,
-                            IOThread* io_thread)
-      : net::ProxyScriptFetcherImpl(context),
-        io_thread_(io_thread) {
-    DCHECK(!ContainsKey(*fetchers(), this));
-    fetchers()->insert(this);
-  }
-
-  virtual ~ManagedProxyScriptFetcher() {
-    DCHECK(ContainsKey(*fetchers(), this));
-    fetchers()->erase(this);
-  }
-
- private:
-  ProxyScriptFetchers* fetchers() {
-    return &io_thread_->fetchers_;
-  }
-
-  IOThread* io_thread_;
-
-  DISALLOW_COPY_AND_ASSIGN(ManagedProxyScriptFetcher);
-};
-
 // 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 77 matching lines @@
 
 void IOThread::ChangedToOnTheRecord() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(
           this,
           &IOThread::ChangedToOnTheRecordOnIOThread));
 }
 
-net::ProxyScriptFetcher* IOThread::CreateAndRegisterProxyScriptFetcher(
-    URLRequestContext* url_request_context) {
-  return new ManagedProxyScriptFetcher(url_request_context, this);
-}
-
 void IOThread::Init() {
 #if !defined(OS_CHROMEOS)
   // TODO(evan): test and enable this on all platforms.
   // Though this thread is called the "IO" thread, it actually just routes
   // messages around; it shouldn't be allowed to perform any blocking disk I/O.
   base::ThreadRestrictions::SetIOAllowed(false);
 #endif
 
   BrowserProcessSubThread::Init();
 
   DCHECK_EQ(MessageLoop::TYPE_IO, message_loop()->type());
 
 #if defined(USE_NSS)
   net::SetMessageLoopForOCSP();
 #endif  // defined(USE_NSS)
 
   DCHECK(!globals_);
   globals_ = new Globals;
 
   // Add an observer that will emit network change events to the ChromeNetLog.
   // Assuming NetworkChangeNotifier dispatches in FIFO order, we should be
   // logging the network change before other IO thread consumers respond to it.
   network_change_observer_.reset(
       new LoggingNetworkChangeObserver(net_log_));
 
+  globals_->client_socket_factory =
+      net::ClientSocketFactory::GetDefaultFactory();
   globals_->host_resolver.reset(
       CreateGlobalHostResolver(net_log_));
   globals_->cert_verifier.reset(new net::CertVerifier);
   globals_->dnsrr_resolver.reset(new net::DnsRRResolver);
+  // TODO(willchan): Use the real SSLConfigService.
+  globals_->ssl_config_service =
+      net::SSLConfigService::CreateSystemSSLConfigService();
   globals_->http_auth_handler_factory.reset(CreateDefaultAuthHandlerFactory(
       globals_->host_resolver.get()));
+  // For the ProxyScriptFetcher, we use a direct ProxyService.
+  globals_->proxy_script_fetcher_proxy_service =
+      net::ProxyService::CreateDirectWithNetLog(net_log_);
+
+  scoped_refptr<URLRequestContext> proxy_script_fetcher_context =
+      ConstructProxyScriptFetcherContext(globals_, net_log_);
+  globals_->proxy_script_fetcher_context = proxy_script_fetcher_context;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePagePrerender)) {
     prerender_interceptor_.reset(new PrerenderInterceptor());
   }
 }
 
 void IOThread::CleanUp() {
   // Step 1: Kill all things that might be holding onto
   // net::URLRequest/URLRequestContexts.
 
 #if defined(USE_NSS)
   net::ShutdownOCSP();
 #endif  // defined(USE_NSS)
 
   // Destroy all URLRequests started by URLFetchers.
   URLFetcher::CancelAll();
 
-  // Break any cycles between the ProxyScriptFetcher and URLRequestContext.
-  for (ProxyScriptFetchers::const_iterator it = fetchers_.begin();
-       it != fetchers_.end();) {
-    ManagedProxyScriptFetcher* fetcher = *it;
-    {
-      // Hang on to the context while cancelling to avoid problems
-      // with the cancellation causing the context to be destroyed
-      // (see http://crbug.com/63796 ).  Ideally, the IOThread would
-      // own the URLRequestContexts.
-      scoped_refptr<URLRequestContext> context(fetcher->GetRequestContext());
-      fetcher->Cancel();
-    }
-    // Any number of fetchers may have been deleted at this point, so
-    // use upper_bound instead of a simple increment.
-    it = fetchers_.upper_bound(fetcher);
-  }
-
   // If any child processes are still running, terminate them and
   // and delete the BrowserChildProcessHost instances to release whatever
   // IO thread only resources they are referencing.
   BrowserChildProcessHost::TerminateAll();
 
   std::list<ChromeURLRequestContextGetter*> url_request_context_getters;
   url_request_context_getters.swap(url_request_context_getters_);
   for (std::list<ChromeURLRequestContextGetter*>::iterator it =
        url_request_context_getters.begin();
        it != url_request_context_getters.end(); ++it) {
@@ skipping 132 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();
 }