profile_io_data.h revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9
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 30class ChromeHttpUserAgentSettings; 31class ChromeNetworkDelegate; 32class CookieSettings; 33class HostContentSettingsMap; 34class ManagedModeURLFilter; 35class MediaDeviceIDSalt; 36class ProtocolHandlerRegistry; 37class SigninNamesOnIOThread; 38 39namespace extensions { 40class InfoMap; 41} 42 43namespace net { 44class CookieStore; 45class FraudulentCertificateReporter; 46class FtpTransactionFactory; 47class HttpServerProperties; 48class HttpTransactionFactory; 49class ServerBoundCertService; 50class ProxyConfigService; 51class ProxyService; 52class SSLConfigService; 53class TransportSecurityPersister; 54class TransportSecurityState; 55class URLRequestJobFactoryImpl; 56} // namespace net 57 58namespace policy { 59class PolicyCertVerifier; 60class PolicyHeaderIOHelper; 61class 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). 69class 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_ 564