[components] Switch {RefCounted}ProfileKeyedService to use BrowserContext

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 123 matching lines @@
     return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
   }
 
  protected:
   virtual ~TestExtensionURLRequestContextGetter() {}
 
  private:
   scoped_ptr<net::URLRequestContext> context_;
 };
 
-ProfileKeyedService* CreateTestDesktopNotificationService(Profile* profile) {
+ProfileKeyedService* CreateTestDesktopNotificationService(
+    content::BrowserContext* profile) {
 #if defined(ENABLE_NOTIFICATIONS)
-  return new DesktopNotificationService(profile, NULL);
+  return new DesktopNotificationService(static_cast<Profile*>(profile), NULL);
 #else
   return NULL;
 #endif
 }
 
 }  // namespace
 
 // static
 #if defined(OS_CHROMEOS)
 // Must be kept in sync with
@@ skipping 151 matching lines @@
 
   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(Profile* profile) {
+static ProfileKeyedService* BuildFaviconService(
+    content::BrowserContext* profile) {
   return new FaviconService(
-      HistoryServiceFactory::GetForProfileWithoutCreating(profile));
+      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(Profile* profile) {
-  return new HistoryService(profile);
+static ProfileKeyedService* 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);
   }
   // This will create and init the history service.
@@ skipping 42 matching lines @@
     top_sites_->Shutdown();
     top_sites_ = NULL;
     // TopSites::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 (MessageLoop::current())
       MessageLoop::current()->RunUntilIdle();
   }
 }
 
-static ProfileKeyedService* BuildBookmarkModel(Profile* profile) {
+static ProfileKeyedService* 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(
-    Profile* profile) {
-  return new WebDataServiceWrapper(profile);
+    content::BrowserContext* profile) {
+  return new WebDataServiceWrapper(static_cast<Profile*>(profile));
 }
 
 void TestingProfile::CreateWebDataService() {
   WebDataServiceFactory::GetInstance()->SetTestingFactory(
       this, BuildWebDataService);
 }
 
 void TestingProfile::BlockUntilHistoryIndexIsRefreshed() {
   // Only get the history service if it actually exists since the caller of the
   // test should explicitly call CreateHistoryService to build it.
@@ skipping 347 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()));
 }