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