Remove references to Profile from browser_context_keyed_service.

chrome/test/base/testing_profile.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/test/base/testing_profile.h"
 
 #include "build/build_config.h"
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
@@ skipping 128 matching lines @@
     return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
   }
 
  protected:
   virtual ~TestExtensionURLRequestContextGetter() {}
 
  private:
   scoped_ptr<net::URLRequestContext> context_;
 };
 
-ProfileKeyedService* CreateTestDesktopNotificationService(
+BrowserContextKeyedService* CreateTestDesktopNotificationService(
     content::BrowserContext* profile) {
 #if defined(ENABLE_NOTIFICATIONS)
   return new DesktopNotificationService(static_cast<Profile*>(profile), NULL);
 #else
   return NULL;
 #endif
 }
 
 }  // namespace
 
 // static
 #if defined(OS_CHROMEOS)
 // Must be kept in sync with
 // ChromeBrowserMainPartsChromeos::PreEarlyInitialization.
 const char TestingProfile::kTestUserProfileDir[] = "test-user";
 #else
 const char TestingProfile::kTestUserProfileDir[] = "Default";
 #endif
 
 TestingProfile::TestingProfile()
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       incognito_(false),
       original_profile_(NULL),
       last_session_exited_cleanly_(true),
-      profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
+      profile_dependency_manager_(
+          BrowserContextDependencyManager::GetInstance()),
       delegate_(NULL) {
   CreateTempProfileDir();
   profile_path_ = temp_dir_.path();
 
   Init();
   FinishInit();
 }
 
 TestingProfile::TestingProfile(const base::FilePath& path)
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       incognito_(false),
       original_profile_(NULL),
       last_session_exited_cleanly_(true),
       profile_path_(path),
-      profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
+      profile_dependency_manager_(
+          BrowserContextDependencyManager::GetInstance()),
       delegate_(NULL) {
   Init();
   FinishInit();
 }
 
 TestingProfile::TestingProfile(const base::FilePath& path,
                                Delegate* delegate)
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       incognito_(false),
       original_profile_(NULL),
       last_session_exited_cleanly_(true),
       profile_path_(path),
-      profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
+      profile_dependency_manager_(
+          BrowserContextDependencyManager::GetInstance()),
       delegate_(delegate) {
   Init();
   if (delegate_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&TestingProfile::FinishInit, base::Unretained(this)));
   } else {
     FinishInit();
   }
 }
 
 TestingProfile::TestingProfile(
     const base::FilePath& path,
     Delegate* delegate,
     scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,
     scoped_ptr<PrefServiceSyncable> prefs)
     : start_time_(Time::Now()),
       prefs_(prefs.release()),
       testing_prefs_(NULL),
       incognito_(false),
       original_profile_(NULL),
       last_session_exited_cleanly_(true),
       extension_special_storage_policy_(extension_policy),
       profile_path_(path),
-      profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
+      profile_dependency_manager_(
+          BrowserContextDependencyManager::GetInstance()),
       delegate_(delegate) {
 
   // If no profile path was supplied, create one.
   if (profile_path_.empty()) {
     CreateTempProfileDir();
     profile_path_ = temp_dir_.path();
   }
 
   Init();
   // If caller supplied a delegate, delay the FinishInit invocation until other
@@ skipping 33 matching lines @@
       // We're screwed if this fails, see CHECK above.
       CHECK(temp_dir_.Set(system_tmp_dir));
     }
   }
 }
 
 void TestingProfile::Init() {
   // Normally this would happen during browser startup, but for tests
   // we need to trigger creation of Profile-related services.
   ChromeBrowserMainExtraPartsProfiles::
-      EnsureProfileKeyedServiceFactoriesBuilt();
+      EnsureBrowserContextKeyedServiceFactoriesBuilt();
 
   if (prefs_.get())
     components::UserPrefs::Set(this, prefs_.get());
   else
     CreateTestingPrefService();
 
   if (!file_util::PathExists(profile_path_))
     file_util::CreateDirectory(profile_path_);
 
   // TODO(joaodasilva): remove this once this PKS isn't created in ProfileImpl
   // anymore, after converting the PrefService to a PKS. Until then it must
   // be associated with a TestingProfile too.
   CreateProfilePolicyConnector();
 
   extensions::ExtensionSystemFactory::GetInstance()->SetTestingFactory(
       this, extensions::TestExtensionSystem::Build);
 
-  profile_dependency_manager_->CreateProfileServices(this, true);
+  profile_dependency_manager_->CreateBrowserContextServices(this, true);
 
 #if defined(ENABLE_NOTIFICATIONS)
   // Install profile keyed service factory hooks for dummy/test services
   DesktopNotificationServiceFactory::GetInstance()->SetTestingFactory(
       this, CreateTestDesktopNotificationService);
 #endif
 }
 
 void TestingProfile::FinishInit() {
   DCHECK(content::NotificationService::current());
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_CREATED,
       content::Source<Profile>(static_cast<Profile*>(this)),
       content::NotificationService::NoDetails());
 
   if (delegate_)
     delegate_->OnProfileCreated(this, true, false);
 }
 
 TestingProfile::~TestingProfile() {
   MaybeSendDestroyedNotification();
 
-  profile_dependency_manager_->DestroyProfileServices(this);
+  profile_dependency_manager_->DestroyBrowserContextServices(this);
 
   if (host_content_settings_map_)
     host_content_settings_map_->ShutdownOnUIThread();
 
   DestroyTopSites();
 
   if (pref_proxy_config_tracker_.get())
     pref_proxy_config_tracker_->DetachFromPrefService();
 }
 
-static ProfileKeyedService* BuildFaviconService(
+static BrowserContextKeyedService* BuildFaviconService(
     content::BrowserContext* profile) {
   return new FaviconService(
       HistoryServiceFactory::GetForProfileWithoutCreating(
           static_cast<Profile*>(profile)));
 }
 
 void TestingProfile::CreateFaviconService() {
   // It is up to the caller to create the history service if one is needed.
   FaviconServiceFactory::GetInstance()->SetTestingFactory(
       this, BuildFaviconService);
 }
 
-static ProfileKeyedService* BuildHistoryService(
+static BrowserContextKeyedService* BuildHistoryService(
     content::BrowserContext* profile) {
   return new HistoryService(static_cast<Profile*>(profile));
 }
 
 void TestingProfile::CreateHistoryService(bool delete_file, bool no_db) {
   DestroyHistoryService();
   if (delete_file) {
     base::FilePath path = GetPath();
     path = path.Append(chrome::kHistoryFilename);
     file_util::Delete(path, false);
@@ skipping 46 matching lines @@
     top_sites_->Shutdown();
     top_sites_ = NULL;
     // TopSitesImpl::Shutdown schedules some tasks (from TopSitesBackend) that
     // need to be run to properly shutdown. Run all pending tasks now. This is
     // normally handled by browser_process shutdown.
     if (base::MessageLoop::current())
       base::MessageLoop::current()->RunUntilIdle();
   }
 }
 
-static ProfileKeyedService* BuildBookmarkModel(
+static BrowserContextKeyedService* BuildBookmarkModel(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
   BookmarkModel* bookmark_model = new BookmarkModel(profile);
   bookmark_model->Load(profile->GetIOTaskRunner());
   return bookmark_model;
 }
 
 
 void TestingProfile::CreateBookmarkModel(bool delete_file) {
   if (delete_file) {
     base::FilePath path = GetPath().Append(chrome::kBookmarksFileName);
     file_util::Delete(path, false);
   }
   // This will create a bookmark model.
   BookmarkModel* bookmark_service = static_cast<BookmarkModel*>(
       BookmarkModelFactory::GetInstance()->SetTestingFactoryAndUse(
           this, BuildBookmarkModel));
 
   HistoryService* history_service =
       HistoryServiceFactory::GetForProfileWithoutCreating(this);
   if (history_service) {
     history_service->history_backend_->bookmark_service_ = bookmark_service;
     history_service->history_backend_->expirer_.bookmark_service_ =
         bookmark_service;
   }
 }
 
-static ProfileKeyedService* BuildWebDataService(
+static BrowserContextKeyedService* BuildWebDataService(
     content::BrowserContext* profile) {
   return new WebDataServiceWrapper(static_cast<Profile*>(profile));
 }
 
 void TestingProfile::CreateWebDataService() {
   WebDataServiceFactory::GetInstance()->SetTestingFactory(
       this, BuildWebDataService);
 }
 
 void TestingProfile::BlockUntilHistoryIndexIsRefreshed() {
@@ skipping 349 matching lines @@
 
 scoped_ptr<TestingProfile> TestingProfile::Builder::Build() {
   DCHECK(!build_called_);
   build_called_ = true;
   return scoped_ptr<TestingProfile>(new TestingProfile(
       path_,
       delegate_,
       extension_policy_,
       pref_service_.Pass()));
 }