Create a URLRequestContext for PAC fetching.

chrome/browser/io_thread.h

 // 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.
 
 #ifndef CHROME_BROWSER_IO_THREAD_H_
 #define CHROME_BROWSER_IO_THREAD_H_
 #pragma once
 
 #include <list>
-#include <set>
 #include <string>
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "chrome/browser/browser_process_sub_thread.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/common/net/predictor_common.h"
 #include "net/base/network_change_notifier.h"
 
 class ChromeNetLog;
 class ChromeURLRequestContextGetter;
 class ListValue;
 class PrefService;
 class PrerenderInterceptor;
 class URLRequestContext;
 
 namespace chrome_browser_net {
 class ConnectInterceptor;
 class Predictor;
 }  // namespace chrome_browser_net
 
 namespace net {
 class CertVerifier;
+class ClientSocketFactory;
 class DnsRRResolver;
 class HostResolver;
 class HttpAuthHandlerFactory;
 class ProxyScriptFetcher;
+class ProxyService;
+class SSLConfigService;
 class URLSecurityManager;
 }  // namespace net
 
 class IOThread : public BrowserProcessSubThread {
  public:
   struct Globals {
     Globals();
     ~Globals();
 
+    net::ClientSocketFactory* client_socket_factory;

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

Where is this freed? Or is GetDefaultFactory a singleton?

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

It surprised me to find out it is a singleton.  I originally wrote this as a
scoped_ptr and it crashed on me :P

     scoped_ptr<net::HostResolver> host_resolver;
     scoped_ptr<net::CertVerifier> cert_verifier;
     scoped_ptr<net::DnsRRResolver> dnsrr_resolver;
+    scoped_refptr<net::SSLConfigService> ssl_config_service;
     scoped_ptr<net::HttpAuthHandlerFactory> http_auth_handler_factory;
+    scoped_refptr<net::ProxyService> proxy_script_fetcher_proxy_service;
     scoped_ptr<net::URLSecurityManager> url_security_manager;
     ChromeNetworkDelegate network_delegate;
+    scoped_refptr<URLRequestContext> proxy_script_fetcher_context;
   };
 
   // |net_log| must either outlive the IOThread or be NULL.
   IOThread(PrefService* local_state, ChromeNetLog* net_log);
 
   virtual ~IOThread();
 
   // Can only be called on the IO thread.
   Globals* globals();
 
@@ skipping 23 matching lines @@
 
   // Unregisters |url_request_context_getter| from the IO thread.  Only called
   // on the IO thread.
   void UnregisterURLRequestContextGetter(
       ChromeURLRequestContextGetter* url_request_context_getter);
 
   // Handles changing to On The Record mode.  Posts a task for this onto the
   // IOThread's message loop.
   void ChangedToOnTheRecord();
 
-  // Creates a ProxyScriptFetcherImpl which will be automatically aborted
-  // during shutdown.
-  // This is used to avoid cycles between the ProxyScriptFetcher and the
-  // URLRequestContext that owns it (indirectly via the ProxyService).
-  net::ProxyScriptFetcher* CreateAndRegisterProxyScriptFetcher(
-      URLRequestContext* url_request_context);
-
  protected:
   virtual void Init();
   virtual void CleanUp();
   virtual void CleanUpAfterMessageLoopDestruction();
 
  private:
-  class ManagedProxyScriptFetcher;
-  typedef std::set<ManagedProxyScriptFetcher*> ProxyScriptFetchers;
-
   static void RegisterPrefs(PrefService* local_state);
 
   net::HttpAuthHandlerFactory* CreateDefaultAuthHandlerFactory(
       net::HostResolver* resolver);
 
   void InitNetworkPredictorOnIOThread(
       bool prefetching_enabled,
       base::TimeDelta max_dns_queue_delay,
       size_t max_speculative_parallel_resolves,
       const chrome_common_net::UrlList& startup_urls,
@@ skipping 31 matching lines @@
   // which gets posted by calling certain member functions of IOThread.
 
   // Note: we user explicit pointers rather than smart pointers to be more
   // explicit about destruction order, and ensure that there is no chance that
   // these observers would be used accidentally after we have begun to tear
   // down.
   chrome_browser_net::ConnectInterceptor* speculative_interceptor_;
   chrome_browser_net::Predictor* predictor_;
   scoped_ptr<PrerenderInterceptor> prerender_interceptor_;
 
-  // List of live ProxyScriptFetchers.
-  ProxyScriptFetchers fetchers_;
-
   // Keeps track of all live ChromeURLRequestContextGetters, so the
   // ChromeURLRequestContexts can be released during
   // IOThread::CleanUpAfterMessageLoopDestruction().
   std::list<ChromeURLRequestContextGetter*> url_request_context_getters_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThread);
 };
 
 #endif  // CHROME_BROWSER_IO_THREAD_H_