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_TEST_BASE_TESTING_PROFILE_H_ 6 #define CHROME_TEST_BASE_TESTING_PROFILE_H_ 7 8 #include <string> 9 10 #include "base/files/scoped_temp_dir.h" 11 #include "base/memory/ref_counted.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "chrome/browser/profiles/profile.h" 14 #include "components/domain_reliability/clear_mode.h" 15 #include "components/keyed_service/content/browser_context_keyed_service_factory.h" 16 17 namespace content { 18 class MockResourceContext; 19 class SSLHostStateDelegate; 20 } 21 22 namespace history { 23 class TopSites; 24 } 25 26 namespace net { 27 class CookieMonster; 28 class URLRequestContextGetter; 29 } 30 31 namespace policy { 32 class PolicyService; 33 class ProfilePolicyConnector; 34 class SchemaRegistryService; 35 } 36 37 namespace storage { 38 class SpecialStoragePolicy; 39 } 40 41 class BrowserContextDependencyManager; 42 class ExtensionSpecialStoragePolicy; 43 class HostContentSettingsMap; 44 class PrefServiceSyncable; 45 class TestingPrefServiceSyncable; 46 47 class TestingProfile : public Profile { 48 public: 49 // Profile directory name for the test user. This is "Default" on most 50 // platforms but must be different on ChromeOS because a logged-in user cannot 51 // use "Default" as profile directory. 52 // Browser- and UI tests should always use this to get to the user's profile 53 // directory. Unit-tests, though, should use |kInitialProfile|, which is 54 // always "Default", because they are runnining without logged-in user. 55 static const char kTestUserProfileDir[]; 56 57 // Default constructor that cannot be used with multi-profiles. 58 TestingProfile(); 59 60 typedef std::vector<std::pair< 61 BrowserContextKeyedServiceFactory*, 62 BrowserContextKeyedServiceFactory::TestingFactoryFunction> > 63 TestingFactories; 64 65 // Helper class for building an instance of TestingProfile (allows injecting 66 // mocks for various services prior to profile initialization). 67 // TODO(atwilson): Remove non-default constructors and various setters in 68 // favor of using the Builder API. 69 class Builder { 70 public: 71 Builder(); 72 ~Builder(); 73 74 // Sets a Delegate to be called back during profile init. This causes the 75 // final initialization to be performed via a task so the caller must run 76 // a MessageLoop. Caller maintains ownership of the Delegate 77 // and must manage its lifetime so it continues to exist until profile 78 // initialization is complete. 79 void SetDelegate(Delegate* delegate); 80 81 // Adds a testing factory to the TestingProfile. These testing factories 82 // are applied before the ProfileKeyedServices are created. 83 void AddTestingFactory( 84 BrowserContextKeyedServiceFactory* service_factory, 85 BrowserContextKeyedServiceFactory::TestingFactoryFunction callback); 86 87 #if defined(ENABLE_EXTENSIONS) 88 // Sets the ExtensionSpecialStoragePolicy to be returned by 89 // GetExtensionSpecialStoragePolicy(). 90 void SetExtensionSpecialStoragePolicy( 91 scoped_refptr<ExtensionSpecialStoragePolicy> policy); 92 #endif 93 94 // Sets the path to the directory to be used to hold profile data. 95 void SetPath(const base::FilePath& path); 96 97 // Sets the PrefService to be used by this profile. 98 void SetPrefService(scoped_ptr<PrefServiceSyncable> prefs); 99 100 // Makes the Profile being built a guest profile. 101 void SetGuestSession(); 102 103 // Sets the supervised user ID (which is empty by default). If it is set to 104 // a non-empty string, the profile is supervised. 105 void SetSupervisedUserId(const std::string& supervised_user_id); 106 107 // Sets the PolicyService to be used by this profile. 108 void SetPolicyService(scoped_ptr<policy::PolicyService> policy_service); 109 110 // Creates the TestingProfile using previously-set settings. 111 scoped_ptr<TestingProfile> Build(); 112 113 // Build an incognito profile, owned by |original_profile|. Note: unless you 114 // need to customize the Builder, or access TestingProfile member functions, 115 // you can use original_profile->GetOffTheRecordProfile(). 116 TestingProfile* BuildIncognito(TestingProfile* original_profile); 117 118 private: 119 // If true, Build() has already been called. 120 bool build_called_; 121 122 // Various staging variables where values are held until Build() is invoked. 123 scoped_ptr<PrefServiceSyncable> pref_service_; 124 #if defined(ENABLE_EXTENSIONS) 125 scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy_; 126 #endif 127 base::FilePath path_; 128 Delegate* delegate_; 129 bool guest_session_; 130 std::string supervised_user_id_; 131 scoped_ptr<policy::PolicyService> policy_service_; 132 TestingFactories testing_factories_; 133 134 DISALLOW_COPY_AND_ASSIGN(Builder); 135 }; 136 137 // Multi-profile aware constructor that takes the path to a directory managed 138 // for this profile. This constructor is meant to be used by 139 // TestingProfileManager::CreateTestingProfile. If you need to create multi- 140 // profile profiles, use that factory method instead of this directly. 141 // Exception: if you need to create multi-profile profiles for testing the 142 // ProfileManager, then use the constructor below instead. 143 explicit TestingProfile(const base::FilePath& path); 144 145 // Multi-profile aware constructor that takes the path to a directory managed 146 // for this profile and a delegate. This constructor is meant to be used 147 // for unittesting the ProfileManager. 148 TestingProfile(const base::FilePath& path, Delegate* delegate); 149 150 // Full constructor allowing the setting of all possible instance data. 151 // Callers should use Builder::Build() instead of invoking this constructor. 152 TestingProfile(const base::FilePath& path, 153 Delegate* delegate, 154 #if defined(ENABLE_EXTENSIONS) 155 scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy, 156 #endif 157 scoped_ptr<PrefServiceSyncable> prefs, 158 TestingProfile* parent, 159 bool guest_session, 160 const std::string& supervised_user_id, 161 scoped_ptr<policy::PolicyService> policy_service, 162 const TestingFactories& factories); 163 164 virtual ~TestingProfile(); 165 166 // Creates the favicon service. Consequent calls would recreate the service. 167 void CreateFaviconService(); 168 169 // Creates the history service. If |delete_file| is true, the history file is 170 // deleted first, then the HistoryService is created. As TestingProfile 171 // deletes the directory containing the files used by HistoryService, this 172 // only matters if you're recreating the HistoryService. If |no_db| is true, 173 // the history backend will fail to initialize its database; this is useful 174 // for testing error conditions. Returns true on success. 175 bool CreateHistoryService(bool delete_file, bool no_db) WARN_UNUSED_RESULT; 176 177 // Shuts down and nulls out the reference to HistoryService. 178 void DestroyHistoryService(); 179 180 // Creates TopSites. This returns immediately, and top sites may not be 181 // loaded. Use BlockUntilTopSitesLoaded to ensure TopSites has finished 182 // loading. 183 void CreateTopSites(); 184 185 // Shuts down and nulls out the reference to TopSites. 186 void DestroyTopSites(); 187 188 // Creates the BookmarkBarModel. If not invoked the bookmark bar model is 189 // NULL. If |delete_file| is true, the bookmarks file is deleted first, then 190 // the model is created. As TestingProfile deletes the directory containing 191 // the files used by HistoryService, the boolean only matters if you're 192 // recreating the BookmarkModel. 193 // 194 // NOTE: this does not block until the bookmarks are loaded. For that use 195 // WaitForBookmarkModelToLoad(). 196 void CreateBookmarkModel(bool delete_file); 197 198 // Creates a WebDataService. If not invoked, the web data service is NULL. 199 void CreateWebDataService(); 200 201 // Blocks until the HistoryService finishes restoring its in-memory cache. 202 // This is NOT invoked from CreateHistoryService. 203 void BlockUntilHistoryIndexIsRefreshed(); 204 205 // Blocks until TopSites finishes loading. 206 void BlockUntilTopSitesLoaded(); 207 208 // Allow setting a profile as Guest after-the-fact to simplify some tests. 209 void SetGuestSession(bool guest); 210 211 TestingPrefServiceSyncable* GetTestingPrefService(); 212 213 // Called on the parent of an incognito |profile|. Usually called from the 214 // constructor of an incognito TestingProfile, but can also be used by tests 215 // to provide an OffTheRecordProfileImpl instance. 216 void SetOffTheRecordProfile(scoped_ptr<Profile> profile); 217 218 // content::BrowserContext 219 virtual base::FilePath GetPath() const OVERRIDE; 220 virtual scoped_refptr<base::SequencedTaskRunner> GetIOTaskRunner() OVERRIDE; 221 virtual bool IsOffTheRecord() const OVERRIDE; 222 virtual content::DownloadManagerDelegate* 223 GetDownloadManagerDelegate() OVERRIDE; 224 virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE; 225 virtual net::URLRequestContextGetter* CreateRequestContext( 226 content::ProtocolHandlerMap* protocol_handlers, 227 content::URLRequestInterceptorScopedVector request_interceptors) OVERRIDE; 228 virtual net::URLRequestContextGetter* GetRequestContextForRenderProcess( 229 int renderer_child_id) OVERRIDE; 230 virtual content::ResourceContext* GetResourceContext() OVERRIDE; 231 virtual content::BrowserPluginGuestManager* GetGuestManager() OVERRIDE; 232 virtual storage::SpecialStoragePolicy* GetSpecialStoragePolicy() OVERRIDE; 233 virtual content::PushMessagingService* GetPushMessagingService() OVERRIDE; 234 virtual content::SSLHostStateDelegate* GetSSLHostStateDelegate() OVERRIDE; 235 236 virtual TestingProfile* AsTestingProfile() OVERRIDE; 237 238 // Profile 239 virtual std::string GetProfileName() OVERRIDE; 240 virtual ProfileType GetProfileType() const OVERRIDE; 241 242 // DEPRECATED, because it's fragile to change a profile from non-incognito 243 // to incognito after the ProfileKeyedServices have been created (some 244 // ProfileKeyedServices either should not exist in incognito mode, or will 245 // crash when they try to get references to other services they depend on, 246 // but do not exist in incognito mode). 247 // TODO(atwilson): Remove this API (http://crbug.com/277296). 248 // 249 // Changes a profile's to/from incognito mode temporarily - profile will be 250 // returned to non-incognito before destruction to allow services to 251 // properly shutdown. This is only supported for legacy tests - new tests 252 // should create a true incognito profile using Builder::SetIncognito() or 253 // by using the TestingProfile constructor that allows setting the incognito 254 // flag. 255 void ForceIncognito(bool force_incognito) { 256 force_incognito_ = force_incognito; 257 } 258 259 virtual Profile* GetOffTheRecordProfile() OVERRIDE; 260 virtual void DestroyOffTheRecordProfile() OVERRIDE {} 261 virtual bool HasOffTheRecordProfile() OVERRIDE; 262 virtual Profile* GetOriginalProfile() OVERRIDE; 263 virtual bool IsSupervised() OVERRIDE; 264 #if defined(ENABLE_EXTENSIONS) 265 void SetExtensionSpecialStoragePolicy( 266 ExtensionSpecialStoragePolicy* extension_special_storage_policy); 267 #endif 268 virtual ExtensionSpecialStoragePolicy* 269 GetExtensionSpecialStoragePolicy() OVERRIDE; 270 // TODO(ajwong): Remove this API in favor of directly retrieving the 271 // CookieStore from the StoragePartition after ExtensionURLRequestContext 272 // has been removed. 273 net::CookieMonster* GetCookieMonster(); 274 275 virtual PrefService* GetPrefs() OVERRIDE; 276 277 virtual history::TopSites* GetTopSites() OVERRIDE; 278 virtual history::TopSites* GetTopSitesWithoutCreating() OVERRIDE; 279 280 virtual net::URLRequestContextGetter* GetMediaRequestContext() OVERRIDE; 281 virtual net::URLRequestContextGetter* GetMediaRequestContextForRenderProcess( 282 int renderer_child_id) OVERRIDE; 283 virtual net::URLRequestContextGetter* 284 GetRequestContextForExtensions() OVERRIDE; 285 virtual net::URLRequestContextGetter* 286 GetMediaRequestContextForStoragePartition( 287 const base::FilePath& partition_path, 288 bool in_memory) OVERRIDE; 289 virtual net::URLRequestContextGetter* CreateRequestContextForStoragePartition( 290 const base::FilePath& partition_path, 291 bool in_memory, 292 content::ProtocolHandlerMap* protocol_handlers, 293 content::URLRequestInterceptorScopedVector request_interceptors) OVERRIDE; 294 virtual net::SSLConfigService* GetSSLConfigService() OVERRIDE; 295 virtual HostContentSettingsMap* GetHostContentSettingsMap() OVERRIDE; 296 void set_last_session_exited_cleanly(bool value) { 297 last_session_exited_cleanly_ = value; 298 } 299 virtual bool IsSameProfile(Profile *p) OVERRIDE; 300 virtual base::Time GetStartTime() const OVERRIDE; 301 virtual base::FilePath last_selected_directory() OVERRIDE; 302 virtual void set_last_selected_directory(const base::FilePath& path) OVERRIDE; 303 virtual bool WasCreatedByVersionOrLater(const std::string& version) OVERRIDE; 304 virtual bool IsGuestSession() const OVERRIDE; 305 virtual void SetExitType(ExitType exit_type) OVERRIDE {} 306 virtual ExitType GetLastSessionExitType() OVERRIDE; 307 #if defined(OS_CHROMEOS) 308 virtual void ChangeAppLocale(const std::string&, 309 AppLocaleChangedVia) OVERRIDE { 310 } 311 virtual void OnLogin() OVERRIDE { 312 } 313 virtual void InitChromeOSPreferences() OVERRIDE { 314 } 315 #endif // defined(OS_CHROMEOS) 316 317 virtual PrefProxyConfigTracker* GetProxyConfigTracker() OVERRIDE; 318 319 // Schedules a task on the history backend and runs a nested loop until the 320 // task is processed. This has the effect of blocking the caller until the 321 // history service processes all pending requests. 322 void BlockUntilHistoryProcessesPendingRequests(); 323 324 virtual chrome_browser_net::Predictor* GetNetworkPredictor() OVERRIDE; 325 virtual DevToolsNetworkController* GetDevToolsNetworkController() OVERRIDE; 326 virtual void ClearNetworkingHistorySince( 327 base::Time time, 328 const base::Closure& completion) OVERRIDE; 329 virtual GURL GetHomePage() OVERRIDE; 330 331 virtual PrefService* GetOffTheRecordPrefs() OVERRIDE; 332 333 void set_profile_name(const std::string& profile_name) { 334 profile_name_ = profile_name; 335 } 336 337 protected: 338 base::Time start_time_; 339 scoped_ptr<PrefServiceSyncable> prefs_; 340 // ref only for right type, lifecycle is managed by prefs_ 341 TestingPrefServiceSyncable* testing_prefs_; 342 343 private: 344 // Creates a temporary directory for use by this profile. 345 void CreateTempProfileDir(); 346 347 // Common initialization between the two constructors. 348 void Init(); 349 350 // Finishes initialization when a profile is created asynchronously. 351 void FinishInit(); 352 353 // Creates a TestingPrefService and associates it with the TestingProfile. 354 void CreateTestingPrefService(); 355 356 // Initializes |prefs_| for an incognito profile, derived from 357 // |original_profile_|. 358 void CreateIncognitoPrefService(); 359 360 // Creates a ProfilePolicyConnector that the ProfilePolicyConnectorFactory 361 // maps to this profile. 362 void CreateProfilePolicyConnector(); 363 364 // Internally, this is a TestURLRequestContextGetter that creates a dummy 365 // request context. Currently, only the CookieMonster is hooked up. 366 scoped_refptr<net::URLRequestContextGetter> extensions_request_context_; 367 368 bool force_incognito_; 369 scoped_ptr<Profile> incognito_profile_; 370 TestingProfile* original_profile_; 371 372 bool guest_session_; 373 374 std::string supervised_user_id_; 375 376 // Did the last session exit cleanly? Default is true. 377 bool last_session_exited_cleanly_; 378 379 scoped_refptr<HostContentSettingsMap> host_content_settings_map_; 380 381 base::FilePath last_selected_directory_; 382 scoped_refptr<history::TopSites> top_sites_; // For history and thumbnails. 383 384 #if defined(ENABLE_EXTENSIONS) 385 scoped_refptr<ExtensionSpecialStoragePolicy> 386 extension_special_storage_policy_; 387 #endif 388 389 // The proxy prefs tracker. 390 scoped_ptr<PrefProxyConfigTracker> pref_proxy_config_tracker_; 391 392 // We use a temporary directory to store testing profile data. In a multi- 393 // profile environment, this is invalid and the directory is managed by the 394 // TestingProfileManager. 395 base::ScopedTempDir temp_dir_; 396 // The path to this profile. This will be valid in either of the two above 397 // cases. 398 base::FilePath profile_path_; 399 400 // We keep a weak pointer to the dependency manager we want to notify on our 401 // death. Defaults to the Singleton implementation but overridable for 402 // testing. 403 BrowserContextDependencyManager* browser_context_dependency_manager_; 404 405 // Owned, but must be deleted on the IO thread so not placing in a 406 // scoped_ptr<>. 407 content::MockResourceContext* resource_context_; 408 409 #if defined(ENABLE_CONFIGURATION_POLICY) 410 scoped_ptr<policy::SchemaRegistryService> schema_registry_service_; 411 #endif 412 scoped_ptr<policy::ProfilePolicyConnector> profile_policy_connector_; 413 414 // Weak pointer to a delegate for indicating that a profile was created. 415 Delegate* delegate_; 416 417 std::string profile_name_; 418 419 scoped_ptr<policy::PolicyService> policy_service_; 420 }; 421 422 #endif // CHROME_TEST_BASE_TESTING_PROFILE_H_ 423
