Move ProfileKeyedAPI implementations to take BrowserContext in the constructor (part 1).

chrome/browser/extensions/api/activity_log_private/activity_log_private_api.cc

 // Copyright 2013 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/browser/extensions/api/activity_log_private/activity_log_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/event_router_forwarder.h"
 #include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/activity_log_private.h"
 #include "chrome/common/pref_names.h"
+#include "content/public/browser/browser_context.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/feature_provider.h"
 
 namespace extensions {
 
 namespace activity_log_private = api::activity_log_private;
 
 using api::activity_log_private::ActivityResultSet;
 using api::activity_log_private::ExtensionActivity;
 using api::activity_log_private::Filter;
 
 static base::LazyInstance<ProfileKeyedAPIFactory<ActivityLogAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 ProfileKeyedAPIFactory<ActivityLogAPI>* ActivityLogAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 template<>
 void ProfileKeyedAPIFactory<ActivityLogAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   DependsOn(ActivityLogFactory::GetInstance());
 }
 
-ActivityLogAPI::ActivityLogAPI(Profile* profile)
-    : profile_(profile),
-      initialized_(false) {
-  if (!ExtensionSystem::Get(profile_)->event_router()) {  // Check for testing.
+ActivityLogAPI::ActivityLogAPI(content::BrowserContext* context)
+    : browser_context_(context), initialized_(false) {
+  if (!ExtensionSystem::Get(browser_context_)
+           ->event_router()) {  // Check for testing.
     DVLOG(1) << "ExtensionSystem event_router does not exist.";
     return;
   }
-  activity_log_ = extensions::ActivityLog::GetInstance(profile_);
+  activity_log_ = extensions::ActivityLog::GetInstance(browser_context_);
   DCHECK(activity_log_);
-  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
       this, activity_log_private::OnExtensionActivity::kEventName);
   activity_log_->AddObserver(this);
   initialized_ = true;
 }
 
 ActivityLogAPI::~ActivityLogAPI() {
 }
 
 void ActivityLogAPI::Shutdown() {
   if (!initialized_) {  // Check for testing.
     DVLOG(1) << "ExtensionSystem event_router does not exist.";
     return;
   }
-  ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
+  ExtensionSystem::Get(browser_context_)->event_router()->UnregisterObserver(
+      this);
   activity_log_->RemoveObserver(this);
 }
 
 // static
 bool ActivityLogAPI::IsExtensionWhitelisted(const std::string& extension_id) {
   return FeatureProvider::GetPermissionFeatures()->
       GetFeature("activityLogPrivate")->IsIdInWhitelist(extension_id);
 }
 
 void ActivityLogAPI::OnListenerAdded(const EventListenerInfo& details) {
   // TODO(felt): Only observe activity_log_ events when we have a customer.
 }
 
 void ActivityLogAPI::OnListenerRemoved(const EventListenerInfo& details) {
   // TODO(felt): Only observe activity_log_ events when we have a customer.
 }
 
 void ActivityLogAPI::OnExtensionActivity(scoped_refptr<Action> activity) {
   scoped_ptr<base::ListValue> value(new base::ListValue());
   scoped_ptr<ExtensionActivity> activity_arg =
       activity->ConvertToExtensionActivity();
   value->Append(activity_arg->ToValue().release());
   scoped_ptr<Event> event(
       new Event(activity_log_private::OnExtensionActivity::kEventName,
           value.Pass()));
-  event->restrict_to_browser_context = profile_;
-  ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(event.Pass());
+  event->restrict_to_browser_context = browser_context_;
+  ExtensionSystem::Get(browser_context_)->event_router()->BroadcastEvent(
+      event.Pass());
 }
 
 bool ActivityLogPrivateGetExtensionActivitiesFunction::RunImpl() {
   scoped_ptr<activity_log_private::GetExtensionActivities::Params> params(
       activity_log_private::GetExtensionActivities::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Get the arguments in the right format.
   scoped_ptr<Filter> filter;
   filter.reset(&params.release()->filter);
@@ skipping 110 matching lines @@
     gurls.push_back(GURL(*it));
   }
 
   ActivityLog* activity_log = ActivityLog::GetInstance(GetProfile());
   DCHECK(activity_log);
   activity_log->RemoveURLs(gurls);
   return true;
 }
 
 }  // namespace extensions