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

chrome/browser/extensions/api/extension_action/extension_action_api.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/browser/extensions/api/extension_action/extension_action_api.h"
 
 #include "base/base64.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 201 matching lines @@
 
 }  // namespace
 
 //
 // ExtensionActionAPI
 //
 
 static base::LazyInstance<ProfileKeyedAPIFactory<ExtensionActionAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
-ExtensionActionAPI::ExtensionActionAPI(Profile* profile) {
+ExtensionActionAPI::ExtensionActionAPI(content::BrowserContext* context) {
   ExtensionFunctionRegistry* registry =
       ExtensionFunctionRegistry::GetInstance();
 
   // Browser Actions
   registry->RegisterFunction<BrowserActionSetIconFunction>();
   registry->RegisterFunction<BrowserActionSetTitleFunction>();
   registry->RegisterFunction<BrowserActionSetBadgeTextFunction>();
   registry->RegisterFunction<BrowserActionSetBadgeBackgroundColorFunction>();
   registry->RegisterFunction<BrowserActionSetPopupFunction>();
   registry->RegisterFunction<BrowserActionGetTitleFunction>();
@@ skipping 19 matching lines @@
 ExtensionActionAPI::~ExtensionActionAPI() {
 }
 
 // static
 ProfileKeyedAPIFactory<ExtensionActionAPI>*
 ExtensionActionAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
-ExtensionActionAPI* ExtensionActionAPI::Get(Profile* profile) {
-  return ProfileKeyedAPIFactory<ExtensionActionAPI>::GetForProfile(profile);
+ExtensionActionAPI* ExtensionActionAPI::Get(content::BrowserContext* context) {
+  return ProfileKeyedAPIFactory<ExtensionActionAPI>::GetForProfile(context);
 }
 
 // static
 bool ExtensionActionAPI::GetBrowserActionVisibility(
     const ExtensionPrefs* prefs,
     const std::string& extension_id) {
   bool visible = false;
   if (!prefs || !prefs->ReadPrefAsBoolean(extension_id,
                                           kBrowserActionVisible,
                                           &visible)) {
@@ skipping 14 matching lines @@
                              kBrowserActionVisible,
                              new base::FundamentalValue(visible));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
       content::Source<ExtensionPrefs>(prefs),
       content::Details<const std::string>(&extension_id));
 }
 
 // static
 void ExtensionActionAPI::BrowserActionExecuted(
-    Profile* profile,
+    content::BrowserContext* context,
     const ExtensionAction& browser_action,
     WebContents* web_contents) {
-  ExtensionActionExecuted(profile, browser_action, web_contents);
+  ExtensionActionExecuted(context, browser_action, web_contents);
 }
 
 // static
-void ExtensionActionAPI::PageActionExecuted(Profile* profile,
+void ExtensionActionAPI::PageActionExecuted(content::BrowserContext* context,
                                             const ExtensionAction& page_action,
                                             int tab_id,
                                             const std::string& url,
                                             int button) {
-  DispatchOldPageActionEvent(profile, page_action.extension_id(),
-                             page_action.id(), tab_id, url, button);
+  DispatchOldPageActionEvent(context,
+                             page_action.extension_id(),
+                             page_action.id(),
+                             tab_id,
+                             url,
+                             button);
   WebContents* web_contents = NULL;
   if (!extensions::ExtensionTabUtil::GetTabById(
-          tab_id, profile, profile->IsOffTheRecord(),
-          NULL, NULL, &web_contents, NULL)) {
+           tab_id,
+           Profile::FromBrowserContext(context),
+           context->IsOffTheRecord(),
+           NULL,
+           NULL,
+           &web_contents,
+           NULL)) {
     return;
   }
-  ExtensionActionExecuted(profile, page_action, web_contents);
+  ExtensionActionExecuted(context, page_action, web_contents);
 }
 
 // static
 void ExtensionActionAPI::DispatchEventToExtension(
-    Profile* profile,
+    content::BrowserContext* context,
     const std::string& extension_id,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args) {
-  if (!extensions::ExtensionSystem::Get(profile)->event_router())
+  if (!extensions::ExtensionSystem::Get(context)->event_router())
     return;
 
   scoped_ptr<Event> event(new Event(event_name, event_args.Pass()));
-  event->restrict_to_browser_context = profile;
+  event->restrict_to_browser_context = context;
   event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
-  ExtensionSystem::Get(profile)->event_router()->
-      DispatchEventToExtension(extension_id, event.Pass());
+  ExtensionSystem::Get(context)->event_router()->DispatchEventToExtension(
+      extension_id, event.Pass());
 }
 
 // static
 void ExtensionActionAPI::DispatchOldPageActionEvent(
-    Profile* profile,
+    content::BrowserContext* context,
     const std::string& extension_id,
     const std::string& page_action_id,
     int tab_id,
     const std::string& url,
     int button) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(new base::StringValue(page_action_id));
 
   base::DictionaryValue* data = new base::DictionaryValue();
   data->Set(page_actions_keys::kTabIdKey, new base::FundamentalValue(tab_id));
   data->Set(page_actions_keys::kTabUrlKey, new base::StringValue(url));
   data->Set(page_actions_keys::kButtonKey,
             new base::FundamentalValue(button));
   args->Append(data);
 
-  DispatchEventToExtension(profile, extension_id, "pageActions", args.Pass());
+  DispatchEventToExtension(context, extension_id, "pageActions", args.Pass());
 }
 
 // static
 void ExtensionActionAPI::ExtensionActionExecuted(
-    Profile* profile,
+    content::BrowserContext* context,
     const ExtensionAction& extension_action,
     WebContents* web_contents) {
   const char* event_name = NULL;
   switch (extension_action.action_type()) {
     case ActionInfo::TYPE_BROWSER:
       event_name = "browserAction.onClicked";
       break;
     case ActionInfo::TYPE_PAGE:
       event_name = "pageAction.onClicked";
       break;
     case ActionInfo::TYPE_SYSTEM_INDICATOR:
       // The System Indicator handles its own clicks.
       break;
   }
 
   if (event_name) {
     scoped_ptr<base::ListValue> args(new base::ListValue());
     base::DictionaryValue* tab_value =
         extensions::ExtensionTabUtil::CreateTabValue(web_contents);
     args->Append(tab_value);
 
-    DispatchEventToExtension(profile,
-                             extension_action.extension_id(),
-                             event_name,
-                             args.Pass());
+    DispatchEventToExtension(
+        context, extension_action.extension_id(), event_name, args.Pass());
   }
 }
 
 //
 // ExtensionActionStorageManager
 //
 
 ExtensionActionStorageManager::ExtensionActionStorageManager(Profile* profile)
     : profile_(profile) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
@@ skipping 540 matching lines @@
   return true;
 }
 
 bool EnablePageActionsFunction::RunImpl() {
   return SetPageActionEnabled(true);
 }
 
 bool DisablePageActionsFunction::RunImpl() {
   return SetPageActionEnabled(false);
 }