Consolidate [BrowserAction,PageAction,ScriptBadge]API into ExtensionActionAPI

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_actions_api.h"
+#include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/extension_action/extension_page_actions_api_constants.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/location_bar_controller.h"
 #include "chrome/browser/extensions/state_store.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
+#include "chrome/common/extensions/api/extension_action/script_badge_handler.h"
+#include "chrome/common/extensions/extension_manifest_constants.h"
+#include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/common/error_utils.h"
 
 namespace {
 
 const char kBrowserActionStorageKey[] = "browser_action";
 const char kPopupUrlStorageKey[] = "poupup_url";
 const char kTitleStorageKey[] = "title";
 const char kIconStorageKey[] = "icon";
 const char kBadgeTextStorageKey[] = "badge_text";
 const char kBadgeBackgroundColorStorageKey[] = "badge_background_color";
 const char kBadgeTextColorStorageKey[] = "badge_text_color";
 const char kAppearanceStorageKey[] = "appearance";
 
 // Errors.
 const char kNoExtensionActionError[] =
     "This extension has no action specified.";
 const char kNoTabError[] = "No tab with id: *.";
+const char kNoPageActionError[] =
+    "This extension has no page action specified.";
+const char kUrlNotActiveError[] = "This url is no longer active: *.";
+
 
 struct IconRepresentationInfo {
   // Size as a string that will be used to retrieve representation value from
   // SetIcon function arguments.
   const char* size_string;
   // Scale factor for which the represantion should be used.
   ui::ScaleFactor scale;
 };
 
 
@@ skipping 110 matching lines @@
     dict->Set(kIconStorageKey, icon_value);
   }
   return dict.Pass();
 }
 
 }  // namespace
 
 namespace extensions {
 
 //
+// ExtensionActionAPI
+//
+
+ExtensionActionAPI::ExtensionActionAPI(Profile* profile) {
+  ManifestHandler::Register(extension_manifest_keys::kScriptBadge,
+                            new ScriptBadgeHandler);
+}
+
+ExtensionActionAPI::~ExtensionActionAPI() {
+}
+
+void ExtensionActionAPI::Shutdown() {
+}
+
+//
 // ExtensionActionStorageManager
 //
 
 ExtensionActionStorageManager::ExtensionActionStorageManager(Profile* profile)
     : profile_(profile) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
   StateStore* storage = ExtensionSystem::Get(profile_)->state_store();
   if (storage)
     storage->RegisterKey(kBrowserActionStorageKey);
 }
 
 ExtensionActionStorageManager::~ExtensionActionStorageManager() {
 }
 
 void ExtensionActionStorageManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
-      if (!extensions::ExtensionActionManager::Get(profile_)->
+      if (!ExtensionActionManager::Get(profile_)->
           GetBrowserAction(*extension)) {
         break;
       }
 
       StateStore* storage = ExtensionSystem::Get(profile_)->state_store();
       if (storage) {
         storage->GetExtensionValue(extension->id(), kBrowserActionStorageKey,
             base::Bind(&ExtensionActionStorageManager::ReadFromStorage,
                        AsWeakPtr(), extension->id()));
       }
@@ skipping 48 matching lines @@
   if (browser_action->has_changed())
     return;
 
   const base::DictionaryValue* dict = NULL;
   if (!value.get() || !value->GetAsDictionary(&dict))
     return;
 
   SetDefaultsFromValue(dict, browser_action);
 }
 
-}  // namespace extensions
-
-
 //
 // ExtensionActionFunction
 //
 
 ExtensionActionFunction::ExtensionActionFunction()
     : details_(NULL),
       tab_id_(ExtensionAction::kDefaultTabId),
       contents_(NULL),
       extension_action_(NULL) {
 }
 
 ExtensionActionFunction::~ExtensionActionFunction() {
 }
 
 bool ExtensionActionFunction::RunImpl() {
-  extensions::ExtensionActionManager* manager =
-      extensions::ExtensionActionManager::Get(profile_);
-  const extensions::Extension* extension = GetExtension();
+  ExtensionActionManager* manager = ExtensionActionManager::Get(profile_);
+  const Extension* extension = GetExtension();
   if (StartsWithASCII(name(), "scriptBadge.", false)) {
     extension_action_ = manager->GetScriptBadge(*extension);
   } else if (StartsWithASCII(name(), "systemIndicator.", false)) {
     extension_action_ = manager->GetSystemIndicator(*extension);
   } else {
     extension_action_ = manager->GetBrowserAction(*extension);
     if (!extension_action_) {
       extension_action_ = manager->GetPageAction(*extension);
     }
   }
   if (!extension_action_) {
     // TODO(kalman): ideally the browserAction/pageAction APIs wouldn't event
     // exist for extensions that don't have one declared. This should come as
     // part of the Feature system.
     error_ = kNoExtensionActionError;
     return false;
   }
 
   // Populates the tab_id_ and details_ members.
   EXTENSION_FUNCTION_VALIDATE(ExtractDataFromArguments());
 
   // Find the WebContents that contains this tab id if one is required.
   if (tab_id_ != ExtensionAction::kDefaultTabId) {
     ExtensionTabUtil::GetTabById(
         tab_id_, profile(), include_incognito(), NULL, NULL, &contents_, NULL);
     if (!contents_) {
-      error_ = extensions::ErrorUtils::FormatErrorMessage(
+      error_ = ErrorUtils::FormatErrorMessage(
           kNoTabError, base::IntToString(tab_id_));
       return false;
     }
   } else {
     // Only browser actions and system indicators have a default tabId.
-    extensions::ActionInfo::Type action_type = extension_action_->action_type();
+    ActionInfo::Type action_type = extension_action_->action_type();
     EXTENSION_FUNCTION_VALIDATE(
-        action_type == extensions::ActionInfo::TYPE_BROWSER ||
-        action_type == extensions::ActionInfo::TYPE_SYSTEM_INDICATOR);
+        action_type == ActionInfo::TYPE_BROWSER ||
+        action_type == ActionInfo::TYPE_SYSTEM_INDICATOR);
   }
   return RunExtensionAction();
 }
 
 bool ExtensionActionFunction::ExtractDataFromArguments() {
   // There may or may not be details (depends on the function).
   // The tabId might appear in details (if it exists), as the first
   // argument besides the action type (depends on the function), or be omitted
   // entirely.
   base::Value* first_arg = NULL;
@@ skipping 33 matching lines @@
 
     default:
       return false;
   }
 
   return true;
 }
 
 void ExtensionActionFunction::NotifyChange() {
   switch (extension_action_->action_type()) {
-    case extensions::ActionInfo::TYPE_BROWSER:
-    case extensions::ActionInfo::TYPE_PAGE:
-      if (extensions::ExtensionActionManager::Get(profile_)->
-          GetBrowserAction(*extension_)) {
+    case ActionInfo::TYPE_BROWSER:
+    case ActionInfo::TYPE_PAGE:
+      if (ExtensionActionManager::Get(profile_)->
+              GetBrowserAction(*extension_)) {
         NotifyBrowserActionChange();
-      } else if (extensions::ExtensionActionManager::Get(profile_)->
-                 GetPageAction(*extension_)) {
+      } else if (ExtensionActionManager::Get(profile_)->
+                     GetPageAction(*extension_)) {
         NotifyLocationBarChange();
       }
       return;
-    case extensions::ActionInfo::TYPE_SCRIPT_BADGE:
+    case ActionInfo::TYPE_SCRIPT_BADGE:
       NotifyLocationBarChange();
       return;
-    case extensions::ActionInfo::TYPE_SYSTEM_INDICATOR:
+    case ActionInfo::TYPE_SYSTEM_INDICATOR:
       NotifySystemIndicatorChange();
       return;
   }
   NOTREACHED();
 }
 
 void ExtensionActionFunction::NotifyBrowserActionChange() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
       content::Source<ExtensionAction>(extension_action_),
       content::Details<Profile>(profile()));
 }
 
 void ExtensionActionFunction::NotifyLocationBarChange() {
-  extensions::TabHelper::FromWebContents(contents_)->
+  TabHelper::FromWebContents(contents_)->
       location_bar_controller()->NotifyChange();
 }
 
 void ExtensionActionFunction::NotifySystemIndicatorChange() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_SYSTEM_INDICATOR_UPDATED,
       content::Source<Profile>(profile()),
       content::Details<ExtensionAction>(extension_action_));
 }
 
@@ skipping 36 matching lines @@
 
 bool ExtensionActionFunction::SetVisible(bool visible) {
   if (extension_action_->GetIsVisible(tab_id_) == visible)
     return true;
   extension_action_->SetAppearance(
       tab_id_, visible ? ExtensionAction::ACTIVE : ExtensionAction::INVISIBLE);
   NotifyChange();
   return true;
 }
 
-extensions::TabHelper& ExtensionActionFunction::tab_helper() const {
+TabHelper& ExtensionActionFunction::tab_helper() const {
   CHECK(contents_);
-  return *extensions::TabHelper::FromWebContents(contents_);
+  return *TabHelper::FromWebContents(contents_);
 }
 
 bool ExtensionActionShowFunction::RunExtensionAction() {
   return SetVisible(true);
 }
 
 bool ExtensionActionHideFunction::RunExtensionAction() {
   return SetVisible(false);
 }
 
@@ skipping 104 matching lines @@
 bool ExtensionActionGetBadgeBackgroundColorFunction::RunExtensionAction() {
   ListValue* list = new ListValue();
   SkColor color = extension_action_->GetBadgeBackgroundColor(tab_id_);
   list->Append(Value::CreateIntegerValue(SkColorGetR(color)));
   list->Append(Value::CreateIntegerValue(SkColorGetG(color)));
   list->Append(Value::CreateIntegerValue(SkColorGetB(color)));
   list->Append(Value::CreateIntegerValue(SkColorGetA(color)));
   SetResult(list);
   return true;
 }
+
+//
+// ScriptBadgeGetAttentionFunction
+//
+
+ScriptBadgeGetAttentionFunction::~ScriptBadgeGetAttentionFunction() {}
+
+bool ScriptBadgeGetAttentionFunction::RunExtensionAction() {
+  tab_helper().location_bar_controller()->GetAttentionFor(extension_id());
+  return true;
+}
+
+}  // namespace extensions
+
+//
+// PageActionsFunction (deprecated)
+//
+
+namespace keys = extension_page_actions_api_constants;
+
+PageActionsFunction::PageActionsFunction() {
+}
+
+PageActionsFunction::~PageActionsFunction() {
+}
+
+bool PageActionsFunction::SetPageActionEnabled(bool enable) {
+  std::string extension_action_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &extension_action_id));
+  DictionaryValue* action = NULL;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &action));
+
+  int tab_id;
+  EXTENSION_FUNCTION_VALIDATE(action->GetInteger(keys::kTabIdKey, &tab_id));
+  std::string url;
+  EXTENSION_FUNCTION_VALIDATE(action->GetString(keys::kUrlKey, &url));
+
+  std::string title;
+  if (enable) {
+    if (action->HasKey(keys::kTitleKey))
+      EXTENSION_FUNCTION_VALIDATE(action->GetString(keys::kTitleKey, &title));
+  }
+
+  ExtensionAction* page_action =
+      extensions::ExtensionActionManager::Get(profile())->
+      GetPageAction(*GetExtension());
+  if (!page_action) {
+    error_ = kNoPageActionError;
+    return false;
+  }
+
+  // Find the WebContents that contains this tab id.
+  content::WebContents* contents = NULL;
+  bool result = ExtensionTabUtil::GetTabById(
+      tab_id, profile(), include_incognito(), NULL, NULL, &contents, NULL);
+  if (!result || !contents) {
+    error_ = extensions::ErrorUtils::FormatErrorMessage(
+        kNoTabError, base::IntToString(tab_id));
+    return false;
+  }
+
+  // Make sure the URL hasn't changed.
+  content::NavigationEntry* entry = contents->GetController().GetActiveEntry();
+  if (!entry || url != entry->GetURL().spec()) {
+    error_ =
+        extensions::ErrorUtils::FormatErrorMessage(kUrlNotActiveError, url);
+    return false;
+  }
+
+  // Set visibility and broadcast notifications that the UI should be updated.
+  page_action->SetAppearance(
+      tab_id, enable ? ExtensionAction::ACTIVE : ExtensionAction::INVISIBLE);
+  page_action->SetTitle(tab_id, title);
+  extensions::TabHelper::FromWebContents(contents)->
+      location_bar_controller()->NotifyChange();
+
+  return true;
+}
+
+bool EnablePageActionsFunction::RunImpl() {
+  return SetPageActionEnabled(true);
+}
+
+bool DisablePageActionsFunction::RunImpl() {
+  return SetPageActionEnabled(false);
+}