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 #include "chrome/test/base/testing_profile.h"
6
7 #include "base/base_paths.h"
8 #include "base/command_line.h"
9 #include "base/files/file_util.h"
10 #include "base/message_loop/message_loop_proxy.h"
11 #include "base/path_service.h"
12 #include "base/prefs/testing_pref_store.h"
13 #include "base/run_loop.h"
14 #include "base/strings/string_number_conversions.h"
15 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
16 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
17 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
18 #include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
19 #include "chrome/browser/browser_process.h"
20 #include "chrome/browser/chrome_notification_types.h"
21 #include "chrome/browser/content_settings/host_content_settings_map.h"
22 #include "chrome/browser/extensions/extension_service.h"
23 #include "chrome/browser/favicon/chrome_favicon_client_factory.h"
24 #include "chrome/browser/favicon/favicon_service.h"
25 #include "chrome/browser/favicon/favicon_service_factory.h"
26 #include "chrome/browser/history/chrome_history_client.h"
27 #include "chrome/browser/history/chrome_history_client_factory.h"
28 #include "chrome/browser/history/history_backend.h"
29 #include "chrome/browser/history/history_db_task.h"
30 #include "chrome/browser/history/history_service.h"
31 #include "chrome/browser/history/history_service_factory.h"
32 #include "chrome/browser/history/top_sites.h"
33 #include "chrome/browser/history/web_history_service_factory.h"
34 #include "chrome/browser/net/pref_proxy_config_tracker.h"
35 #include "chrome/browser/net/proxy_service_factory.h"
36 #include "chrome/browser/notifications/desktop_notification_service.h"
37 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
38 #include "chrome/browser/policy/profile_policy_connector.h"
39 #include "chrome/browser/policy/profile_policy_connector_factory.h"
40 #include "chrome/browser/prefs/browser_prefs.h"
41 #include "chrome/browser/prefs/pref_service_syncable.h"
42 #include "chrome/browser/prerender/prerender_manager.h"
43 #include "chrome/browser/profiles/chrome_browser_main_extra_parts_profiles.h"
44 #include "chrome/browser/profiles/profile_manager.h"
45 #include "chrome/browser/profiles/storage_partition_descriptor.h"
46 #include "chrome/browser/search_engines/template_url_fetcher_factory.h"
47 #include "chrome/browser/webdata/web_data_service_factory.h"
48 #include "chrome/common/chrome_constants.h"
49 #include "chrome/common/chrome_switches.h"
50 #include "chrome/common/pref_names.h"
51 #include "chrome/common/url_constants.h"
52 #include "chrome/test/base/history_index_restore_observer.h"
53 #include "chrome/test/base/testing_pref_service_syncable.h"
54 #include "chrome/test/base/ui_test_utils.h"
55 #include "components/bookmarks/browser/bookmark_model.h"
56 #include "components/bookmarks/common/bookmark_constants.h"
57 #include "components/history/core/browser/top_sites_observer.h"
58 #include "components/keyed_service/content/browser_context_dependency_manager.h"
59 #include "components/policy/core/common/policy_service.h"
60 #include "components/user_prefs/user_prefs.h"
61 #include "content/public/browser/browser_thread.h"
62 #include "content/public/browser/cookie_store_factory.h"
63 #include "content/public/browser/notification_service.h"
64 #include "content/public/browser/render_process_host.h"
65 #include "content/public/browser/storage_partition.h"
66 #include "content/public/test/mock_resource_context.h"
67 #include "content/public/test/test_utils.h"
68 #include "extensions/common/constants.h"
69 #include "net/cookies/cookie_monster.h"
70 #include "net/url_request/url_request_context.h"
71 #include "net/url_request/url_request_context_getter.h"
72 #include "net/url_request/url_request_test_util.h"
73 #include "testing/gmock/include/gmock/gmock.h"
74
75 #if defined(ENABLE_CONFIGURATION_POLICY)
76 #include "chrome/browser/policy/schema_registry_service.h"
77 #include "chrome/browser/policy/schema_registry_service_factory.h"
78 #include "components/policy/core/common/configuration_policy_provider.h"
79 #include "components/policy/core/common/policy_service_impl.h"
80 #include "components/policy/core/common/schema.h"
81 #else
82 #include "components/policy/core/common/policy_service_stub.h"
83 #endif // defined(ENABLE_CONFIGURATION_POLICY)
84
85 #if defined(ENABLE_EXTENSIONS)
86 #include "chrome/browser/extensions/extension_special_storage_policy.h"
87 #include "chrome/browser/extensions/extension_system_factory.h"
88 #include "chrome/browser/extensions/test_extension_system.h"
89 #include "extensions/browser/extension_system.h"
90 #include "extensions/browser/guest_view/guest_view_manager.h"
91 #endif
92
93 #if defined(OS_ANDROID)
94 #include "chrome/browser/signin/android_profile_oauth2_token_service.h"
95 #endif
96
97 #if defined(ENABLE_MANAGED_USERS)
98 #include "chrome/browser/supervised_user/supervised_user_settings_service.h"
99 #include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
100 #endif
101
102 using base::Time;
103 using content::BrowserThread;
104 using content::DownloadManagerDelegate;
105 using testing::NiceMock;
106 using testing::Return;
107
108 namespace {
109
110 // Used to make sure TopSites has finished loading
111 class WaitTopSitesLoadedObserver : public history::TopSitesObserver {
112 public:
WaitTopSitesLoadedObserver(content::MessageLoopRunner * runner)113 explicit WaitTopSitesLoadedObserver(content::MessageLoopRunner* runner)
114 : runner_(runner) {}
TopSitesLoaded(history::TopSites * top_sites)115 virtual void TopSitesLoaded(history::TopSites* top_sites) OVERRIDE {
116 runner_->Quit();
117 }
TopSitesChanged(history::TopSites * top_sites)118 virtual void TopSitesChanged(history::TopSites* top_sites) OVERRIDE {}
119
120 private:
121 // weak
122 content::MessageLoopRunner* runner_;
123 };
124
125 // Task used to make sure history has finished processing a request. Intended
126 // for use with BlockUntilHistoryProcessesPendingRequests.
127
128 class QuittingHistoryDBTask : public history::HistoryDBTask {
129 public:
QuittingHistoryDBTask()130 QuittingHistoryDBTask() {}
131
RunOnDBThread(history::HistoryBackend * backend,history::HistoryDatabase * db)132 virtual bool RunOnDBThread(history::HistoryBackend* backend,
133 history::HistoryDatabase* db) OVERRIDE {
134 return true;
135 }
136
DoneRunOnMainThread()137 virtual void DoneRunOnMainThread() OVERRIDE {
138 base::MessageLoop::current()->Quit();
139 }
140
141 private:
~QuittingHistoryDBTask()142 virtual ~QuittingHistoryDBTask() {}
143
144 DISALLOW_COPY_AND_ASSIGN(QuittingHistoryDBTask);
145 };
146
147 class TestExtensionURLRequestContext : public net::URLRequestContext {
148 public:
TestExtensionURLRequestContext()149 TestExtensionURLRequestContext() {
150 net::CookieMonster* cookie_monster =
151 content::CreateCookieStore(content::CookieStoreConfig())->
152 GetCookieMonster();
153 const char* const schemes[] = {extensions::kExtensionScheme};
154 cookie_monster->SetCookieableSchemes(schemes, arraysize(schemes));
155 set_cookie_store(cookie_monster);
156 }
157
~TestExtensionURLRequestContext()158 virtual ~TestExtensionURLRequestContext() {
159 AssertNoURLRequests();
160 }
161 };
162
163 class TestExtensionURLRequestContextGetter
164 : public net::URLRequestContextGetter {
165 public:
GetURLRequestContext()166 virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE {
167 if (!context_.get())
168 context_.reset(new TestExtensionURLRequestContext());
169 return context_.get();
170 }
171 virtual scoped_refptr<base::SingleThreadTaskRunner>
GetNetworkTaskRunner() const172 GetNetworkTaskRunner() const OVERRIDE {
173 return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
174 }
175
176 protected:
~TestExtensionURLRequestContextGetter()177 virtual ~TestExtensionURLRequestContextGetter() {}
178
179 private:
180 scoped_ptr<net::URLRequestContext> context_;
181 };
182
183 #if defined(ENABLE_NOTIFICATIONS)
CreateTestDesktopNotificationService(content::BrowserContext * profile)184 KeyedService* CreateTestDesktopNotificationService(
185 content::BrowserContext* profile) {
186 return new DesktopNotificationService(static_cast<Profile*>(profile));
187 }
188 #endif
189
190 } // namespace
191
192 // static
193 #if defined(OS_CHROMEOS)
194 // Must be kept in sync with
195 // ChromeBrowserMainPartsChromeos::PreEarlyInitialization.
196 const char TestingProfile::kTestUserProfileDir[] = "test-user";
197 #else
198 const char TestingProfile::kTestUserProfileDir[] = "Default";
199 #endif
200
TestingProfile()201 TestingProfile::TestingProfile()
202 : start_time_(Time::Now()),
203 testing_prefs_(NULL),
204 force_incognito_(false),
205 original_profile_(NULL),
206 guest_session_(false),
207 last_session_exited_cleanly_(true),
208 browser_context_dependency_manager_(
209 BrowserContextDependencyManager::GetInstance()),
210 resource_context_(NULL),
211 delegate_(NULL) {
212 CreateTempProfileDir();
213 profile_path_ = temp_dir_.path();
214
215 Init();
216 FinishInit();
217 }
218
TestingProfile(const base::FilePath & path)219 TestingProfile::TestingProfile(const base::FilePath& path)
220 : start_time_(Time::Now()),
221 testing_prefs_(NULL),
222 force_incognito_(false),
223 original_profile_(NULL),
224 guest_session_(false),
225 last_session_exited_cleanly_(true),
226 profile_path_(path),
227 browser_context_dependency_manager_(
228 BrowserContextDependencyManager::GetInstance()),
229 resource_context_(NULL),
230 delegate_(NULL) {
231 Init();
232 FinishInit();
233 }
234
TestingProfile(const base::FilePath & path,Delegate * delegate)235 TestingProfile::TestingProfile(const base::FilePath& path,
236 Delegate* delegate)
237 : start_time_(Time::Now()),
238 testing_prefs_(NULL),
239 force_incognito_(false),
240 original_profile_(NULL),
241 guest_session_(false),
242 last_session_exited_cleanly_(true),
243 profile_path_(path),
244 browser_context_dependency_manager_(
245 BrowserContextDependencyManager::GetInstance()),
246 resource_context_(NULL),
247 delegate_(delegate) {
248 Init();
249 if (delegate_) {
250 base::MessageLoop::current()->PostTask(
251 FROM_HERE,
252 base::Bind(&TestingProfile::FinishInit, base::Unretained(this)));
253 } else {
254 FinishInit();
255 }
256 }
257
TestingProfile(const base::FilePath & path,Delegate * delegate,scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,scoped_ptr<PrefServiceSyncable> prefs,TestingProfile * parent,bool guest_session,const std::string & supervised_user_id,scoped_ptr<policy::PolicyService> policy_service,const TestingFactories & factories)258 TestingProfile::TestingProfile(
259 const base::FilePath& path,
260 Delegate* delegate,
261 #if defined(ENABLE_EXTENSIONS)
262 scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,
263 #endif
264 scoped_ptr<PrefServiceSyncable> prefs,
265 TestingProfile* parent,
266 bool guest_session,
267 const std::string& supervised_user_id,
268 scoped_ptr<policy::PolicyService> policy_service,
269 const TestingFactories& factories)
270 : start_time_(Time::Now()),
271 prefs_(prefs.release()),
272 testing_prefs_(NULL),
273 force_incognito_(false),
274 original_profile_(parent),
275 guest_session_(guest_session),
276 supervised_user_id_(supervised_user_id),
277 last_session_exited_cleanly_(true),
278 #if defined(ENABLE_EXTENSIONS)
279 extension_special_storage_policy_(extension_policy),
280 #endif
281 profile_path_(path),
282 browser_context_dependency_manager_(
283 BrowserContextDependencyManager::GetInstance()),
284 resource_context_(NULL),
285 delegate_(delegate),
286 policy_service_(policy_service.release()) {
287 if (parent)
288 parent->SetOffTheRecordProfile(scoped_ptr<Profile>(this));
289
290 // If no profile path was supplied, create one.
291 if (profile_path_.empty()) {
292 CreateTempProfileDir();
293 profile_path_ = temp_dir_.path();
294 }
295
296 // Set any testing factories prior to initializing the services.
297 for (TestingFactories::const_iterator it = factories.begin();
298 it != factories.end(); ++it) {
299 it->first->SetTestingFactory(this, it->second);
300 }
301
302 Init();
303 // If caller supplied a delegate, delay the FinishInit invocation until other
304 // tasks have run.
305 // TODO(atwilson): See if this is still required once we convert the current
306 // users of the constructor that takes a Delegate* param.
307 if (delegate_) {
308 base::MessageLoop::current()->PostTask(
309 FROM_HERE,
310 base::Bind(&TestingProfile::FinishInit, base::Unretained(this)));
311 } else {
312 FinishInit();
313 }
314 }
315
CreateTempProfileDir()316 void TestingProfile::CreateTempProfileDir() {
317 if (!temp_dir_.CreateUniqueTempDir()) {
318 LOG(ERROR) << "Failed to create unique temporary directory.";
319
320 // Fallback logic in case we fail to create unique temporary directory.
321 base::FilePath system_tmp_dir;
322 bool success = PathService::Get(base::DIR_TEMP, &system_tmp_dir);
323
324 // We're severly screwed if we can't get the system temporary
325 // directory. Die now to avoid writing to the filesystem root
326 // or other bad places.
327 CHECK(success);
328
329 base::FilePath fallback_dir(
330 system_tmp_dir.AppendASCII("TestingProfilePath"));
331 base::DeleteFile(fallback_dir, true);
332 base::CreateDirectory(fallback_dir);
333 if (!temp_dir_.Set(fallback_dir)) {
334 // That shouldn't happen, but if it does, try to recover.
335 LOG(ERROR) << "Failed to use a fallback temporary directory.";
336
337 // We're screwed if this fails, see CHECK above.
338 CHECK(temp_dir_.Set(system_tmp_dir));
339 }
340 }
341 }
342
Init()343 void TestingProfile::Init() {
344 // If threads have been initialized, we should be on the UI thread.
345 DCHECK(!content::BrowserThread::IsThreadInitialized(
346 content::BrowserThread::UI) ||
347 content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
348
349 #if defined(OS_ANDROID)
350 // Make sure token service knows its running in tests.
351 AndroidProfileOAuth2TokenService::set_is_testing_profile();
352 #endif
353
354 // Normally this would happen during browser startup, but for tests
355 // we need to trigger creation of Profile-related services.
356 ChromeBrowserMainExtraPartsProfiles::
357 EnsureBrowserContextKeyedServiceFactoriesBuilt();
358
359 if (prefs_.get())
360 user_prefs::UserPrefs::Set(this, prefs_.get());
361 else if (IsOffTheRecord())
362 CreateIncognitoPrefService();
363 else
364 CreateTestingPrefService();
365
366 if (!base::PathExists(profile_path_))
367 base::CreateDirectory(profile_path_);
368
369 // TODO(joaodasilva): remove this once this PKS isn't created in ProfileImpl
370 // anymore, after converting the PrefService to a PKS. Until then it must
371 // be associated with a TestingProfile too.
372 if (!IsOffTheRecord())
373 CreateProfilePolicyConnector();
374
375 #if defined(ENABLE_EXTENSIONS)
376 extensions::ExtensionSystemFactory::GetInstance()->SetTestingFactory(
377 this, extensions::TestExtensionSystem::Build);
378 #endif
379
380 // Prefs for incognito profiles are set in CreateIncognitoPrefService() by
381 // simulating ProfileImpl::GetOffTheRecordPrefs().
382 if (!IsOffTheRecord()) {
383 DCHECK(!original_profile_);
384 user_prefs::PrefRegistrySyncable* pref_registry =
385 static_cast<user_prefs::PrefRegistrySyncable*>(
386 prefs_->DeprecatedGetPrefRegistry());
387 browser_context_dependency_manager_->
388 RegisterProfilePrefsForServices(this, pref_registry);
389 }
390
391 browser_context_dependency_manager_->CreateBrowserContextServicesForTest(
392 this);
393
394 #if defined(ENABLE_NOTIFICATIONS)
395 // Install profile keyed service factory hooks for dummy/test services
396 DesktopNotificationServiceFactory::GetInstance()->SetTestingFactory(
397 this, CreateTestDesktopNotificationService);
398 #endif
399
400 #if defined(ENABLE_MANAGED_USERS)
401 if (!IsOffTheRecord()) {
402 SupervisedUserSettingsService* settings_service =
403 SupervisedUserSettingsServiceFactory::GetForProfile(this);
404 TestingPrefStore* store = new TestingPrefStore();
405 settings_service->Init(store);
406 store->SetInitializationCompleted();
407 }
408 #endif
409
410 profile_name_ = "testing_profile";
411 }
412
FinishInit()413 void TestingProfile::FinishInit() {
414 DCHECK(content::NotificationService::current());
415 content::NotificationService::current()->Notify(
416 chrome::NOTIFICATION_PROFILE_CREATED,
417 content::Source<Profile>(static_cast<Profile*>(this)),
418 content::NotificationService::NoDetails());
419
420 ProfileManager* profile_manager = g_browser_process->profile_manager();
421 if (profile_manager)
422 profile_manager->InitProfileUserPrefs(this);
423
424 if (delegate_)
425 delegate_->OnProfileCreated(this, true, false);
426 }
427
~TestingProfile()428 TestingProfile::~TestingProfile() {
429 // Revert to non-incognito mode before shutdown.
430 force_incognito_ = false;
431
432 // If this profile owns an incognito profile, tear it down first.
433 incognito_profile_.reset();
434
435 // Any objects holding live URLFetchers should be deleted before teardown.
436 TemplateURLFetcherFactory::ShutdownForProfile(this);
437
438 MaybeSendDestroyedNotification();
439
440 browser_context_dependency_manager_->DestroyBrowserContextServices(this);
441
442 if (host_content_settings_map_.get())
443 host_content_settings_map_->ShutdownOnUIThread();
444
445 DestroyTopSites();
446
447 if (pref_proxy_config_tracker_.get())
448 pref_proxy_config_tracker_->DetachFromPrefService();
449 // Failing a post == leaks == heapcheck failure. Make that an immediate test
450 // failure.
451 if (resource_context_) {
452 CHECK(BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE,
453 resource_context_));
454 resource_context_ = NULL;
455 content::RunAllPendingInMessageLoop(BrowserThread::IO);
456 }
457 }
458
BuildFaviconService(content::BrowserContext * profile)459 static KeyedService* BuildFaviconService(content::BrowserContext* profile) {
460 FaviconClient* favicon_client =
461 ChromeFaviconClientFactory::GetForProfile(static_cast<Profile*>(profile));
462 return new FaviconService(static_cast<Profile*>(profile), favicon_client);
463 }
464
CreateFaviconService()465 void TestingProfile::CreateFaviconService() {
466 // It is up to the caller to create the history service if one is needed.
467 FaviconServiceFactory::GetInstance()->SetTestingFactory(
468 this, BuildFaviconService);
469 }
470
BuildHistoryService(content::BrowserContext * context)471 static KeyedService* BuildHistoryService(content::BrowserContext* context) {
472 Profile* profile = static_cast<Profile*>(context);
473 return new HistoryService(ChromeHistoryClientFactory::GetForProfile(profile),
474 profile);
475 }
476
CreateHistoryService(bool delete_file,bool no_db)477 bool TestingProfile::CreateHistoryService(bool delete_file, bool no_db) {
478 DestroyHistoryService();
479 if (delete_file) {
480 base::FilePath path = GetPath();
481 path = path.Append(chrome::kHistoryFilename);
482 if (!base::DeleteFile(path, false) || base::PathExists(path))
483 return false;
484 }
485 // This will create and init the history service.
486 HistoryService* history_service = static_cast<HistoryService*>(
487 HistoryServiceFactory::GetInstance()->SetTestingFactoryAndUse(
488 this, BuildHistoryService));
489 if (!history_service->Init(this->GetPath(), no_db)) {
490 HistoryServiceFactory::GetInstance()->SetTestingFactoryAndUse(this, NULL);
491 }
492 // Disable WebHistoryService by default, since it makes network requests.
493 WebHistoryServiceFactory::GetInstance()->SetTestingFactory(this, NULL);
494 return true;
495 }
496
DestroyHistoryService()497 void TestingProfile::DestroyHistoryService() {
498 HistoryService* history_service =
499 HistoryServiceFactory::GetForProfileWithoutCreating(this);
500 if (!history_service)
501 return;
502
503 history_service->ClearCachedDataForContextID(0);
504 history_service->SetOnBackendDestroyTask(base::MessageLoop::QuitClosure());
505 history_service->Cleanup();
506 HistoryServiceFactory::ShutdownForProfile(this);
507
508 // Wait for the backend class to terminate before deleting the files and
509 // moving to the next test. Note: if this never terminates, somebody is
510 // probably leaking a reference to the history backend, so it never calls
511 // our destroy task.
512 base::MessageLoop::current()->Run();
513
514 // Make sure we don't have any event pending that could disrupt the next
515 // test.
516 base::MessageLoop::current()->PostTask(FROM_HERE,
517 base::MessageLoop::QuitClosure());
518 base::MessageLoop::current()->Run();
519 }
520
CreateTopSites()521 void TestingProfile::CreateTopSites() {
522 DestroyTopSites();
523 top_sites_ = history::TopSites::Create(
524 this, GetPath().Append(chrome::kTopSitesFilename));
525 }
526
DestroyTopSites()527 void TestingProfile::DestroyTopSites() {
528 if (top_sites_.get()) {
529 top_sites_->Shutdown();
530 top_sites_ = NULL;
531 // TopSitesImpl::Shutdown schedules some tasks (from TopSitesBackend) that
532 // need to be run to properly shutdown. Run all pending tasks now. This is
533 // normally handled by browser_process shutdown.
534 if (base::MessageLoop::current())
535 base::MessageLoop::current()->RunUntilIdle();
536 }
537 }
538
BuildBookmarkModel(content::BrowserContext * context)539 static KeyedService* BuildBookmarkModel(content::BrowserContext* context) {
540 Profile* profile = static_cast<Profile*>(context);
541 ChromeBookmarkClient* bookmark_client =
542 ChromeBookmarkClientFactory::GetForProfile(profile);
543 BookmarkModel* bookmark_model = new BookmarkModel(bookmark_client);
544 bookmark_client->Init(bookmark_model);
545 bookmark_model->Load(profile->GetPrefs(),
546 profile->GetPrefs()->GetString(prefs::kAcceptLanguages),
547 profile->GetPath(),
548 profile->GetIOTaskRunner(),
549 content::BrowserThread::GetMessageLoopProxyForThread(
550 content::BrowserThread::UI));
551 return bookmark_model;
552 }
553
BuildChromeBookmarkClient(content::BrowserContext * context)554 static KeyedService* BuildChromeBookmarkClient(
555 content::BrowserContext* context) {
556 return new ChromeBookmarkClient(static_cast<Profile*>(context));
557 }
558
BuildChromeHistoryClient(content::BrowserContext * context)559 static KeyedService* BuildChromeHistoryClient(
560 content::BrowserContext* context) {
561 Profile* profile = static_cast<Profile*>(context);
562 return new ChromeHistoryClient(BookmarkModelFactory::GetForProfile(profile),
563 profile,
564 profile->GetTopSites());
565 }
566
CreateBookmarkModel(bool delete_file)567 void TestingProfile::CreateBookmarkModel(bool delete_file) {
568 if (delete_file) {
569 base::FilePath path = GetPath().Append(bookmarks::kBookmarksFileName);
570 base::DeleteFile(path, false);
571 }
572 ChromeHistoryClientFactory::GetInstance()->SetTestingFactory(
573 this, BuildChromeHistoryClient);
574 ChromeBookmarkClientFactory::GetInstance()->SetTestingFactory(
575 this, BuildChromeBookmarkClient);
576 // This creates the BookmarkModel.
577 ignore_result(BookmarkModelFactory::GetInstance()->SetTestingFactoryAndUse(
578 this, BuildBookmarkModel));
579 }
580
BuildWebDataService(content::BrowserContext * profile)581 static KeyedService* BuildWebDataService(content::BrowserContext* profile) {
582 return new WebDataServiceWrapper(static_cast<Profile*>(profile));
583 }
584
CreateWebDataService()585 void TestingProfile::CreateWebDataService() {
586 WebDataServiceFactory::GetInstance()->SetTestingFactory(
587 this, BuildWebDataService);
588 }
589
BlockUntilHistoryIndexIsRefreshed()590 void TestingProfile::BlockUntilHistoryIndexIsRefreshed() {
591 // Only get the history service if it actually exists since the caller of the
592 // test should explicitly call CreateHistoryService to build it.
593 HistoryService* history_service =
594 HistoryServiceFactory::GetForProfileWithoutCreating(this);
595 DCHECK(history_service);
596 history::InMemoryURLIndex* index = history_service->InMemoryIndex();
597 if (!index || index->restored())
598 return;
599 base::RunLoop run_loop;
600 HistoryIndexRestoreObserver observer(
601 content::GetQuitTaskForRunLoop(&run_loop));
602 index->set_restore_cache_observer(&observer);
603 run_loop.Run();
604 index->set_restore_cache_observer(NULL);
605 DCHECK(index->restored());
606 }
607
608 // TODO(phajdan.jr): Doesn't this hang if Top Sites are already loaded?
BlockUntilTopSitesLoaded()609 void TestingProfile::BlockUntilTopSitesLoaded() {
610 scoped_refptr<content::MessageLoopRunner> runner =
611 new content::MessageLoopRunner;
612 WaitTopSitesLoadedObserver observer(runner.get());
613 top_sites_->AddObserver(&observer);
614 runner->Run();
615 top_sites_->RemoveObserver(&observer);
616 }
617
SetGuestSession(bool guest)618 void TestingProfile::SetGuestSession(bool guest) {
619 guest_session_ = guest;
620 }
621
GetPath() const622 base::FilePath TestingProfile::GetPath() const {
623 return profile_path_;
624 }
625
GetIOTaskRunner()626 scoped_refptr<base::SequencedTaskRunner> TestingProfile::GetIOTaskRunner() {
627 return base::MessageLoop::current()->message_loop_proxy();
628 }
629
GetTestingPrefService()630 TestingPrefServiceSyncable* TestingProfile::GetTestingPrefService() {
631 DCHECK(prefs_);
632 DCHECK(testing_prefs_);
633 return testing_prefs_;
634 }
635
AsTestingProfile()636 TestingProfile* TestingProfile::AsTestingProfile() {
637 return this;
638 }
639
GetProfileName()640 std::string TestingProfile::GetProfileName() {
641 return profile_name_;
642 }
643
GetProfileType() const644 Profile::ProfileType TestingProfile::GetProfileType() const {
645 if (guest_session_)
646 return GUEST_PROFILE;
647 if (force_incognito_ || original_profile_)
648 return INCOGNITO_PROFILE;
649 return REGULAR_PROFILE;
650 }
651
IsOffTheRecord() const652 bool TestingProfile::IsOffTheRecord() const {
653 return force_incognito_ || original_profile_;
654 }
655
SetOffTheRecordProfile(scoped_ptr<Profile> profile)656 void TestingProfile::SetOffTheRecordProfile(scoped_ptr<Profile> profile) {
657 DCHECK(!IsOffTheRecord());
658 DCHECK_EQ(this, profile->GetOriginalProfile());
659 incognito_profile_ = profile.Pass();
660 }
661
GetOffTheRecordProfile()662 Profile* TestingProfile::GetOffTheRecordProfile() {
663 if (IsOffTheRecord())
664 return this;
665 if (!incognito_profile_)
666 TestingProfile::Builder().BuildIncognito(this);
667 return incognito_profile_.get();
668 }
669
HasOffTheRecordProfile()670 bool TestingProfile::HasOffTheRecordProfile() {
671 return incognito_profile_.get() != NULL;
672 }
673
GetOriginalProfile()674 Profile* TestingProfile::GetOriginalProfile() {
675 if (original_profile_)
676 return original_profile_;
677 return this;
678 }
679
IsSupervised()680 bool TestingProfile::IsSupervised() {
681 return !supervised_user_id_.empty();
682 }
683
684 #if defined(ENABLE_EXTENSIONS)
SetExtensionSpecialStoragePolicy(ExtensionSpecialStoragePolicy * extension_special_storage_policy)685 void TestingProfile::SetExtensionSpecialStoragePolicy(
686 ExtensionSpecialStoragePolicy* extension_special_storage_policy) {
687 extension_special_storage_policy_ = extension_special_storage_policy;
688 }
689 #endif
690
691 ExtensionSpecialStoragePolicy*
GetExtensionSpecialStoragePolicy()692 TestingProfile::GetExtensionSpecialStoragePolicy() {
693 #if defined(ENABLE_EXTENSIONS)
694 if (!extension_special_storage_policy_.get())
695 extension_special_storage_policy_ = new ExtensionSpecialStoragePolicy(NULL);
696 return extension_special_storage_policy_.get();
697 #else
698 return NULL;
699 #endif
700 }
701
GetCookieMonster()702 net::CookieMonster* TestingProfile::GetCookieMonster() {
703 if (!GetRequestContext())
704 return NULL;
705 return GetRequestContext()->GetURLRequestContext()->cookie_store()->
706 GetCookieMonster();
707 }
708
CreateTestingPrefService()709 void TestingProfile::CreateTestingPrefService() {
710 DCHECK(!prefs_.get());
711 testing_prefs_ = new TestingPrefServiceSyncable();
712 prefs_.reset(testing_prefs_);
713 user_prefs::UserPrefs::Set(this, prefs_.get());
714 chrome::RegisterUserProfilePrefs(testing_prefs_->registry());
715 }
716
CreateIncognitoPrefService()717 void TestingProfile::CreateIncognitoPrefService() {
718 DCHECK(original_profile_);
719 DCHECK(!testing_prefs_);
720 // Simplified version of ProfileImpl::GetOffTheRecordPrefs(). Note this
721 // leaves testing_prefs_ unset.
722 prefs_.reset(original_profile_->prefs_->CreateIncognitoPrefService(NULL));
723 user_prefs::UserPrefs::Set(this, prefs_.get());
724 }
725
CreateProfilePolicyConnector()726 void TestingProfile::CreateProfilePolicyConnector() {
727 #if defined(ENABLE_CONFIGURATION_POLICY)
728 schema_registry_service_ =
729 policy::SchemaRegistryServiceFactory::CreateForContext(
730 this, policy::Schema(), NULL);
731 CHECK_EQ(schema_registry_service_.get(),
732 policy::SchemaRegistryServiceFactory::GetForContext(this));
733 #endif // defined(ENABLE_CONFIGURATION_POLICY)
734
735 if (!policy_service_) {
736 #if defined(ENABLE_CONFIGURATION_POLICY)
737 std::vector<policy::ConfigurationPolicyProvider*> providers;
738 policy_service_.reset(new policy::PolicyServiceImpl(providers));
739 #else
740 policy_service_.reset(new policy::PolicyServiceStub());
741 #endif
742 }
743 profile_policy_connector_.reset(new policy::ProfilePolicyConnector());
744 profile_policy_connector_->InitForTesting(policy_service_.Pass());
745 policy::ProfilePolicyConnectorFactory::GetInstance()->SetServiceForTesting(
746 this, profile_policy_connector_.get());
747 CHECK_EQ(profile_policy_connector_.get(),
748 policy::ProfilePolicyConnectorFactory::GetForProfile(this));
749 }
750
GetPrefs()751 PrefService* TestingProfile::GetPrefs() {
752 DCHECK(prefs_);
753 return prefs_.get();
754 }
755
GetTopSites()756 history::TopSites* TestingProfile::GetTopSites() {
757 return top_sites_.get();
758 }
759
GetTopSitesWithoutCreating()760 history::TopSites* TestingProfile::GetTopSitesWithoutCreating() {
761 return top_sites_.get();
762 }
763
GetDownloadManagerDelegate()764 DownloadManagerDelegate* TestingProfile::GetDownloadManagerDelegate() {
765 return NULL;
766 }
767
GetRequestContext()768 net::URLRequestContextGetter* TestingProfile::GetRequestContext() {
769 return GetDefaultStoragePartition(this)->GetURLRequestContext();
770 }
771
CreateRequestContext(content::ProtocolHandlerMap * protocol_handlers,content::URLRequestInterceptorScopedVector request_interceptors)772 net::URLRequestContextGetter* TestingProfile::CreateRequestContext(
773 content::ProtocolHandlerMap* protocol_handlers,
774 content::URLRequestInterceptorScopedVector request_interceptors) {
775 return new net::TestURLRequestContextGetter(
776 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
777 }
778
GetRequestContextForRenderProcess(int renderer_child_id)779 net::URLRequestContextGetter* TestingProfile::GetRequestContextForRenderProcess(
780 int renderer_child_id) {
781 content::RenderProcessHost* rph = content::RenderProcessHost::FromID(
782 renderer_child_id);
783 return rph->GetStoragePartition()->GetURLRequestContext();
784 }
785
GetMediaRequestContext()786 net::URLRequestContextGetter* TestingProfile::GetMediaRequestContext() {
787 return NULL;
788 }
789
790 net::URLRequestContextGetter*
GetMediaRequestContextForRenderProcess(int renderer_child_id)791 TestingProfile::GetMediaRequestContextForRenderProcess(
792 int renderer_child_id) {
793 return NULL;
794 }
795
796 net::URLRequestContextGetter*
GetMediaRequestContextForStoragePartition(const base::FilePath & partition_path,bool in_memory)797 TestingProfile::GetMediaRequestContextForStoragePartition(
798 const base::FilePath& partition_path,
799 bool in_memory) {
800 return NULL;
801 }
802
GetRequestContextForExtensions()803 net::URLRequestContextGetter* TestingProfile::GetRequestContextForExtensions() {
804 if (!extensions_request_context_.get())
805 extensions_request_context_ = new TestExtensionURLRequestContextGetter();
806 return extensions_request_context_.get();
807 }
808
GetSSLConfigService()809 net::SSLConfigService* TestingProfile::GetSSLConfigService() {
810 if (!GetRequestContext())
811 return NULL;
812 return GetRequestContext()->GetURLRequestContext()->ssl_config_service();
813 }
814
815 net::URLRequestContextGetter*
CreateRequestContextForStoragePartition(const base::FilePath & partition_path,bool in_memory,content::ProtocolHandlerMap * protocol_handlers,content::URLRequestInterceptorScopedVector request_interceptors)816 TestingProfile::CreateRequestContextForStoragePartition(
817 const base::FilePath& partition_path,
818 bool in_memory,
819 content::ProtocolHandlerMap* protocol_handlers,
820 content::URLRequestInterceptorScopedVector request_interceptors) {
821 // We don't test storage partitions here yet, so returning the same dummy
822 // context is sufficient for now.
823 return GetRequestContext();
824 }
825
GetResourceContext()826 content::ResourceContext* TestingProfile::GetResourceContext() {
827 if (!resource_context_)
828 resource_context_ = new content::MockResourceContext();
829 return resource_context_;
830 }
831
GetHostContentSettingsMap()832 HostContentSettingsMap* TestingProfile::GetHostContentSettingsMap() {
833 if (!host_content_settings_map_.get()) {
834 host_content_settings_map_ = new HostContentSettingsMap(GetPrefs(), false);
835 #if defined(ENABLE_EXTENSIONS)
836 ExtensionService* extension_service =
837 extensions::ExtensionSystem::Get(this)->extension_service();
838 if (extension_service) {
839 extension_service->RegisterContentSettings(
840 host_content_settings_map_.get());
841 }
842 #endif
843 }
844 return host_content_settings_map_.get();
845 }
846
GetGuestManager()847 content::BrowserPluginGuestManager* TestingProfile::GetGuestManager() {
848 #if defined(ENABLE_EXTENSIONS)
849 return extensions::GuestViewManager::FromBrowserContext(this);
850 #else
851 return NULL;
852 #endif
853 }
854
GetPushMessagingService()855 content::PushMessagingService* TestingProfile::GetPushMessagingService() {
856 return NULL;
857 }
858
IsSameProfile(Profile * p)859 bool TestingProfile::IsSameProfile(Profile *p) {
860 return this == p;
861 }
862
GetStartTime() const863 base::Time TestingProfile::GetStartTime() const {
864 return start_time_;
865 }
866
last_selected_directory()867 base::FilePath TestingProfile::last_selected_directory() {
868 return last_selected_directory_;
869 }
870
set_last_selected_directory(const base::FilePath & path)871 void TestingProfile::set_last_selected_directory(const base::FilePath& path) {
872 last_selected_directory_ = path;
873 }
874
GetProxyConfigTracker()875 PrefProxyConfigTracker* TestingProfile::GetProxyConfigTracker() {
876 if (!pref_proxy_config_tracker_.get()) {
877 // TestingProfile is used in unit tests, where local state is not available.
878 pref_proxy_config_tracker_.reset(
879 ProxyServiceFactory::CreatePrefProxyConfigTrackerOfProfile(GetPrefs(),
880 NULL));
881 }
882 return pref_proxy_config_tracker_.get();
883 }
884
BlockUntilHistoryProcessesPendingRequests()885 void TestingProfile::BlockUntilHistoryProcessesPendingRequests() {
886 HistoryService* history_service =
887 HistoryServiceFactory::GetForProfile(this, Profile::EXPLICIT_ACCESS);
888 DCHECK(history_service);
889 DCHECK(base::MessageLoop::current());
890
891 base::CancelableTaskTracker tracker;
892 history_service->ScheduleDBTask(
893 scoped_ptr<history::HistoryDBTask>(
894 new QuittingHistoryDBTask()),
895 &tracker);
896 base::MessageLoop::current()->Run();
897 }
898
GetNetworkPredictor()899 chrome_browser_net::Predictor* TestingProfile::GetNetworkPredictor() {
900 return NULL;
901 }
902
GetDevToolsNetworkController()903 DevToolsNetworkController* TestingProfile::GetDevToolsNetworkController() {
904 return NULL;
905 }
906
ClearNetworkingHistorySince(base::Time time,const base::Closure & completion)907 void TestingProfile::ClearNetworkingHistorySince(
908 base::Time time,
909 const base::Closure& completion) {
910 if (!completion.is_null()) {
911 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, completion);
912 }
913 }
914
GetHomePage()915 GURL TestingProfile::GetHomePage() {
916 return GURL(chrome::kChromeUINewTabURL);
917 }
918
GetOffTheRecordPrefs()919 PrefService* TestingProfile::GetOffTheRecordPrefs() {
920 return NULL;
921 }
922
GetSpecialStoragePolicy()923 storage::SpecialStoragePolicy* TestingProfile::GetSpecialStoragePolicy() {
924 #if defined(ENABLE_EXTENSIONS)
925 return GetExtensionSpecialStoragePolicy();
926 #else
927 return NULL;
928 #endif
929 }
930
GetSSLHostStateDelegate()931 content::SSLHostStateDelegate* TestingProfile::GetSSLHostStateDelegate() {
932 return NULL;
933 }
934
WasCreatedByVersionOrLater(const std::string & version)935 bool TestingProfile::WasCreatedByVersionOrLater(const std::string& version) {
936 return true;
937 }
938
IsGuestSession() const939 bool TestingProfile::IsGuestSession() const {
940 return guest_session_;
941 }
942
GetLastSessionExitType()943 Profile::ExitType TestingProfile::GetLastSessionExitType() {
944 return last_session_exited_cleanly_ ? EXIT_NORMAL : EXIT_CRASHED;
945 }
946
Builder()947 TestingProfile::Builder::Builder()
948 : build_called_(false),
949 delegate_(NULL),
950 guest_session_(false) {
951 }
952
~Builder()953 TestingProfile::Builder::~Builder() {
954 }
955
SetPath(const base::FilePath & path)956 void TestingProfile::Builder::SetPath(const base::FilePath& path) {
957 path_ = path;
958 }
959
SetDelegate(Delegate * delegate)960 void TestingProfile::Builder::SetDelegate(Delegate* delegate) {
961 delegate_ = delegate;
962 }
963
964 #if defined(ENABLE_EXTENSIONS)
SetExtensionSpecialStoragePolicy(scoped_refptr<ExtensionSpecialStoragePolicy> policy)965 void TestingProfile::Builder::SetExtensionSpecialStoragePolicy(
966 scoped_refptr<ExtensionSpecialStoragePolicy> policy) {
967 extension_policy_ = policy;
968 }
969 #endif
970
SetPrefService(scoped_ptr<PrefServiceSyncable> prefs)971 void TestingProfile::Builder::SetPrefService(
972 scoped_ptr<PrefServiceSyncable> prefs) {
973 pref_service_ = prefs.Pass();
974 }
975
SetGuestSession()976 void TestingProfile::Builder::SetGuestSession() {
977 guest_session_ = true;
978 }
979
SetSupervisedUserId(const std::string & supervised_user_id)980 void TestingProfile::Builder::SetSupervisedUserId(
981 const std::string& supervised_user_id) {
982 supervised_user_id_ = supervised_user_id;
983 }
984
SetPolicyService(scoped_ptr<policy::PolicyService> policy_service)985 void TestingProfile::Builder::SetPolicyService(
986 scoped_ptr<policy::PolicyService> policy_service) {
987 policy_service_ = policy_service.Pass();
988 }
989
AddTestingFactory(BrowserContextKeyedServiceFactory * service_factory,BrowserContextKeyedServiceFactory::TestingFactoryFunction callback)990 void TestingProfile::Builder::AddTestingFactory(
991 BrowserContextKeyedServiceFactory* service_factory,
992 BrowserContextKeyedServiceFactory::TestingFactoryFunction callback) {
993 testing_factories_.push_back(std::make_pair(service_factory, callback));
994 }
995
Build()996 scoped_ptr<TestingProfile> TestingProfile::Builder::Build() {
997 DCHECK(!build_called_);
998 build_called_ = true;
999
1000 return scoped_ptr<TestingProfile>(new TestingProfile(path_,
1001 delegate_,
1002 #if defined(ENABLE_EXTENSIONS)
1003 extension_policy_,
1004 #endif
1005 pref_service_.Pass(),
1006 NULL,
1007 guest_session_,
1008 supervised_user_id_,
1009 policy_service_.Pass(),
1010 testing_factories_));
1011 }
1012
BuildIncognito(TestingProfile * original_profile)1013 TestingProfile* TestingProfile::Builder::BuildIncognito(
1014 TestingProfile* original_profile) {
1015 DCHECK(!build_called_);
1016 DCHECK(original_profile);
1017 build_called_ = true;
1018
1019 // Note: Owned by |original_profile|.
1020 return new TestingProfile(path_,
1021 delegate_,
1022 #if defined(ENABLE_EXTENSIONS)
1023 extension_policy_,
1024 #endif
1025 pref_service_.Pass(),
1026 original_profile,
1027 guest_session_,
1028 supervised_user_id_,
1029 policy_service_.Pass(),
1030 testing_factories_);
1031 }
1032