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 // This class gathers state related to a single user profile. 6 7 #ifndef CHROME_BROWSER_PROFILES_PROFILE_H_ 8 #define CHROME_BROWSER_PROFILES_PROFILE_H_ 9 10 #include <string> 11 12 #include "base/basictypes.h" 13 #include "base/containers/hash_tables.h" 14 #include "base/logging.h" 15 #include "content/public/browser/browser_context.h" 16 #include "content/public/browser/content_browser_client.h" 17 #include "net/url_request/url_request_job_factory.h" 18 19 class ChromeAppCacheService; 20 class ExtensionService; 21 class ExtensionSpecialStoragePolicy; 22 class FaviconService; 23 class HostContentSettingsMap; 24 class PasswordStore; 25 class PrefProxyConfigTracker; 26 class PrefService; 27 class PromoCounter; 28 class ProtocolHandlerRegistry; 29 class TestingProfile; 30 class WebDataService; 31 32 namespace android { 33 class TabContentsProvider; 34 } 35 36 namespace base { 37 class SequencedTaskRunner; 38 class Time; 39 } 40 41 namespace chrome_browser_net { 42 class Predictor; 43 } 44 45 namespace chromeos { 46 class LibCrosServiceLibraryImpl; 47 class ResetDefaultProxyConfigServiceTask; 48 } 49 50 namespace content { 51 class WebUI; 52 } 53 54 namespace fileapi { 55 class FileSystemContext; 56 } 57 58 namespace history { 59 class ShortcutsBackend; 60 class TopSites; 61 } 62 63 namespace net { 64 class SSLConfigService; 65 } 66 67 namespace user_prefs { 68 class PrefRegistrySyncable; 69 } 70 71 // Instead of adding more members to Profile, consider creating a 72 // BrowserContextKeyedService. See 73 // http://dev.chromium.org/developers/design-documents/profile-architecture 74 class Profile : public content::BrowserContext { 75 public: 76 // Profile services are accessed with the following parameter. This parameter 77 // defines what the caller plans to do with the service. 78 // The caller is responsible for not performing any operation that would 79 // result in persistent implicit records while using an OffTheRecord profile. 80 // This flag allows the profile to perform an additional check. 81 // 82 // It also gives us an opportunity to perform further checks in the future. We 83 // could, for example, return an history service that only allow some specific 84 // methods. 85 enum ServiceAccessType { 86 // The caller plans to perform a read or write that takes place as a result 87 // of the user input. Use this flag when the operation you are doing can be 88 // performed while incognito. (ex: creating a bookmark) 89 // 90 // Since EXPLICIT_ACCESS means "as a result of a user action", this request 91 // always succeeds. 92 EXPLICIT_ACCESS, 93 94 // The caller plans to call a method that will permanently change some data 95 // in the profile, as part of Chrome's implicit data logging. Use this flag 96 // when you are about to perform an operation which is incompatible with the 97 // incognito mode. 98 IMPLICIT_ACCESS 99 }; 100 101 enum CreateStatus { 102 // Profile services were not created due to a local error (e.g., disk full). 103 CREATE_STATUS_LOCAL_FAIL, 104 // Profile services were not created due to a remote error (e.g., network 105 // down during limited-user registration). 106 CREATE_STATUS_REMOTE_FAIL, 107 // Profile created but before initializing extensions and promo resources. 108 CREATE_STATUS_CREATED, 109 // Profile is created, extensions and promo resources are initialized. 110 CREATE_STATUS_INITIALIZED, 111 // Profile creation (managed-user registration, generally) was canceled 112 // by the user. 113 CREATE_STATUS_CANCELED, 114 MAX_CREATE_STATUS // For histogram display. 115 }; 116 117 enum CreateMode { 118 CREATE_MODE_SYNCHRONOUS, 119 CREATE_MODE_ASYNCHRONOUS 120 }; 121 122 enum ExitType { 123 // A normal shutdown. The user clicked exit/closed last window of the 124 // profile. 125 EXIT_NORMAL, 126 127 // The exit was the result of the system shutting down. 128 EXIT_SESSION_ENDED, 129 130 EXIT_CRASHED, 131 }; 132 133 class Delegate { 134 public: 135 virtual ~Delegate(); 136 137 // Called when creation of the profile is finished. 138 virtual void OnProfileCreated(Profile* profile, 139 bool success, 140 bool is_new_profile) = 0; 141 }; 142 143 // Key used to bind profile to the widget with which it is associated. 144 static const char kProfileKey[]; 145 146 Profile(); 147 virtual ~Profile(); 148 149 // Profile prefs are registered as soon as the prefs are loaded for the first 150 // time. 151 static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry); 152 153 // Gets task runner for I/O operations associated with |profile|. 154 static scoped_refptr<base::SequencedTaskRunner> GetTaskRunnerForProfile( 155 Profile* profile); 156 157 // Create a new profile given a path. If |create_mode| is 158 // CREATE_MODE_ASYNCHRONOUS then the profile is initialized asynchronously. 159 static Profile* CreateProfile(const base::FilePath& path, 160 Delegate* delegate, 161 CreateMode create_mode); 162 163 // Returns the profile corresponding to the given browser context. 164 static Profile* FromBrowserContext(content::BrowserContext* browser_context); 165 166 // Returns the profile corresponding to the given WebUI. 167 static Profile* FromWebUI(content::WebUI* web_ui); 168 169 // content::BrowserContext implementation ------------------------------------ 170 171 // Typesafe upcast. 172 virtual TestingProfile* AsTestingProfile(); 173 174 // Returns sequenced task runner where browser context dependent I/O 175 // operations should be performed. 176 virtual scoped_refptr<base::SequencedTaskRunner> GetIOTaskRunner() = 0; 177 178 // Returns the name associated with this profile. This name is displayed in 179 // the browser frame. 180 virtual std::string GetProfileName() = 0; 181 182 // Return the incognito version of this profile. The returned pointer 183 // is owned by the receiving profile. If the receiving profile is off the 184 // record, the same profile is returned. 185 // 186 // WARNING: This will create the OffTheRecord profile if it doesn't already 187 // exist. If this isn't what you want, you need to check 188 // HasOffTheRecordProfile() first. 189 virtual Profile* GetOffTheRecordProfile() = 0; 190 191 // Destroys the incognito profile. 192 virtual void DestroyOffTheRecordProfile() = 0; 193 194 // True if an incognito profile exists. 195 virtual bool HasOffTheRecordProfile() = 0; 196 197 // Return the original "recording" profile. This method returns this if the 198 // profile is not incognito. 199 virtual Profile* GetOriginalProfile() = 0; 200 201 // Returns whether the profile is managed (see ManagedUserService). 202 virtual bool IsManaged() = 0; 203 204 // Returns a pointer to the TopSites (thumbnail manager) instance 205 // for this profile. 206 virtual history::TopSites* GetTopSites() = 0; 207 208 // Variant of GetTopSites that doesn't force creation. 209 virtual history::TopSites* GetTopSitesWithoutCreating() = 0; 210 211 // DEPRECATED. Instead, use ExtensionSystem::extension_service(). 212 // Retrieves a pointer to the ExtensionService associated with this 213 // profile. The ExtensionService is created at startup. 214 // TODO(yoz): remove this accessor (bug 104095). 215 virtual ExtensionService* GetExtensionService() = 0; 216 217 // Accessor. The instance is created upon first access. 218 virtual ExtensionSpecialStoragePolicy* 219 GetExtensionSpecialStoragePolicy() = 0; 220 221 // Retrieves a pointer to the PrefService that manages the 222 // preferences for this user profile. 223 virtual PrefService* GetPrefs() = 0; 224 225 // Retrieves a pointer to the PrefService that manages the preferences 226 // for OffTheRecord Profiles. This PrefService is lazily created the first 227 // time that this method is called. 228 virtual PrefService* GetOffTheRecordPrefs() = 0; 229 230 // Returns the main request context. 231 virtual net::URLRequestContextGetter* GetRequestContext() = 0; 232 233 // Returns the request context used for extension-related requests. This 234 // is only used for a separate cookie store currently. 235 virtual net::URLRequestContextGetter* GetRequestContextForExtensions() = 0; 236 237 // Returns the SSLConfigService for this profile. 238 virtual net::SSLConfigService* GetSSLConfigService() = 0; 239 240 // Returns the Hostname <-> Content settings map for this profile. 241 virtual HostContentSettingsMap* GetHostContentSettingsMap() = 0; 242 243 // Return whether 2 profiles are the same. 2 profiles are the same if they 244 // represent the same profile. This can happen if there is pointer equality 245 // or if one profile is the incognito version of another profile (or vice 246 // versa). 247 virtual bool IsSameProfile(Profile* profile) = 0; 248 249 // Returns the time the profile was started. This is not the time the profile 250 // was created, rather it is the time the user started chrome and logged into 251 // this profile. For the single profile case, this corresponds to the time 252 // the user started chrome. 253 virtual base::Time GetStartTime() const = 0; 254 255 // Creates the main net::URLRequestContextGetter that will be returned by 256 // GetRequestContext(). Should only be called once per ContentBrowserClient 257 // object. This function is exposed because of the circular dependency where 258 // GetStoragePartition() is used to retrieve the request context, but creation 259 // still has to happen in the Profile so the StoragePartition calls 260 // ContextBrowserClient to call this function. 261 // TODO(ajwong): Remove once http://crbug.com/159193 is resolved. 262 virtual net::URLRequestContextGetter* CreateRequestContext( 263 content::ProtocolHandlerMap* protocol_handlers) = 0; 264 265 // Creates the net::URLRequestContextGetter for a StoragePartition. Should 266 // only be called once per partition_path per ContentBrowserClient object. 267 // This function is exposed because the request context is retrieved from the 268 // StoragePartition, but creation still has to happen in the Profile so the 269 // StoragePartition calls ContextBrowserClient to call this function. 270 // TODO(ajwong): Remove once http://crbug.com/159193 is resolved. 271 virtual net::URLRequestContextGetter* CreateRequestContextForStoragePartition( 272 const base::FilePath& partition_path, 273 bool in_memory, 274 content::ProtocolHandlerMap* protocol_handlers) = 0; 275 276 // Returns the last directory that was chosen for uploading or opening a file. 277 virtual base::FilePath last_selected_directory() = 0; 278 virtual void set_last_selected_directory(const base::FilePath& path) = 0; 279 280 #if defined(OS_CHROMEOS) 281 enum AppLocaleChangedVia { 282 // Caused by chrome://settings change. 283 APP_LOCALE_CHANGED_VIA_SETTINGS, 284 // Locale has been reverted via LocaleChangeGuard. 285 APP_LOCALE_CHANGED_VIA_REVERT, 286 // From login screen. 287 APP_LOCALE_CHANGED_VIA_LOGIN, 288 // Source unknown. 289 APP_LOCALE_CHANGED_VIA_UNKNOWN 290 }; 291 292 // Changes application locale for a profile. 293 virtual void ChangeAppLocale( 294 const std::string& locale, AppLocaleChangedVia via) = 0; 295 296 // Called after login. 297 virtual void OnLogin() = 0; 298 299 // Creates ChromeOS's EnterpriseExtensionListener. 300 virtual void SetupChromeOSEnterpriseExtensionObserver() = 0; 301 302 // Initializes Chrome OS's preferences. 303 virtual void InitChromeOSPreferences() = 0; 304 #endif // defined(OS_CHROMEOS) 305 306 // Returns the helper object that provides the proxy configuration service 307 // access to the the proxy configuration possibly defined by preferences. 308 virtual PrefProxyConfigTracker* GetProxyConfigTracker() = 0; 309 310 // Returns the Predictor object used for dns prefetch. 311 virtual chrome_browser_net::Predictor* GetNetworkPredictor() = 0; 312 313 // Deletes all network related data since |time|. It deletes transport 314 // security state since |time| and it also deletes HttpServerProperties data. 315 // Works asynchronously, however if the |completion| callback is non-null, it 316 // will be posted on the UI thread once the removal process completes. 317 // Be aware that theoretically it is possible that |completion| will be 318 // invoked after the Profile instance has been destroyed. 319 virtual void ClearNetworkingHistorySince(base::Time time, 320 const base::Closure& completion) = 0; 321 322 // Returns the home page for this profile. 323 virtual GURL GetHomePage() = 0; 324 325 // Returns whether or not the profile was created by a version of Chrome 326 // more recent (or equal to) the one specified. 327 virtual bool WasCreatedByVersionOrLater(const std::string& version) = 0; 328 329 std::string GetDebugName(); 330 331 // Returns whether it is a guest session. 332 virtual bool IsGuestSession() const; 333 334 // Did the user restore the last session? This is set by SessionRestore. 335 void set_restored_last_session(bool restored_last_session) { 336 restored_last_session_ = restored_last_session; 337 } 338 bool restored_last_session() const { 339 return restored_last_session_; 340 } 341 342 // Sets the ExitType for the profile. This may be invoked multiple times 343 // during shutdown; only the first such change (the transition from 344 // EXIT_CRASHED to one of the other values) is written to prefs, any 345 // later calls are ignored. 346 // 347 // NOTE: this is invoked internally on a normal shutdown, but is public so 348 // that it can be invoked when the user logs out/powers down (WM_ENDSESSION), 349 // or to handle backgrounding/foregrounding on mobile. 350 virtual void SetExitType(ExitType exit_type) = 0; 351 352 // Returns how the last session was shutdown. 353 virtual ExitType GetLastSessionExitType() = 0; 354 355 // Stop sending accessibility events until ResumeAccessibilityEvents(). 356 // Calls to Pause nest; no events will be sent until the number of 357 // Resume calls matches the number of Pause calls received. 358 void PauseAccessibilityEvents() { 359 accessibility_pause_level_++; 360 } 361 362 void ResumeAccessibilityEvents() { 363 DCHECK_GT(accessibility_pause_level_, 0); 364 accessibility_pause_level_--; 365 } 366 367 bool ShouldSendAccessibilityEvents() { 368 return 0 == accessibility_pause_level_; 369 } 370 371 // Returns whether the profile is new. A profile is new if the browser has 372 // not been shut down since the profile was created. 373 bool IsNewProfile(); 374 375 // Checks whether sync is configurable by the user. Returns false if sync is 376 // disabled or controlled by configuration management. 377 bool IsSyncAccessible(); 378 379 // Send NOTIFICATION_PROFILE_DESTROYED for this Profile, if it has not 380 // already been sent. It is necessary because most Profiles are destroyed by 381 // ProfileDestroyer, but in tests, some are not. 382 void MaybeSendDestroyedNotification(); 383 384 // Creates an OffTheRecordProfile which points to this Profile. 385 Profile* CreateOffTheRecordProfile(); 386 387 private: 388 bool restored_last_session_; 389 390 // Used to prevent the notification that this Profile is destroyed from 391 // being sent twice. 392 bool sent_destroyed_notification_; 393 394 // Accessibility events will only be propagated when the pause 395 // level is zero. PauseAccessibilityEvents and ResumeAccessibilityEvents 396 // increment and decrement the level, respectively, rather than set it to 397 // true or false, so that calls can be nested. 398 int accessibility_pause_level_; 399 400 DISALLOW_COPY_AND_ASSIGN(Profile); 401 }; 402 403 #if defined(COMPILER_GCC) 404 namespace BASE_HASH_NAMESPACE { 405 406 template<> 407 struct hash<Profile*> { 408 std::size_t operator()(Profile* const& p) const { 409 return reinterpret_cast<std::size_t>(p); 410 } 411 }; 412 413 } // namespace BASE_HASH_NAMESPACE 414 #endif 415 416 #endif // CHROME_BROWSER_PROFILES_PROFILE_H_ 417