src/chrome/browser/profiles/profile_io_data.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_PROFILES_PROFILE_IO_DATA_H_
   6 #define CHROME_BROWSER_PROFILES_PROFILE_IO_DATA_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback_forward.h"
  12 #include "base/files/file_path.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/prefs/pref_member.h"
  17 #include "base/synchronization/lock.h"
  18 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
  19 #include "chrome/browser/io_thread.h"
  20 #include "chrome/browser/net/chrome_url_request_context.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/profiles/storage_partition_descriptor.h"
  23 #include "chrome/common/content_settings_types.h"
  24 #include "content/public/browser/content_browser_client.h"
  25 #include "content/public/browser/resource_context.h"
  26 #include "net/cookies/cookie_monster.h"
  27 #include "net/http/http_network_session.h"
  28 #include "net/url_request/url_request_job_factory.h"
  29
  30 class ChromeHttpUserAgentSettings;
  31 class ChromeNetworkDelegate;
  32 class CookieSettings;
  33 class HostContentSettingsMap;
  34 class ManagedModeURLFilter;
  35 class MediaDeviceIDSalt;
  36 class ProtocolHandlerRegistry;
  37 class SigninNamesOnIOThread;
  38
  39 namespace extensions {
  40 class InfoMap;
  41 }
  42
  43 namespace net {
  44 class CookieStore;
  45 class FraudulentCertificateReporter;
  46 class FtpTransactionFactory;
  47 class HttpServerProperties;
  48 class HttpTransactionFactory;
  49 class ServerBoundCertService;
  50 class ProxyConfigService;
  51 class ProxyService;
  52 class SSLConfigService;
  53 class TransportSecurityPersister;
  54 class TransportSecurityState;
  55 class URLRequestJobFactoryImpl;
  56 }  // namespace net
  57
  58 namespace policy {
  59 class PolicyCertVerifier;
  60 class PolicyHeaderIOHelper;
  61 class URLBlacklistManager;
  62 }  // namespace policy
  63
  64 // Conceptually speaking, the ProfileIOData represents data that lives on the IO
  65 // thread that is owned by a Profile, such as, but not limited to, network
  66 // objects like CookieMonster, HttpTransactionFactory, etc.  Profile owns
  67 // ProfileIOData, but will make sure to delete it on the IO thread (except
  68 // possibly in unit tests where there is no IO thread).
  69 class ProfileIOData {
  70  public:
  71   virtual ~ProfileIOData();
  72
  73   static ProfileIOData* FromResourceContext(content::ResourceContext* rc);
  74
  75   // Returns true if |scheme| is handled in Chrome, or by default handlers in
  76   // net::URLRequest.
  77   static bool IsHandledProtocol(const std::string& scheme);
  78
  79   // Returns true if |url| is handled in Chrome, or by default handlers in
  80   // net::URLRequest.
  81   static bool IsHandledURL(const GURL& url);
  82
  83   // Utility to install additional WebUI handlers into the |job_factory|.
  84   // Ownership of the handlers is transfered from |protocol_handlers|
  85   // to the |job_factory|.
  86   static void InstallProtocolHandlers(
  87       net::URLRequestJobFactoryImpl* job_factory,
  88       content::ProtocolHandlerMap* protocol_handlers);
  89
  90   // Called by Profile.
  91   content::ResourceContext* GetResourceContext() const;
  92
  93   // Initializes the ProfileIOData object and primes the RequestContext
  94   // generation. Must be called prior to any of the Get*() methods other than
  95   // GetResouceContext or GetMetricsEnabledStateOnIOThread.
  96   void Init(content::ProtocolHandlerMap* protocol_handlers,
  97             content::ProtocolHandlerScopedVector protocol_interceptors) const;
  98
  99   ChromeURLRequestContext* GetMainRequestContext() const;
 100   ChromeURLRequestContext* GetMediaRequestContext() const;
 101   ChromeURLRequestContext* GetExtensionsRequestContext() const;
 102   ChromeURLRequestContext* GetIsolatedAppRequestContext(
 103       ChromeURLRequestContext* main_context,
 104       const StoragePartitionDescriptor& partition_descriptor,
 105       scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 106           protocol_handler_interceptor,
 107       content::ProtocolHandlerMap* protocol_handlers,
 108       content::ProtocolHandlerScopedVector protocol_interceptors) const;
 109   ChromeURLRequestContext* GetIsolatedMediaRequestContext(
 110       ChromeURLRequestContext* app_context,
 111       const StoragePartitionDescriptor& partition_descriptor) const;
 112
 113   // These are useful when the Chrome layer is called from the content layer
 114   // with a content::ResourceContext, and they want access to Chrome data for
 115   // that profile.
 116   extensions::InfoMap* GetExtensionInfoMap() const;
 117   CookieSettings* GetCookieSettings() const;
 118   HostContentSettingsMap* GetHostContentSettingsMap() const;
 119
 120   IntegerPrefMember* session_startup_pref() const {
 121     return &session_startup_pref_;
 122   }
 123
 124   SigninNamesOnIOThread* signin_names() const {
 125     return signin_names_.get();
 126   }
 127
 128   StringPrefMember* google_services_account_id() const {
 129     return &google_services_user_account_id_;
 130   }
 131
 132   StringPrefMember* google_services_username() const {
 133     return &google_services_username_;
 134   }
 135
 136   StringPrefMember* google_services_username_pattern() const {
 137     return &google_services_username_pattern_;
 138   }
 139
 140   BooleanPrefMember* reverse_autologin_enabled() const {
 141     return &reverse_autologin_enabled_;
 142   }
 143
 144   const std::string& reverse_autologin_pending_email() const {
 145     return reverse_autologin_pending_email_;
 146   }
 147
 148   void set_reverse_autologin_pending_email(const std::string& email) {
 149     reverse_autologin_pending_email_ = email;
 150   }
 151
 152   StringListPrefMember* one_click_signin_rejected_email_list() const {
 153     return &one_click_signin_rejected_email_list_;
 154   }
 155
 156   ChromeURLRequestContext* extensions_request_context() const {
 157     return extensions_request_context_.get();
 158   }
 159
 160   BooleanPrefMember* safe_browsing_enabled() const {
 161     return &safe_browsing_enabled_;
 162   }
 163
 164   BooleanPrefMember* printing_enabled() const {
 165     return &printing_enabled_;
 166   }
 167
 168   BooleanPrefMember* sync_disabled() const {
 169     return &sync_disabled_;
 170   }
 171
 172   BooleanPrefMember* signin_allowed() const {
 173     return &signin_allowed_;
 174   }
 175
 176   BooleanPrefMember* network_prediction_enabled() const {
 177     return &network_prediction_enabled_;
 178   }
 179
 180   content::ResourceContext::SaltCallback GetMediaDeviceIDSalt() const;
 181
 182   net::TransportSecurityState* transport_security_state() const {
 183     return transport_security_state_.get();
 184   }
 185
 186 #if defined(OS_CHROMEOS)
 187   std::string username_hash() const {
 188     return username_hash_;
 189   }
 190 #endif
 191
 192   Profile::ProfileType profile_type() const {
 193     return profile_type_;
 194   }
 195
 196   bool IsOffTheRecord() const;
 197
 198 #if defined(ENABLE_CONFIGURATION_POLICY)
 199   policy::PolicyHeaderIOHelper* policy_header_helper() const {
 200     return policy_header_helper_.get();
 201   }
 202 #endif
 203
 204 #if defined(ENABLE_MANAGED_USERS)
 205   const ManagedModeURLFilter* managed_mode_url_filter() const {
 206     return managed_mode_url_filter_.get();
 207   }
 208 #endif
 209
 210   // Initialize the member needed to track the metrics enabled state. This is
 211   // only to be called on the UI thread.
 212   void InitializeMetricsEnabledStateOnUIThread();
 213
 214   // Returns whether or not metrics reporting is enabled in the browser instance
 215   // on which this profile resides. This is safe for use from the IO thread, and
 216   // should only be called from there.
 217   bool GetMetricsEnabledStateOnIOThread() const;
 218
 219   void set_client_cert_store_factory_for_testing(
 220     const base::Callback<scoped_ptr<net::ClientCertStore>()>& factory) {
 221       client_cert_store_factory_ = factory;
 222   }
 223
 224  protected:
 225   // A URLRequestContext for media that owns its HTTP factory, to ensure
 226   // it is deleted.
 227   class MediaRequestContext : public ChromeURLRequestContext {
 228    public:
 229     MediaRequestContext();
 230
 231     void SetHttpTransactionFactory(
 232         scoped_ptr<net::HttpTransactionFactory> http_factory);
 233
 234    private:
 235     virtual ~MediaRequestContext();
 236
 237     scoped_ptr<net::HttpTransactionFactory> http_factory_;
 238   };
 239
 240   // A URLRequestContext for apps that owns its cookie store and HTTP factory,
 241   // to ensure they are deleted.
 242   class AppRequestContext : public ChromeURLRequestContext {
 243    public:
 244     AppRequestContext();
 245
 246     void SetCookieStore(net::CookieStore* cookie_store);
 247     void SetHttpTransactionFactory(
 248         scoped_ptr<net::HttpTransactionFactory> http_factory);
 249     void SetJobFactory(scoped_ptr<net::URLRequestJobFactory> job_factory);
 250
 251    private:
 252     virtual ~AppRequestContext();
 253
 254     scoped_refptr<net::CookieStore> cookie_store_;
 255     scoped_ptr<net::HttpTransactionFactory> http_factory_;
 256     scoped_ptr<net::URLRequestJobFactory> job_factory_;
 257   };
 258
 259   // Created on the UI thread, read on the IO thread during ProfileIOData lazy
 260   // initialization.
 261   struct ProfileParams {
 262     ProfileParams();
 263     ~ProfileParams();
 264
 265     base::FilePath path;
 266     IOThread* io_thread;
 267     scoped_refptr<CookieSettings> cookie_settings;
 268     scoped_refptr<HostContentSettingsMap> host_content_settings_map;
 269     scoped_refptr<net::SSLConfigService> ssl_config_service;
 270     scoped_refptr<net::CookieMonster::Delegate> cookie_monster_delegate;
 271     scoped_refptr<extensions::InfoMap> extension_info_map;
 272
 273     // This pointer exists only as a means of conveying a url job factory
 274     // pointer from the protocol handler registry on the UI thread to the
 275     // the URLRequestContext on the IO thread. The consumer MUST take
 276     // ownership of the object by calling release() on this pointer.
 277     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 278         protocol_handler_interceptor;
 279
 280     // We need to initialize the ProxyConfigService from the UI thread
 281     // because on linux it relies on initializing things through gconf,
 282     // and needs to be on the main thread.
 283     scoped_ptr<net::ProxyConfigService> proxy_config_service;
 284
 285 #if defined(ENABLE_MANAGED_USERS)
 286     scoped_refptr<const ManagedModeURLFilter> managed_mode_url_filter;
 287 #endif
 288
 289 #if defined(OS_CHROMEOS)
 290     std::string username_hash;
 291 #endif
 292
 293     // The profile this struct was populated from. It's passed as a void* to
 294     // ensure it's not accidently used on the IO thread. Before using it on the
 295     // UI thread, call ProfileManager::IsValidProfile to ensure it's alive.
 296     void* profile;
 297   };
 298
 299   explicit ProfileIOData(Profile::ProfileType profile_type);
 300
 301   static std::string GetSSLSessionCacheShard();
 302
 303   void InitializeOnUIThread(Profile* profile);
 304   void ApplyProfileParamsToContext(ChromeURLRequestContext* context) const;
 305
 306   scoped_ptr<net::URLRequestJobFactory> SetUpJobFactoryDefaults(
 307       scoped_ptr<net::URLRequestJobFactoryImpl> job_factory,
 308       content::ProtocolHandlerScopedVector protocol_interceptors,
 309       scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 310           protocol_handler_interceptor,
 311       net::NetworkDelegate* network_delegate,
 312       net::FtpTransactionFactory* ftp_transaction_factory) const;
 313
 314   // Called when the profile is destroyed.
 315   void ShutdownOnUIThread();
 316
 317   // A ServerBoundCertService object is created by a derived class of
 318   // ProfileIOData, and the derived class calls this method to set the
 319   // server_bound_cert_service_ member and transfers ownership to the base
 320   // class.
 321   void set_server_bound_cert_service(
 322       net::ServerBoundCertService* server_bound_cert_service) const;
 323
 324   ChromeNetworkDelegate* network_delegate() const {
 325     return network_delegate_.get();
 326   }
 327
 328   net::FraudulentCertificateReporter* fraudulent_certificate_reporter() const {
 329     return fraudulent_certificate_reporter_.get();
 330   }
 331
 332   net::ProxyService* proxy_service() const {
 333     return proxy_service_.get();
 334   }
 335
 336   base::WeakPtr<net::HttpServerProperties> http_server_properties() const;
 337
 338   void set_http_server_properties(
 339       scoped_ptr<net::HttpServerProperties> http_server_properties) const;
 340
 341   ChromeURLRequestContext* main_request_context() const {
 342     return main_request_context_.get();
 343   }
 344
 345   bool initialized() const {
 346     return initialized_;
 347   }
 348
 349   // Destroys the ResourceContext first, to cancel any URLRequests that are
 350   // using it still, before we destroy the member variables that those
 351   // URLRequests may be accessing.
 352   void DestroyResourceContext();
 353
 354   // Fills in fields of params using values from main_request_context_ and the
 355   // IOThread associated with profile_params.
 356   void PopulateNetworkSessionParams(
 357       const ProfileParams* profile_params,
 358       net::HttpNetworkSession::Params* params) const;
 359
 360   void SetCookieSettingsForTesting(CookieSettings* cookie_settings);
 361
 362   void set_signin_names_for_testing(SigninNamesOnIOThread* signin_names);
 363
 364  private:
 365   class ResourceContext : public content::ResourceContext {
 366    public:
 367     explicit ResourceContext(ProfileIOData* io_data);
 368     virtual ~ResourceContext();
 369
 370     // ResourceContext implementation:
 371     virtual net::HostResolver* GetHostResolver() OVERRIDE;
 372     virtual net::URLRequestContext* GetRequestContext() OVERRIDE;
 373     virtual scoped_ptr<net::ClientCertStore> CreateClientCertStore() OVERRIDE;
 374     virtual void CreateKeygenHandler(
 375         uint32 key_size_in_bits,
 376         const std::string& challenge_string,
 377         const GURL& url,
 378         const base::Callback<void(scoped_ptr<net::KeygenHandler>)>& callback)
 379         OVERRIDE;
 380     virtual bool AllowMicAccess(const GURL& origin) OVERRIDE;
 381     virtual bool AllowCameraAccess(const GURL& origin) OVERRIDE;
 382     virtual SaltCallback GetMediaDeviceIDSalt() OVERRIDE;
 383
 384    private:
 385     friend class ProfileIOData;
 386
 387     // Helper method that returns true if |type| is allowed for |origin|, false
 388     // otherwise.
 389     bool AllowContentAccess(const GURL& origin, ContentSettingsType type);
 390
 391     ProfileIOData* const io_data_;
 392
 393     net::HostResolver* host_resolver_;
 394     net::URLRequestContext* request_context_;
 395   };
 396
 397   typedef std::map<StoragePartitionDescriptor,
 398                    ChromeURLRequestContext*,
 399                    StoragePartitionDescriptorLess>
 400       URLRequestContextMap;
 401
 402   // --------------------------------------------
 403   // Virtual interface for subtypes to implement:
 404   // --------------------------------------------
 405
 406   // Does the actual initialization of the ProfileIOData subtype. Subtypes
 407   // should use the static helper functions above to implement this.
 408   virtual void InitializeInternal(
 409       ProfileParams* profile_params,
 410       content::ProtocolHandlerMap* protocol_handlers,
 411       content::ProtocolHandlerScopedVector protocol_interceptors) const = 0;
 412
 413   // Initializes the RequestContext for extensions.
 414   virtual void InitializeExtensionsRequestContext(
 415       ProfileParams* profile_params) const = 0;
 416   // Does an on-demand initialization of a RequestContext for the given
 417   // isolated app.
 418   virtual ChromeURLRequestContext* InitializeAppRequestContext(
 419       ChromeURLRequestContext* main_context,
 420       const StoragePartitionDescriptor& details,
 421       scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 422           protocol_handler_interceptor,
 423       content::ProtocolHandlerMap* protocol_handlers,
 424       content::ProtocolHandlerScopedVector protocol_interceptors) const = 0;
 425
 426   // Does an on-demand initialization of a media RequestContext for the given
 427   // isolated app.
 428   virtual ChromeURLRequestContext* InitializeMediaRequestContext(
 429       ChromeURLRequestContext* original_context,
 430       const StoragePartitionDescriptor& details) const = 0;
 431
 432   // These functions are used to transfer ownership of the lazily initialized
 433   // context from ProfileIOData to the URLRequestContextGetter.
 434   virtual ChromeURLRequestContext*
 435       AcquireMediaRequestContext() const = 0;
 436   virtual ChromeURLRequestContext* AcquireIsolatedAppRequestContext(
 437       ChromeURLRequestContext* main_context,
 438       const StoragePartitionDescriptor& partition_descriptor,
 439       scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 440           protocol_handler_interceptor,
 441       content::ProtocolHandlerMap* protocol_handlers,
 442       content::ProtocolHandlerScopedVector protocol_interceptors) const = 0;
 443   virtual ChromeURLRequestContext*
 444       AcquireIsolatedMediaRequestContext(
 445           ChromeURLRequestContext* app_context,
 446           const StoragePartitionDescriptor& partition_descriptor) const = 0;
 447
 448   // The order *DOES* matter for the majority of these member variables, so
 449   // don't move them around unless you know what you're doing!
 450   // General rules:
 451   //   * ResourceContext references the URLRequestContexts, so
 452   //   URLRequestContexts must outlive ResourceContext, hence ResourceContext
 453   //   should be destroyed first.
 454   //   * URLRequestContexts reference a whole bunch of members, so
 455   //   URLRequestContext needs to be destroyed before them.
 456   //   * Therefore, ResourceContext should be listed last, and then the
 457   //   URLRequestContexts, and then the URLRequestContext members.
 458   //   * Note that URLRequestContext members have a directed dependency graph
 459   //   too, so they must themselves be ordered correctly.
 460
 461   // Tracks whether or not we've been lazily initialized.
 462   mutable bool initialized_;
 463
 464   // Data from the UI thread from the Profile, used to initialize ProfileIOData.
 465   // Deleted after lazy initialization.
 466   mutable scoped_ptr<ProfileParams> profile_params_;
 467
 468   // Provides access to the email addresses of all signed in profiles.
 469   mutable scoped_ptr<SigninNamesOnIOThread> signin_names_;
 470
 471   // Used for testing.
 472   mutable base::Callback<scoped_ptr<net::ClientCertStore>()>
 473       client_cert_store_factory_;
 474
 475   mutable StringPrefMember google_services_user_account_id_;
 476   mutable StringPrefMember google_services_username_;
 477   mutable StringPrefMember google_services_username_pattern_;
 478   mutable BooleanPrefMember reverse_autologin_enabled_;
 479
 480   // During the reverse autologin request chain processing, this member saves
 481   // the email of the google account that is being signed into.
 482   std::string reverse_autologin_pending_email_;
 483
 484   mutable StringListPrefMember one_click_signin_rejected_email_list_;
 485
 486   mutable scoped_refptr<MediaDeviceIDSalt> media_device_id_salt_;
 487
 488   // Member variables which are pointed to by the various context objects.
 489   mutable BooleanPrefMember enable_referrers_;
 490   mutable BooleanPrefMember enable_do_not_track_;
 491   mutable BooleanPrefMember force_safesearch_;
 492   mutable BooleanPrefMember safe_browsing_enabled_;
 493   mutable BooleanPrefMember printing_enabled_;
 494   mutable BooleanPrefMember sync_disabled_;
 495   mutable BooleanPrefMember signin_allowed_;
 496   mutable BooleanPrefMember network_prediction_enabled_;
 497   // TODO(marja): Remove session_startup_pref_ if no longer needed.
 498   mutable IntegerPrefMember session_startup_pref_;
 499   mutable BooleanPrefMember quick_check_enabled_;
 500
 501   // The state of metrics reporting in the browser that this profile runs on.
 502   // Unfortunately, since ChromeOS has a separate representation of this state,
 503   // we need to make one available based on the platform.
 504 #if defined(OS_CHROMEOS)
 505   bool enable_metrics_;
 506 #else
 507   BooleanPrefMember enable_metrics_;
 508 #endif
 509
 510 #if defined(ENABLE_CONFIGURATION_POLICY)
 511   // Pointed to by NetworkDelegate.
 512   mutable scoped_ptr<policy::URLBlacklistManager> url_blacklist_manager_;
 513   mutable scoped_ptr<policy::PolicyHeaderIOHelper> policy_header_helper_;
 514 #endif
 515
 516   // Pointed to by URLRequestContext.
 517   mutable scoped_refptr<extensions::InfoMap> extension_info_map_;
 518   mutable scoped_ptr<net::ServerBoundCertService> server_bound_cert_service_;
 519   mutable scoped_ptr<ChromeNetworkDelegate> network_delegate_;
 520   mutable scoped_ptr<net::FraudulentCertificateReporter>
 521       fraudulent_certificate_reporter_;
 522   mutable scoped_ptr<net::ProxyService> proxy_service_;
 523   mutable scoped_ptr<net::TransportSecurityState> transport_security_state_;
 524   mutable scoped_ptr<net::HttpServerProperties>
 525       http_server_properties_;
 526 #if defined(OS_CHROMEOS)
 527   mutable scoped_ptr<policy::PolicyCertVerifier> cert_verifier_;
 528   mutable std::string username_hash_;
 529 #endif
 530
 531   mutable scoped_ptr<net::TransportSecurityPersister>
 532       transport_security_persister_;
 533
 534   // These are only valid in between LazyInitialize() and their accessor being
 535   // called.
 536   mutable scoped_ptr<ChromeURLRequestContext> main_request_context_;
 537   mutable scoped_ptr<ChromeURLRequestContext> extensions_request_context_;
 538   // One URLRequestContext per isolated app for main and media requests.
 539   mutable URLRequestContextMap app_request_context_map_;
 540   mutable URLRequestContextMap isolated_media_request_context_map_;
 541
 542   mutable scoped_ptr<ResourceContext> resource_context_;
 543
 544   mutable scoped_refptr<CookieSettings> cookie_settings_;
 545
 546   mutable scoped_refptr<HostContentSettingsMap> host_content_settings_map_;
 547
 548   mutable scoped_ptr<ChromeHttpUserAgentSettings>
 549       chrome_http_user_agent_settings_;
 550
 551 #if defined(ENABLE_MANAGED_USERS)
 552   mutable scoped_refptr<const ManagedModeURLFilter> managed_mode_url_filter_;
 553 #endif
 554
 555   // TODO(jhawkins): Remove once crbug.com/102004 is fixed.
 556   bool initialized_on_UI_thread_;
 557
 558   const Profile::ProfileType profile_type_;
 559
 560   DISALLOW_COPY_AND_ASSIGN(ProfileIOData);
 561 };
 562
 563 #endif  // CHROME_BROWSER_PROFILES_PROFILE_IO_DATA_H_