Move initialization of ChromeURLRequestContexts to the IO thread.

Before, these URLRequestContexts were lazily created from the UI thread. Unfortunately that model made it easy for consumers on the UI thread to poke at stuff which was being used from the IO thread, and introduce races.

So instead of providing a URLRequestContext*, the Profile now vends a URLRequestContextGetter*. 

The consequence of this is:

* Consumers on the UI thread can no longer get access to a URLRequestContext.
* Consumers on the IO thread need to call URLRequestContextGetter::GetURLRequestContext() to get at the context. This uses the same style lazy-creation of URLRequestContexts, albeit from the IO thread.

OK, so now the smelly part:

There were a couple of consumers of URLRequestContext on the UI thread that can't easily be moved to the IO thread -- these are the consumers of the cookie store. Before they could happily mess with the cookie store from the UI thread, and this was fine since CookieStore is threadsafe. However under the new model, they have no way to get at the URLRequestContext from the UI thread, hence can't get a pointer to the cookie store.

To support that use-cases, I bastardized the API some by adding a URLRequestContextGetter::GetCookieStore() method that lets UI thread consumers get a pointer to the cookie store, since we know this particular cross-thread usage is safe.

BUG=http://crbug.com/22294

Review URL: http://codereview.chromium.org/258008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@29880 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 227 insertions, 40 deletions

diff --git a/chrome/browser/net/chrome_url_request_context.h b/chrome/browser/net/chrome_url_request_context.h
index 892593b..8bbfabe 100644
--- a/chrome/browser/net/chrome_url_request_context.h
+++ b/chrome/browser/net/chrome_url_request_context.h
@@ -2,7 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef CHROME_BROWSER_NET_CHROME_URL_REQUEST_CONTEXT_H_
+#define CHROME_BROWSER_NET_CHROME_URL_REQUEST_CONTEXT_H_
+
 #include "base/file_path.h"
+#include "chrome/browser/net/url_request_context_getter.h"
 #include "chrome/common/appcache/chrome_appcache_service.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/pref_service.h"
@@ -16,50 +20,135 @@ namespace net {
 class ProxyConfig;
 }
 
-// A URLRequestContext subclass used by the browser. This can be used to store
-// extra information about requests, beyond what is supported by the base
-// URLRequestContext class.
+class ChromeURLRequestContext;
+class ChromeURLRequestContextFactory;
+
+// TODO(eroman): Cleanup the declaration order in this file -- it is all
+//               wonky to try and minimize awkward deltas.
+
+// A URLRequestContextGetter subclass used by the browser. This returns a
+// subclass of URLRequestContext which can be used to store extra information
+// about requests.
 //
-// All methods are expected to be called on the IO thread except the
-// constructor and factories (CreateOriginal, CreateOffTheRecord), which are
-// expected to be called on the UI thread.
-class ChromeURLRequestContext : public URLRequestContext,
-                                public NotificationObserver {
+// Most methods are expected to be called on the UI thread, except for
+// the destructor and GetURLRequestContext().
+class ChromeURLRequestContextGetter : public URLRequestContextGetter,
+                             public NotificationObserver {
  public:
-  typedef std::map<std::string, FilePath> ExtensionPaths;
+  // Constructs a ChromeURLRequestContextGetter that will use |factory| to
+  // create the ChromeURLRequestContext. If |profile| is non-NULL, then the
+  // ChromeURLRequestContextGetter will additionally watch the preferences for
+  // changes to charset/language and CleanupOnUIThread() will need to be
+  // called to unregister.
+  ChromeURLRequestContextGetter(Profile* profile,
+                                ChromeURLRequestContextFactory* factory);
+
+  // Must be called on the IO thread.
+  virtual ~ChromeURLRequestContextGetter();
+
+  // Note that GetURLRequestContext() can only be called from the IO
+  // thread (it will assert otherwise). GetCookieStore() however can
+  // be called from any thread.
+  //
+  // URLRequestContextGetter implementation.
+  virtual URLRequestContext* GetURLRequestContext();
+  virtual net::CookieStore* GetCookieStore();
+
+  // Convenience overload of GetURLRequestContext() that returns a
+  // ChromeURLRequestContext* rather than a URLRequestContext*.
+  ChromeURLRequestContext* GetIOContext() {
+    return reinterpret_cast<ChromeURLRequestContext*>(GetURLRequestContext());
+  }
 
   // Create an instance for use with an 'original' (non-OTR) profile. This is
   // expected to get called on the UI thread.
-  static ChromeURLRequestContext* CreateOriginal(
+  static ChromeURLRequestContextGetter* CreateOriginal(
       Profile* profile, const FilePath& cookie_store_path,
-      const FilePath& disk_cache_path, int cache_size,
-      ChromeAppCacheService* appcache_service);
+      const FilePath& disk_cache_path, int cache_size);
 
   // Create an instance for an original profile for media. This is expected to
   // get called on UI thread. This method takes a profile and reuses the
   // 'original' URLRequestContext for common files.
-  static ChromeURLRequestContext* CreateOriginalForMedia(Profile *profile,
-      const FilePath& disk_cache_path, int cache_size,
-      ChromeAppCacheService* appcache_service);
+  static ChromeURLRequestContextGetter* CreateOriginalForMedia(
+      Profile* profile, const FilePath& disk_cache_path, int cache_size);
 
   // Create an instance for an original profile for extensions. This is expected
   // to get called on UI thread.
-  static ChromeURLRequestContext* CreateOriginalForExtensions(Profile *profile,
-      const FilePath& cookie_store_path);
+  static ChromeURLRequestContextGetter* CreateOriginalForExtensions(
+      Profile* profile, const FilePath& cookie_store_path);
 
   // Create an instance for use with an OTR profile. This is expected to get
   // called on the UI thread.
-  static ChromeURLRequestContext* CreateOffTheRecord(Profile* profile,
-      ChromeAppCacheService* appcache_service);
+  static ChromeURLRequestContextGetter* CreateOffTheRecord(Profile* profile);
 
   // Create an instance of request context for OTR profile for extensions.
-  static ChromeURLRequestContext* CreateOffTheRecordForExtensions(
+  static ChromeURLRequestContextGetter* CreateOffTheRecordForExtensions(
       Profile* profile);
 
   // Clean up UI thread resources. This is expected to get called on the UI
   // thread before the instance is deleted on the IO thread.
   void CleanupOnUIThread();
 
+  // These methods simply forward to the corresponding method on
+  // ChromeURLRequestContext.
+  void OnNewExtensions(const std::string& id, const FilePath& path);
+  void OnUnloadedExtension(const std::string& id);
+
+  // NotificationObserver implementation.
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
+ private:
+  // Registers an observer on |profile|'s preferences which will be used
+  // to update the context when the default language and charset change.
+  void RegisterPrefsObserver(Profile* profile);
+
+  // Creates a request context for media resources from a regular request
+  // context. This helper method is called from CreateOriginalForMedia and
+  // CreateOffTheRecordForMedia.
+  static ChromeURLRequestContextGetter* CreateRequestContextForMedia(
+      Profile* profile, const FilePath& disk_cache_path, int cache_size,
+      bool off_the_record);
+
+  // These methods simply forward to the corresponding method on
+  // ChromeURLRequestContext.
+  void OnAcceptLanguageChange(const std::string& accept_language);
+  void OnCookiePolicyChange(net::CookiePolicy::Type type);
+  void OnDefaultCharsetChange(const std::string& default_charset);
+
+  // Saves the cookie store to |result| and signals |completion|.
+  void GetCookieStoreAsyncHelper(base::WaitableEvent* completion,
+                                 net::CookieStore** result);
+
+  // Access only from the UI thread.
+  PrefService* prefs_;
+  NotificationRegistrar registrar_;
+
+  // Deferred logic for creating a ChromeURLRequestContext.
+  // Access only from the IO thread.
+  scoped_ptr<ChromeURLRequestContextFactory> factory_;
+
+  // NULL if not yet initialized. Otherwise, it is the URLRequestContext
+  // instance that was lazilly created by GetURLRequestContext.
+  // Access only from the IO thread.
+  scoped_refptr<URLRequestContext> url_request_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeURLRequestContextGetter);
+};
+
+// Subclass of URLRequestContext which can be used to store extra information
+// for requests.
+//
+// All methods of this class must be called from the IO thread,
+// including the constructor and destructor.
+class ChromeURLRequestContext : public URLRequestContext {
+ public:
+  typedef std::map<std::string, FilePath> ExtensionPaths;
+
+  ChromeURLRequestContext();
+  virtual ~ChromeURLRequestContext();
+
   // Gets the path to the directory for the specified extension.
   FilePath GetPathForExtension(const std::string& id);
 
@@ -74,6 +163,16 @@ class ChromeURLRequestContext : public URLRequestContext,
     return appcache_service_.get();
   }
 
+  bool is_off_the_record() const {
+    return is_off_the_record_;
+  }
+  bool is_media() const {
+    return is_media_;
+  }
+  const ExtensionPaths& extension_paths() const {
+    return extension_paths_;
+  }
+
   virtual const std::string& GetUserAgent(const GURL& url) const;
 
   virtual bool InterceptCookie(const URLRequest* request, std::string* cookie);
@@ -90,23 +189,66 @@ class ChromeURLRequestContext : public URLRequestContext,
   void OnUnloadedExtension(const std::string& id);
 
  protected:
-  // Private constructors, use the static factory methods instead. This is
-  // expected to be called on the UI thread.
-  ChromeURLRequestContext(
-      Profile* profile, ChromeAppCacheService* appcache_service);
+  // Copies the dependencies from |other| into |this|. If you use this
+  // constructor, then you should hold a reference to |other|, as we
+  // depend on |other| being alive.
   ChromeURLRequestContext(ChromeURLRequestContext* other);
 
-  // Create a request context for media resources from a regular request
-  // context. This helper method is called from CreateOriginalForMedia and
-  // CreateOffTheRecordForMedia.
-  static ChromeURLRequestContext* CreateRequestContextForMedia(Profile* profile,
-      const FilePath& disk_cache_path, int cache_size, bool off_the_record,
-      ChromeAppCacheService* appache_service);
+ public:
+  // Setters to simplify initializing from factory objects.
 
-  // NotificationObserver implementation.
-  virtual void Observe(NotificationType type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details);
+  void set_accept_language(const std::string& accept_language) {
+    accept_language_ = accept_language;
+  }
+  void set_accept_charset(const std::string& accept_charset) {
+    accept_charset_ = accept_charset;
+  }
+  void set_referrer_charset(const std::string& referrer_charset) {
+    referrer_charset_ = referrer_charset;
+  }
+  void set_cookie_policy_type(net::CookiePolicy::Type type) {
+    cookie_policy_.set_type(type);
+  }
+  void set_strict_transport_security_state(
+      net::StrictTransportSecurityState* state) {
+    strict_transport_security_state_ = state;
+  }
+  void set_ssl_config_service(net::SSLConfigService* service) {
+    ssl_config_service_ = service;
+  }
+  void set_host_resolver(net::HostResolver* resolver) {
+    host_resolver_ = resolver;
+  }
+  void set_http_transaction_factory(net::HttpTransactionFactory* factory) {
+    http_transaction_factory_ = factory;
+  }
+  void set_ftp_transaction_factory(net::FtpTransactionFactory* factory) {
+    ftp_transaction_factory_ = factory;
+  }
+  void set_cookie_store(net::CookieStore* cookie_store) {
+    cookie_store_ = cookie_store;
+  }
+  void set_proxy_service(net::ProxyService* service) {
+    proxy_service_ = service;
+  }
+  void set_user_script_dir_path(const FilePath& path) {
+    user_script_dir_path_ = path;
+  }
+  void set_is_off_the_record(bool is_off_the_record) {
+    is_off_the_record_ = is_off_the_record;
+  }
+  void set_is_media(bool is_media) {
+    is_media_ = is_media;
+  }
+  void set_extension_paths(const ExtensionPaths& paths) {
+    extension_paths_ = paths;
+  }
+  void set_blacklist(const Blacklist* blacklist) {
+    blacklist_ = blacklist;
+  }
+  void set_appcache_service(ChromeAppCacheService* service) {
+    appcache_service_ = service;
+  }
 
   // Callback for when the accept language changes.
   void OnAcceptLanguageChange(const std::string& accept_language);
@@ -117,11 +259,7 @@ class ChromeURLRequestContext : public URLRequestContext,
   // Callback for when the default charset changes.
   void OnDefaultCharsetChange(const std::string& default_charset);
 
-  // Destructor.
-  virtual ~ChromeURLRequestContext();
-
-  NotificationRegistrar registrar_;
-
+ protected:
   // Maps extension IDs to paths on disk. This is initialized in the
   // construtor and updated when extensions changed.
   ExtensionPaths extension_paths_;
@@ -131,12 +269,61 @@ class ChromeURLRequestContext : public URLRequestContext,
 
   scoped_refptr<ChromeAppCacheService> appcache_service_;
 
-  PrefService* prefs_;
   const Blacklist* blacklist_;
   bool is_media_;
   bool is_off_the_record_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ChromeURLRequestContext);
+};
+
+// Base class for a ChromeURLRequestContext factory. This includes
+// the shared functionality like extracting the default language/charset
+// from a profile.
+//
+// Except for the constructor, all methods of this class must be called from
+// the IO thread.
+class ChromeURLRequestContextFactory {
+ public:
+  // Extract properties of interested from |profile|, for setting later into
+  // a ChromeURLRequestContext using ApplyProfileParametersToContext().
+  ChromeURLRequestContextFactory(Profile* profile);
+
+  virtual ~ChromeURLRequestContextFactory();
+
+  // Called to create a new instance (will only be called once).
+  virtual ChromeURLRequestContext* Create() = 0;
+
+ protected:
+  // Assigns this factory's properties to |context|.
+  void ApplyProfileParametersToContext(ChromeURLRequestContext* context);
+
+  // Values extracted from the Profile.
+  //
+  // NOTE: If you add any parameters here, keep it in sync with
+  // ApplyProfileParametersToContext().
+  bool is_media_;
+  bool is_off_the_record_;
+  std::string accept_language_;
+  std::string accept_charset_;
+  std::string referrer_charset_;
+  net::CookiePolicy::Type cookie_policy_type_;
+  ChromeURLRequestContext::ExtensionPaths extension_paths_;
+  FilePath user_script_dir_path_;
+  Blacklist* blacklist_;
+  net::StrictTransportSecurityState* strict_transport_security_state_;
+  scoped_refptr<net::SSLConfigService> ssl_config_service_;
+
+  FilePath profile_dir_path_;
+
+  // Values extracted from the browser process.
+  MessageLoop* db_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeURLRequestContextFactory);
 };
 
 // Creates a proxy configuration using the overrides specified on the command
 // line. Returns NULL if the system defaults should be used instead.
 net::ProxyConfig* CreateProxyConfig(const CommandLine& command_line);
+
+#endif  // CHROME_BROWSER_NET_CHROME_URL_REQUEST_CONTEXT_H_