chrome/test/base/testing_profile.cc

   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:
 113   explicit WaitTopSitesLoadedObserver(content::MessageLoopRunner* runner)
 114       : runner_(runner) {}
 115   virtual void TopSitesLoaded(history::TopSites* top_sites) OVERRIDE {
 116     runner_->Quit();
 117   }
 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:
 130   QuittingHistoryDBTask() {}
 131
 132   virtual bool RunOnDBThread(history::HistoryBackend* backend,
 133                              history::HistoryDatabase* db) OVERRIDE {
 134     return true;
 135   }
 136
 137   virtual void DoneRunOnMainThread() OVERRIDE {
 138     base::MessageLoop::current()->Quit();
 139   }
 140
 141  private:
 142   virtual ~QuittingHistoryDBTask() {}
 143
 144   DISALLOW_COPY_AND_ASSIGN(QuittingHistoryDBTask);
 145 };
 146
 147 class TestExtensionURLRequestContext : public net::URLRequestContext {
 148  public:
 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
 158   virtual ~TestExtensionURLRequestContext() {
 159     AssertNoURLRequests();
 160   }
 161 };
 162
 163 class TestExtensionURLRequestContextGetter
 164     : public net::URLRequestContextGetter {
 165  public:
 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>
 172       GetNetworkTaskRunner() const OVERRIDE {
 173     return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
 174   }
 175
 176  protected:
 177   virtual ~TestExtensionURLRequestContextGetter() {}
 178
 179  private:
 180   scoped_ptr<net::URLRequestContext> context_;
 181 };
 182
 183 #if defined(ENABLE_NOTIFICATIONS)
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 521 void TestingProfile::CreateTopSites() {
 522   DestroyTopSites();
 523   top_sites_ = history::TopSites::Create(
 524       this, GetPath().Append(chrome::kTopSitesFilename));
 525 }
 526
 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
 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
 554 static KeyedService* BuildChromeBookmarkClient(
 555     content::BrowserContext* context) {
 556   return new ChromeBookmarkClient(static_cast<Profile*>(context));
 557 }
 558
 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
 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
 581 static KeyedService* BuildWebDataService(content::BrowserContext* profile) {
 582   return new WebDataServiceWrapper(static_cast<Profile*>(profile));
 583 }
 584
 585 void TestingProfile::CreateWebDataService() {
 586   WebDataServiceFactory::GetInstance()->SetTestingFactory(
 587       this, BuildWebDataService);
 588 }
 589
 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?
 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
 618 void TestingProfile::SetGuestSession(bool guest) {
 619   guest_session_ = guest;
 620 }
 621
 622 base::FilePath TestingProfile::GetPath() const {
 623   return profile_path_;
 624 }
 625
 626 scoped_refptr<base::SequencedTaskRunner> TestingProfile::GetIOTaskRunner() {
 627   return base::MessageLoop::current()->message_loop_proxy();
 628 }
 629
 630 TestingPrefServiceSyncable* TestingProfile::GetTestingPrefService() {
 631   DCHECK(prefs_);
 632   DCHECK(testing_prefs_);
 633   return testing_prefs_;
 634 }
 635
 636 TestingProfile* TestingProfile::AsTestingProfile() {
 637   return this;
 638 }
 639
 640 std::string TestingProfile::GetProfileName() {
 641   return profile_name_;
 642 }
 643
 644 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
 652 bool TestingProfile::IsOffTheRecord() const {
 653   return force_incognito_ || original_profile_;
 654 }
 655
 656 void TestingProfile::SetOffTheRecordProfile(scoped_ptr<Profile> profile) {
 657   DCHECK(!IsOffTheRecord());
 658   DCHECK_EQ(this, profile->GetOriginalProfile());
 659   incognito_profile_ = profile.Pass();
 660 }
 661
 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
 670 bool TestingProfile::HasOffTheRecordProfile() {
 671   return incognito_profile_.get() != NULL;
 672 }
 673
 674 Profile* TestingProfile::GetOriginalProfile() {
 675   if (original_profile_)
 676     return original_profile_;
 677   return this;
 678 }
 679
 680 bool TestingProfile::IsSupervised() {
 681   return !supervised_user_id_.empty();
 682 }
 683
 684 #if defined(ENABLE_EXTENSIONS)
 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*
 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
 702 net::CookieMonster* TestingProfile::GetCookieMonster() {
 703   if (!GetRequestContext())
 704     return NULL;
 705   return GetRequestContext()->GetURLRequestContext()->cookie_store()->
 706       GetCookieMonster();
 707 }
 708
 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
 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
 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
 751 PrefService* TestingProfile::GetPrefs() {
 752   DCHECK(prefs_);
 753   return prefs_.get();
 754 }
 755
 756 history::TopSites* TestingProfile::GetTopSites() {
 757   return top_sites_.get();
 758 }
 759
 760 history::TopSites* TestingProfile::GetTopSitesWithoutCreating() {
 761   return top_sites_.get();
 762 }
 763
 764 DownloadManagerDelegate* TestingProfile::GetDownloadManagerDelegate() {
 765   return NULL;
 766 }
 767
 768 net::URLRequestContextGetter* TestingProfile::GetRequestContext() {
 769   return GetDefaultStoragePartition(this)->GetURLRequestContext();
 770 }
 771
 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
 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
 786 net::URLRequestContextGetter* TestingProfile::GetMediaRequestContext() {
 787   return NULL;
 788 }
 789
 790 net::URLRequestContextGetter*
 791 TestingProfile::GetMediaRequestContextForRenderProcess(
 792     int renderer_child_id) {
 793   return NULL;
 794 }
 795
 796 net::URLRequestContextGetter*
 797 TestingProfile::GetMediaRequestContextForStoragePartition(
 798     const base::FilePath& partition_path,
 799     bool in_memory) {
 800   return NULL;
 801 }
 802
 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
 809 net::SSLConfigService* TestingProfile::GetSSLConfigService() {
 810   if (!GetRequestContext())
 811     return NULL;
 812   return GetRequestContext()->GetURLRequestContext()->ssl_config_service();
 813 }
 814
 815 net::URLRequestContextGetter*
 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
 826 content::ResourceContext* TestingProfile::GetResourceContext() {
 827   if (!resource_context_)
 828     resource_context_ = new content::MockResourceContext();
 829   return resource_context_;
 830 }
 831
 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
 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
 855 content::PushMessagingService* TestingProfile::GetPushMessagingService() {
 856   return NULL;
 857 }
 858
 859 bool TestingProfile::IsSameProfile(Profile *p) {
 860   return this == p;
 861 }
 862
 863 base::Time TestingProfile::GetStartTime() const {
 864   return start_time_;
 865 }
 866
 867 base::FilePath TestingProfile::last_selected_directory() {
 868   return last_selected_directory_;
 869 }
 870
 871 void TestingProfile::set_last_selected_directory(const base::FilePath& path) {
 872   last_selected_directory_ = path;
 873 }
 874
 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
 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
 899 chrome_browser_net::Predictor* TestingProfile::GetNetworkPredictor() {
 900   return NULL;
 901 }
 902
 903 DevToolsNetworkController* TestingProfile::GetDevToolsNetworkController() {
 904   return NULL;
 905 }
 906
 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
 915 GURL TestingProfile::GetHomePage() {
 916   return GURL(chrome::kChromeUINewTabURL);
 917 }
 918
 919 PrefService* TestingProfile::GetOffTheRecordPrefs() {
 920   return NULL;
 921 }
 922
 923 storage::SpecialStoragePolicy* TestingProfile::GetSpecialStoragePolicy() {
 924 #if defined(ENABLE_EXTENSIONS)
 925   return GetExtensionSpecialStoragePolicy();
 926 #else
 927   return NULL;
 928 #endif
 929 }
 930
 931 content::SSLHostStateDelegate* TestingProfile::GetSSLHostStateDelegate() {
 932   return NULL;
 933 }
 934
 935 bool TestingProfile::WasCreatedByVersionOrLater(const std::string& version) {
 936   return true;
 937 }
 938
 939 bool TestingProfile::IsGuestSession() const {
 940   return guest_session_;
 941 }
 942
 943 Profile::ExitType TestingProfile::GetLastSessionExitType() {
 944   return last_session_exited_cleanly_ ? EXIT_NORMAL : EXIT_CRASHED;
 945 }
 946
 947 TestingProfile::Builder::Builder()
 948     : build_called_(false),
 949       delegate_(NULL),
 950       guest_session_(false) {
 951 }
 952
 953 TestingProfile::Builder::~Builder() {
 954 }
 955
 956 void TestingProfile::Builder::SetPath(const base::FilePath& path) {
 957   path_ = path;
 958 }
 959
 960 void TestingProfile::Builder::SetDelegate(Delegate* delegate) {
 961   delegate_ = delegate;
 962 }
 963
 964 #if defined(ENABLE_EXTENSIONS)
 965 void TestingProfile::Builder::SetExtensionSpecialStoragePolicy(
 966     scoped_refptr<ExtensionSpecialStoragePolicy> policy) {
 967   extension_policy_ = policy;
 968 }
 969 #endif
 970
 971 void TestingProfile::Builder::SetPrefService(
 972     scoped_ptr<PrefServiceSyncable> prefs) {
 973   pref_service_ = prefs.Pass();
 974 }
 975
 976 void TestingProfile::Builder::SetGuestSession() {
 977   guest_session_ = true;
 978 }
 979
 980 void TestingProfile::Builder::SetSupervisedUserId(
 981     const std::string& supervised_user_id) {
 982   supervised_user_id_ = supervised_user_id;
 983 }
 984
 985 void TestingProfile::Builder::SetPolicyService(
 986     scoped_ptr<policy::PolicyService> policy_service) {
 987   policy_service_ = policy_service.Pass();
 988 }
 989
 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
 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
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 }