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