From 5b105f911f7aa134ee44558fefaf171360d3d9d2 Mon Sep 17 00:00:00 2001 From: Shelley Vohr Date: Wed, 18 Oct 2023 16:19:31 +0200 Subject: [PATCH] chore: implement no-op `chrome.action` extension APIs (#40222) chore: implement no-op chrome.action extension APIs --- filenames.gni | 2 + .../extension_action/extension_action_api.cc | 197 +++++++ .../extension_action/extension_action_api.h | 520 ++++++++++++++++++ ...lectron_extensions_browser_api_provider.cc | 1 + shell/common/extensions/api/BUILD.gn | 1 + shell/common/extensions/api/action.json | 483 ++++++++++++++++ 6 files changed, 1204 insertions(+) create mode 100644 shell/browser/extensions/api/extension_action/extension_action_api.cc create mode 100644 shell/browser/extensions/api/extension_action/extension_action_api.h create mode 100644 shell/common/extensions/api/action.json diff --git a/filenames.gni b/filenames.gni index 74094b744b..527f186dcf 100644 --- a/filenames.gni +++ b/filenames.gni @@ -709,6 +709,8 @@ filenames = { ] lib_sources_extensions = [ + "shell/browser/extensions/api/extension_action/extension_action_api.cc", + "shell/browser/extensions/api/extension_action/extension_action_api.h", "shell/browser/extensions/api/management/electron_management_api_delegate.cc", "shell/browser/extensions/api/management/electron_management_api_delegate.h", "shell/browser/extensions/api/resources_private/resources_private_api.cc", diff --git a/shell/browser/extensions/api/extension_action/extension_action_api.cc b/shell/browser/extensions/api/extension_action/extension_action_api.cc new file mode 100644 index 0000000000..9c1df9450b --- /dev/null +++ b/shell/browser/extensions/api/extension_action/extension_action_api.cc @@ -0,0 +1,197 @@ +// Copyright (c) 2023 Microsoft, GmbH +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +#include "shell/browser/extensions/api/extension_action/extension_action_api.h" + +#include + +#include +#include + +#include "base/functional/bind.h" +#include "base/lazy_instance.h" +#include "base/observer_list.h" +#include "extensions/browser/event_router.h" +#include "extensions/browser/extension_prefs.h" +#include "extensions/browser/extension_util.h" +#include "extensions/common/mojom/view_type.mojom.h" + +using content::WebContents; + +namespace extensions { + +// +// ExtensionActionAPI::Observer +// + +void ExtensionActionAPI::Observer::OnExtensionActionUpdated( + ExtensionAction* extension_action, + content::WebContents* web_contents, + content::BrowserContext* browser_context) {} + +void ExtensionActionAPI::Observer::OnExtensionActionAPIShuttingDown() {} + +ExtensionActionAPI::Observer::~Observer() {} + +// +// ExtensionActionAPI +// + +static base::LazyInstance>:: + DestructorAtExit g_extension_action_api_factory = LAZY_INSTANCE_INITIALIZER; + +ExtensionActionAPI::ExtensionActionAPI(content::BrowserContext* context) + : browser_context_(context), extension_prefs_(nullptr) {} + +ExtensionActionAPI::~ExtensionActionAPI() {} + +// static +BrowserContextKeyedAPIFactory* +ExtensionActionAPI::GetFactoryInstance() { + return g_extension_action_api_factory.Pointer(); +} + +// static +ExtensionActionAPI* ExtensionActionAPI::Get(content::BrowserContext* context) { + return BrowserContextKeyedAPIFactory::Get(context); +} + +ExtensionPrefs* ExtensionActionAPI::GetExtensionPrefs() { + return nullptr; +} + +void ExtensionActionAPI::Shutdown() {} + +// +// ExtensionActionFunction +// + +ExtensionActionFunction::ExtensionActionFunction() {} + +ExtensionActionFunction::~ExtensionActionFunction() {} + +ExtensionFunction::ResponseAction ExtensionActionFunction::Run() { + return RunExtensionAction(); +} + +ExtensionFunction::ResponseAction +ExtensionActionShowFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.show is not supported in Electron"; + + return RespondNow(NoArguments()); +} + +ExtensionFunction::ResponseAction +ExtensionActionHideFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.hide is not supported in Electron"; + + return RespondNow(NoArguments()); +} + +ExtensionFunction::ResponseAction +ActionIsEnabledFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.isEnabled is not supported in Electron"; + + return RespondNow(WithArguments(false)); +} + +ExtensionFunction::ResponseAction +ExtensionActionSetIconFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.setIcon is not supported in Electron"; + + return RespondNow(NoArguments()); +} + +ExtensionFunction::ResponseAction +ExtensionActionSetTitleFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.setTitle is not supported in Electron"; + + return RespondNow(NoArguments()); +} + +ExtensionFunction::ResponseAction +ExtensionActionSetPopupFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.setPopup is not supported in Electron"; + + return RespondNow(NoArguments()); +} + +ExtensionFunction::ResponseAction +ExtensionActionSetBadgeTextFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.setBadgeText is not supported in Electron"; + + return RespondNow(NoArguments()); +} + +ExtensionFunction::ResponseAction +ExtensionActionSetBadgeBackgroundColorFunction::RunExtensionAction() { + LOG(INFO) + << "chrome.action.setBadgeBackgroundColor is not supported in Electron"; + + return RespondNow(NoArguments()); +} + +ExtensionFunction::ResponseAction +ActionSetBadgeTextColorFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.setBadgeTextColor is not supported in Electron"; + + return RespondNow(NoArguments()); +} + +ExtensionFunction::ResponseAction +ExtensionActionGetTitleFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.getTitle is not supported in Electron"; + + return RespondNow(WithArguments("")); +} + +ExtensionFunction::ResponseAction +ExtensionActionGetPopupFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.getPopup is not supported in Electron"; + + return RespondNow(WithArguments("")); +} + +ExtensionFunction::ResponseAction +ExtensionActionGetBadgeTextFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.getBadgeText is not supported in Electron"; + + return RespondNow(WithArguments("")); +} + +ExtensionFunction::ResponseAction +ExtensionActionGetBadgeBackgroundColorFunction::RunExtensionAction() { + LOG(INFO) + << "chrome.action.getBadgeBackgroundColor is not supported in Electron"; + + base::Value::List list; + return RespondNow(WithArguments(std::move(list))); +} + +ExtensionFunction::ResponseAction +ActionGetBadgeTextColorFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.getBadgeTextColor is not supported in Electron"; + + base::Value::List list; + return RespondNow(WithArguments(std::move(list))); +} + +ActionGetUserSettingsFunction::ActionGetUserSettingsFunction() = default; +ActionGetUserSettingsFunction::~ActionGetUserSettingsFunction() = default; + +ExtensionFunction::ResponseAction ActionGetUserSettingsFunction::Run() { + LOG(INFO) << "chrome.action.getUserSettings is not supported in Electron"; + + base::Value::Dict ui_settings; + return RespondNow(WithArguments(std::move(ui_settings))); +} + +ExtensionFunction::ResponseAction +ActionOpenPopupFunction::RunExtensionAction() { + LOG(INFO) << "chrome.action.openPopup is not supported in Electron"; + + return RespondNow(NoArguments()); +} + +} // namespace extensions diff --git a/shell/browser/extensions/api/extension_action/extension_action_api.h b/shell/browser/extensions/api/extension_action/extension_action_api.h new file mode 100644 index 0000000000..c22a23b17a --- /dev/null +++ b/shell/browser/extensions/api/extension_action/extension_action_api.h @@ -0,0 +1,520 @@ +// Copyright (c) 2023 Microsoft, GmbH +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +#ifndef SHELL_BROWSER_EXTENSIONS_API_EXTENSION_ACTION_EXTENSION_ACTION_API_H_ +#define SHELL_BROWSER_EXTENSIONS_API_EXTENSION_ACTION_EXTENSION_ACTION_API_H_ + +#include + +#include "base/memory/raw_ptr.h" +#include "base/observer_list.h" +#include "base/values.h" +#include "extensions/browser/browser_context_keyed_api_factory.h" +#include "extensions/browser/extension_action.h" +#include "extensions/browser/extension_function.h" +#include "extensions/browser/extension_host_registry.h" + +namespace content { +class BrowserContext; +class WebContents; +} // namespace content + +namespace extensions { + +class ExtensionHost; +class ExtensionPrefs; + +class ExtensionActionAPI : public BrowserContextKeyedAPI { + public: + class Observer { + public: + virtual void OnExtensionActionUpdated( + ExtensionAction* extension_action, + content::WebContents* web_contents, + content::BrowserContext* browser_context); + + virtual void OnExtensionActionAPIShuttingDown(); + + protected: + virtual ~Observer(); + }; + + explicit ExtensionActionAPI(content::BrowserContext* context); + + ExtensionActionAPI(const ExtensionActionAPI&) = delete; + ExtensionActionAPI& operator=(const ExtensionActionAPI&) = delete; + + ~ExtensionActionAPI() override; + + // Convenience method to get the instance for a profile. + static ExtensionActionAPI* Get(content::BrowserContext* context); + + static BrowserContextKeyedAPIFactory* + GetFactoryInstance(); + + // Add or remove observers. + void AddObserver(Observer* observer) {} + void RemoveObserver(Observer* observer) {} + + // Notifies that there has been a change in the given |extension_action|. + void NotifyChange(ExtensionAction* extension_action, + content::WebContents* web_contents, + content::BrowserContext* browser_context) {} + + // Dispatches the onClicked event for extension that owns the given action. + void DispatchExtensionActionClicked(const ExtensionAction& extension_action, + content::WebContents* web_contents, + const Extension* extension) {} + + // Clears the values for all ExtensionActions for the tab associated with the + // given |web_contents| (and signals that page actions changed). + void ClearAllValuesForTab(content::WebContents* web_contents) {} + + private: + friend class BrowserContextKeyedAPIFactory; + + ExtensionPrefs* GetExtensionPrefs(); + + // BrowserContextKeyedAPI implementation. + void Shutdown() override; + static const char* service_name() { return "ExtensionActionAPI"; } + static const bool kServiceRedirectedInIncognito = true; + + raw_ptr browser_context_; + + raw_ptr extension_prefs_; +}; + +// Implementation of the browserAction and pageAction APIs. +class ExtensionActionFunction : public ExtensionFunction { + protected: + ExtensionActionFunction(); + ~ExtensionActionFunction() override; + ResponseAction Run() override; + + virtual ResponseAction RunExtensionAction() = 0; +}; + +// +// Implementations of each extension action API. +// +// pageAction and browserAction bindings are created for these by extending them +// then declaring an EXTENSION_FUNCTION_NAME. +// + +// show +class ExtensionActionShowFunction : public ExtensionActionFunction { + protected: + ~ExtensionActionShowFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// hide +class ExtensionActionHideFunction : public ExtensionActionFunction { + protected: + ~ExtensionActionHideFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// setIcon +class ExtensionActionSetIconFunction : public ExtensionActionFunction { + public: + static void SetReportErrorForInvisibleIconForTesting(bool value); + + protected: + ~ExtensionActionSetIconFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// setTitle +class ExtensionActionSetTitleFunction : public ExtensionActionFunction { + protected: + ~ExtensionActionSetTitleFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// setPopup +class ExtensionActionSetPopupFunction : public ExtensionActionFunction { + protected: + ~ExtensionActionSetPopupFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// setBadgeText +class ExtensionActionSetBadgeTextFunction : public ExtensionActionFunction { + protected: + ~ExtensionActionSetBadgeTextFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// setBadgeBackgroundColor +class ExtensionActionSetBadgeBackgroundColorFunction + : public ExtensionActionFunction { + protected: + ~ExtensionActionSetBadgeBackgroundColorFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// getTitle +class ExtensionActionGetTitleFunction : public ExtensionActionFunction { + protected: + ~ExtensionActionGetTitleFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// getPopup +class ExtensionActionGetPopupFunction : public ExtensionActionFunction { + protected: + ~ExtensionActionGetPopupFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// openPopup +class ExtensionActionOpenPopupFunction : public ExtensionActionFunction { + protected: + ~ExtensionActionOpenPopupFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// getBadgeText +class ExtensionActionGetBadgeTextFunction : public ExtensionActionFunction { + protected: + ~ExtensionActionGetBadgeTextFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// getBadgeBackgroundColor +class ExtensionActionGetBadgeBackgroundColorFunction + : public ExtensionActionFunction { + protected: + ~ExtensionActionGetBadgeBackgroundColorFunction() override {} + ResponseAction RunExtensionAction() override; +}; + +// +// action.* aliases for supported action APIs. +// + +class ActionSetIconFunction : public ExtensionActionSetIconFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.setIcon", ACTION_SETICON) + + protected: + ~ActionSetIconFunction() override {} +}; + +class ActionGetPopupFunction : public ExtensionActionGetPopupFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.getPopup", ACTION_GETPOPUP) + + protected: + ~ActionGetPopupFunction() override {} +}; + +class ActionSetPopupFunction : public ExtensionActionSetPopupFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.setPopup", ACTION_SETPOPUP) + + protected: + ~ActionSetPopupFunction() override {} +}; + +class ActionGetTitleFunction : public ExtensionActionGetTitleFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.getTitle", ACTION_GETTITLE) + + protected: + ~ActionGetTitleFunction() override {} +}; + +class ActionSetTitleFunction : public ExtensionActionSetTitleFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.setTitle", ACTION_SETTITLE) + + protected: + ~ActionSetTitleFunction() override {} +}; + +class ActionGetBadgeTextFunction : public ExtensionActionGetBadgeTextFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.getBadgeText", ACTION_GETBADGETEXT) + + protected: + ~ActionGetBadgeTextFunction() override {} +}; + +class ActionSetBadgeTextFunction : public ExtensionActionSetBadgeTextFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.setBadgeText", ACTION_SETBADGETEXT) + + protected: + ~ActionSetBadgeTextFunction() override {} +}; + +class ActionGetBadgeBackgroundColorFunction + : public ExtensionActionGetBadgeBackgroundColorFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.getBadgeBackgroundColor", + ACTION_GETBADGEBACKGROUNDCOLOR) + + protected: + ~ActionGetBadgeBackgroundColorFunction() override {} +}; + +class ActionSetBadgeBackgroundColorFunction + : public ExtensionActionSetBadgeBackgroundColorFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.setBadgeBackgroundColor", + ACTION_SETBADGEBACKGROUNDCOLOR) + + protected: + ~ActionSetBadgeBackgroundColorFunction() override {} +}; + +class ActionGetBadgeTextColorFunction : public ExtensionActionFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.getBadgeTextColor", + ACTION_GETBADGETEXTCOLOR) + + protected: + ~ActionGetBadgeTextColorFunction() override = default; + ResponseAction RunExtensionAction() override; +}; + +class ActionSetBadgeTextColorFunction : public ExtensionActionFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.setBadgeTextColor", + ACTION_SETBADGETEXTCOLOR) + + protected: + ~ActionSetBadgeTextColorFunction() override = default; + ResponseAction RunExtensionAction() override; +}; + +class ActionEnableFunction : public ExtensionActionShowFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.enable", ACTION_ENABLE) + + protected: + ~ActionEnableFunction() override {} +}; + +class ActionDisableFunction : public ExtensionActionHideFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.disable", ACTION_DISABLE) + + protected: + ~ActionDisableFunction() override {} +}; + +class ActionIsEnabledFunction : public ExtensionActionFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.isEnabled", ACTION_ISENABLED) + + protected: + ~ActionIsEnabledFunction() override = default; + ResponseAction RunExtensionAction() override; +}; + +class ActionGetUserSettingsFunction : public ExtensionFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.getUserSettings", ACTION_GETUSERSETTINGS) + + ActionGetUserSettingsFunction(); + ActionGetUserSettingsFunction(const ActionGetUserSettingsFunction&) = delete; + ActionGetUserSettingsFunction& operator=( + const ActionGetUserSettingsFunction&) = delete; + + ResponseAction Run() override; + + protected: + ~ActionGetUserSettingsFunction() override; +}; + +class ActionOpenPopupFunction : public ExtensionActionOpenPopupFunction { + public: + DECLARE_EXTENSION_FUNCTION("action.openPopup", ACTION_OPENPOPUP) + + protected: + ~ActionOpenPopupFunction() override = default; + ResponseAction RunExtensionAction() override; +}; + +// +// browserAction.* aliases for supported browserAction APIs. +// + +class BrowserActionSetIconFunction : public ExtensionActionSetIconFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.setIcon", BROWSERACTION_SETICON) + + protected: + ~BrowserActionSetIconFunction() override {} +}; + +class BrowserActionSetTitleFunction : public ExtensionActionSetTitleFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.setTitle", BROWSERACTION_SETTITLE) + + protected: + ~BrowserActionSetTitleFunction() override {} +}; + +class BrowserActionSetPopupFunction : public ExtensionActionSetPopupFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.setPopup", BROWSERACTION_SETPOPUP) + + protected: + ~BrowserActionSetPopupFunction() override {} +}; + +class BrowserActionGetTitleFunction : public ExtensionActionGetTitleFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.getTitle", BROWSERACTION_GETTITLE) + + protected: + ~BrowserActionGetTitleFunction() override {} +}; + +class BrowserActionGetPopupFunction : public ExtensionActionGetPopupFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.getPopup", BROWSERACTION_GETPOPUP) + + protected: + ~BrowserActionGetPopupFunction() override {} +}; + +class BrowserActionSetBadgeTextFunction + : public ExtensionActionSetBadgeTextFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.setBadgeText", + BROWSERACTION_SETBADGETEXT) + + protected: + ~BrowserActionSetBadgeTextFunction() override {} +}; + +class BrowserActionSetBadgeBackgroundColorFunction + : public ExtensionActionSetBadgeBackgroundColorFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.setBadgeBackgroundColor", + BROWSERACTION_SETBADGEBACKGROUNDCOLOR) + + protected: + ~BrowserActionSetBadgeBackgroundColorFunction() override {} +}; + +class BrowserActionGetBadgeTextFunction + : public ExtensionActionGetBadgeTextFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.getBadgeText", + BROWSERACTION_GETBADGETEXT) + + protected: + ~BrowserActionGetBadgeTextFunction() override {} +}; + +class BrowserActionGetBadgeBackgroundColorFunction + : public ExtensionActionGetBadgeBackgroundColorFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.getBadgeBackgroundColor", + BROWSERACTION_GETBADGEBACKGROUNDCOLOR) + + protected: + ~BrowserActionGetBadgeBackgroundColorFunction() override {} +}; + +class BrowserActionEnableFunction : public ExtensionActionShowFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.enable", BROWSERACTION_ENABLE) + + protected: + ~BrowserActionEnableFunction() override {} +}; + +class BrowserActionDisableFunction : public ExtensionActionHideFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.disable", BROWSERACTION_DISABLE) + + protected: + ~BrowserActionDisableFunction() override {} +}; + +class BrowserActionOpenPopupFunction : public ExtensionActionOpenPopupFunction { + public: + DECLARE_EXTENSION_FUNCTION("browserAction.openPopup", + BROWSERACTION_OPEN_POPUP) + + protected: + ~BrowserActionOpenPopupFunction() override {} +}; + +} // namespace extensions + +// +// pageAction.* aliases for supported pageAction APIs. +// + +class PageActionShowFunction : public extensions::ExtensionActionShowFunction { + public: + DECLARE_EXTENSION_FUNCTION("pageAction.show", PAGEACTION_SHOW) + + protected: + ~PageActionShowFunction() override {} +}; + +class PageActionHideFunction : public extensions::ExtensionActionHideFunction { + public: + DECLARE_EXTENSION_FUNCTION("pageAction.hide", PAGEACTION_HIDE) + + protected: + ~PageActionHideFunction() override {} +}; + +class PageActionSetIconFunction + : public extensions::ExtensionActionSetIconFunction { + public: + DECLARE_EXTENSION_FUNCTION("pageAction.setIcon", PAGEACTION_SETICON) + + protected: + ~PageActionSetIconFunction() override {} +}; + +class PageActionSetTitleFunction + : public extensions::ExtensionActionSetTitleFunction { + public: + DECLARE_EXTENSION_FUNCTION("pageAction.setTitle", PAGEACTION_SETTITLE) + + protected: + ~PageActionSetTitleFunction() override {} +}; + +class PageActionSetPopupFunction + : public extensions::ExtensionActionSetPopupFunction { + public: + DECLARE_EXTENSION_FUNCTION("pageAction.setPopup", PAGEACTION_SETPOPUP) + + protected: + ~PageActionSetPopupFunction() override {} +}; + +class PageActionGetTitleFunction + : public extensions::ExtensionActionGetTitleFunction { + public: + DECLARE_EXTENSION_FUNCTION("pageAction.getTitle", PAGEACTION_GETTITLE) + + protected: + ~PageActionGetTitleFunction() override {} +}; + +class PageActionGetPopupFunction + : public extensions::ExtensionActionGetPopupFunction { + public: + DECLARE_EXTENSION_FUNCTION("pageAction.getPopup", PAGEACTION_GETPOPUP) + + protected: + ~PageActionGetPopupFunction() override {} +}; + +#endif // SHELL_BROWSER_EXTENSIONS_API_EXTENSION_ACTION_EXTENSION_ACTION_API_H_ diff --git a/shell/browser/extensions/electron_extensions_browser_api_provider.cc b/shell/browser/extensions/electron_extensions_browser_api_provider.cc index 6317a5a334..a066a78740 100644 --- a/shell/browser/extensions/electron_extensions_browser_api_provider.cc +++ b/shell/browser/extensions/electron_extensions_browser_api_provider.cc @@ -6,6 +6,7 @@ #include "extensions/browser/api/i18n/i18n_api.h" #include "extensions/browser/extension_function_registry.h" +#include "shell/browser/extensions/api/extension_action/extension_action_api.h" #include "shell/browser/extensions/api/generated_api_registration.h" #include "shell/browser/extensions/api/scripting/scripting_api.h" #include "shell/browser/extensions/api/tabs/tabs_api.h" diff --git a/shell/common/extensions/api/BUILD.gn b/shell/common/extensions/api/BUILD.gn index 839dd06954..e40defe1a8 100644 --- a/shell/common/extensions/api/BUILD.gn +++ b/shell/common/extensions/api/BUILD.gn @@ -37,6 +37,7 @@ group("extensions_features") { generated_json_strings("generated_api_json_strings") { sources = [ + "action.json", "extension.json", "resources_private.idl", "scripting.idl", diff --git a/shell/common/extensions/api/action.json b/shell/common/extensions/api/action.json new file mode 100644 index 0000000000..0c109ba94d --- /dev/null +++ b/shell/common/extensions/api/action.json @@ -0,0 +1,483 @@ +// Copyright (c) 2023 Microsoft, GmbH +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. +[ + { + "namespace": "action", + "description": "Use the chrome.action API to control the extension's icon in the Google Chrome toolbar.", + "compiler_options": { + "implemented_in": "shell/browser/extensions/api/extension_action/extension_action_api.h" + }, + "types": [ + { + "id": "TabDetails", + "type": "object", + "properties": { + "tabId": { + "type": "integer", + "optional": true, + "minimum": 0, + "description": "The ID of the tab to query state for. If no tab is specified, the non-tab-specific state is returned." + } + } + }, + { + "id": "UserSettings", + "type": "object", + "properties": { + "isOnToolbar": { + "type": "boolean", + "description": "Whether the extension's action icon is visible on browser windows' top-level toolbar (i.e., whether the extension has been 'pinned' by the user)." + } + }, + "description": "The collection of user-specified settings relating to an extension's action." + }, + { + "id": "OpenPopupOptions", + "type": "object", + "properties": { + "windowId": { + "type": "integer", + "description": "The id of the window to open the action popup in. Defaults to the currently-active window if unspecified.", + "optional": true + } + } + } + ], + "functions": [ + { + "name": "setTitle", + "deprecated": "chrome.action.setTitle is not supported in Electron", + "type": "function", + "description": "Sets the title of the action. This shows up in the tooltip.", + "parameters": [ + { + "name": "details", + "type": "object", + "properties": { + "title": { + "type": "string", + "description": "The string the action should display when moused over." + }, + "tabId": { + "type": "integer", + "optional": true, + "minimum": 0, + "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed." + } + } + } + ], + "returns_async": { + "name": "callback", + "parameters": [], + "optional": true + } + }, + { + "name": "getTitle", + "deprecated": "chrome.action.getTitle is not supported in Electron", + "type": "function", + "description": "Gets the title of the action.", + "parameters": [ + { + "name": "details", + "$ref": "TabDetails" + } + ], + "returns_async": { + "name": "callback", + "parameters": [ + { + "name": "result", + "type": "string" + } + ] + } + }, + { + "name": "setIcon", + "deprecated": "chrome.action.setIcon is not supported in Electron", + "type": "function", + "description": "Sets the icon for the action. The icon can be specified either as the path to an image file or as the pixel data from a canvas element, or as dictionary of either one of those. Either the path or the imageData property must be specified.", + "parameters": [ + { + "name": "details", + "type": "object", + "properties": { + "imageData": { + "choices": [ + { + "$ref": "browserAction.ImageDataType" + }, + { + "type": "object", + "additionalProperties": { + "type": "any" + } + } + ], + "optional": true, + "description": "Either an ImageData object or a dictionary {size -> ImageData} representing icon to be set. If the icon is specified as a dictionary, the actual image to be used is chosen depending on screen's pixel density. If the number of image pixels that fit into one screen space unit equals scale, then image with size scale * n will be selected, where n is the size of the icon in the UI. At least one image must be specified. Note that 'details.imageData = foo' is equivalent to 'details.imageData = {'16': foo}'" + }, + "path": { + "choices": [ + { + "type": "string" + }, + { + "type": "object", + "additionalProperties": { + "type": "any" + } + } + ], + "optional": true, + "description": "Either a relative image path or a dictionary {size -> relative image path} pointing to icon to be set. If the icon is specified as a dictionary, the actual image to be used is chosen depending on screen's pixel density. If the number of image pixels that fit into one screen space unit equals scale, then image with size scale * n will be selected, where n is the size of the icon in the UI. At least one image must be specified. Note that 'details.path = foo' is equivalent to 'details.path = {'16': foo}'" + }, + "tabId": { + "type": "integer", + "optional": true, + "minimum": 0, + "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed." + } + } + } + ], + "returns_async": { + "name": "callback", + "optional": true, + "parameters": [] + } + }, + { + "name": "setPopup", + "deprecated": "chrome.action.setPopup is not supported in Electron", + "type": "function", + "description": "Sets the HTML document to be opened as a popup when the user clicks on the action's icon.", + "parameters": [ + { + "name": "details", + "type": "object", + "properties": { + "tabId": { + "type": "integer", + "optional": true, + "minimum": 0, + "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed." + }, + "popup": { + "type": "string", + "description": "The relative path to the HTML file to show in a popup. If set to the empty string (''), no popup is shown." + } + } + } + ], + "returns_async": { + "name": "callback", + "parameters": [], + "optional": true + } + }, + { + "name": "getPopup", + "deprecated": "chrome.action.getPopup is not supported in Electron", + "type": "function", + "description": "Gets the html document set as the popup for this action.", + "parameters": [ + { + "name": "details", + "$ref": "TabDetails" + } + ], + "returns_async": { + "name": "callback", + "parameters": [ + { + "name": "result", + "type": "string" + } + ] + } + }, + { + "name": "setBadgeText", + "deprecated": "chrome.action.setBadgeText is not supported in Electron", + "type": "function", + "description": "Sets the badge text for the action. The badge is displayed on top of the icon.", + "parameters": [ + { + "name": "details", + "type": "object", + "properties": { + "text": { + "type": "string", + "optional": true, + "description": "Any number of characters can be passed, but only about four can fit in the space. If an empty string ('') is passed, the badge text is cleared. If tabId is specified and text is null, the text for the specified tab is cleared and defaults to the global badge text." + }, + "tabId": { + "type": "integer", + "optional": true, + "minimum": 0, + "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed." + } + } + } + ], + "returns_async": { + "name": "callback", + "parameters": [], + "optional": true + } + }, + { + "name": "getBadgeText", + "deprecated": "chrome.action.getBadgeText is not supported in Electron", + "type": "function", + "description": "Gets the badge text of the action. If no tab is specified, the non-tab-specific badge text is returned. If displayActionCountAsBadgeText is enabled, a placeholder text will be returned unless the declarativeNetRequestFeedback permission is present or tab-specific badge text was provided.", + "parameters": [ + { + "name": "details", + "$ref": "TabDetails" + } + ], + "returns_async": { + "name": "callback", + "parameters": [ + { + "name": "result", + "type": "string" + } + ] + } + }, + { + "name": "setBadgeBackgroundColor", + "deprecated": "chrome.action.setBadgeBackgroundColor is not supported in Electron", + "type": "function", + "description": "Sets the background color for the badge.", + "parameters": [ + { + "name": "details", + "type": "object", + "properties": { + "color": { + "description": "An array of four integers in the range [0,255] that make up the RGBA color of the badge. For example, opaque red is [255, 0, 0, 255]. Can also be a string with a CSS value, with opaque red being #FF0000 or #F00.", + "choices": [ + { + "type": "string" + }, + { + "$ref": "browserAction.ColorArray" + } + ] + }, + "tabId": { + "type": "integer", + "optional": true, + "minimum": 0, + "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed." + } + } + } + ], + "returns_async": { + "name": "callback", + "parameters": [], + "optional": true + } + }, + { + "name": "getBadgeBackgroundColor", + "deprecated": "chrome.action.getBadgeBackgroundColor is not supported in Electron", + "type": "function", + "description": "Gets the background color of the action.", + "parameters": [ + { + "name": "details", + "$ref": "TabDetails" + } + ], + "returns_async": { + "name": "callback", + "parameters": [ + { + "name": "result", + "$ref": "browserAction.ColorArray" + } + ] + } + }, + { + "name": "setBadgeTextColor", + "deprecated": "chrome.action.setBadgeTextColor is not supported in Electron", + "type": "function", + "description": "Sets the text color for the badge.", + "parameters": [ + { + "name": "details", + "type": "object", + "properties": { + "color": { + "description": "An array of four integers in the range [0,255] that make up the RGBA color of the badge. For example, opaque red is [255, 0, 0, 255]. Can also be a string with a CSS value, with opaque red being #FF0000 or #F00. Not setting this value will cause a color to be automatically chosen that will contrast with the badge's background color so the text will be visible. Colors with alpha values equivalent to 0 will not be set and will return an error.", + "choices": [ + { + "type": "string" + }, + { + "$ref": "browserAction.ColorArray" + } + ] + }, + "tabId": { + "type": "integer", + "optional": true, + "minimum": 0, + "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed." + } + } + } + ], + "returns_async": { + "name": "callback", + "parameters": [], + "optional": true + } + }, + { + "name": "getBadgeTextColor", + "deprecated": "chrome.action.getBadgeTextColor is not supported in Electron", + "type": "function", + "description": "Gets the text color of the action.", + "parameters": [ + { + "name": "details", + "$ref": "TabDetails" + } + ], + "returns_async": { + "name": "callback", + "parameters": [ + { + "name": "result", + "$ref": "browserAction.ColorArray" + } + ] + } + }, + { + "name": "enable", + "deprecated": "chrome.action.enable is not supported in Electron", + "type": "function", + "description": "Enables the action for a tab. By default, actions are enabled.", + "parameters": [ + { + "type": "integer", + "optional": true, + "name": "tabId", + "minimum": 0, + "description": "The id of the tab for which you want to modify the action." + } + ], + "returns_async": { + "name": "callback", + "parameters": [], + "optional": true + } + }, + { + "name": "disable", + "deprecated": "chrome.action.disable is not supported in Electron", + "type": "function", + "description": "Disables the action for a tab.", + "parameters": [ + { + "type": "integer", + "optional": true, + "name": "tabId", + "minimum": 0, + "description": "The id of the tab for which you want to modify the action." + } + ], + "returns_async": { + "name": "callback", + "parameters": [], + "optional": true + } + }, + { + "name": "isEnabled", + "deprecated": "chrome.action.isEnabled is not supported in Electron", + "type": "function", + "description": "Indicates whether the extension action is enabled for a tab (or globally if no tabId is provided). Actions enabled using only $(ref:declarativeContent) always return false.", + "parameters": [ + { + "type": "integer", + "optional": true, + "name": "tabId", + "minimum": 0, + "description": "The id of the tab for which you want check enabled status." + } + ], + "returns_async": { + "name": "callback", + "parameters": [ + { + "name": "isEnabled", + "type": "boolean", + "description": "True if the extension action is enabled." + } + ] + } + }, + { + "name": "getUserSettings", + "deprecated": "chrome.action.getUserSettings is not supported in Electron", + "type": "function", + "description": "Returns the user-specified settings relating to an extension's action.", + "parameters": [], + "returns_async": { + "name": "callback", + "parameters": [ + { + "name": "userSettings", + "$ref": "UserSettings" + } + ] + } + }, + { + "name": "openPopup", + "deprecated": "chrome.action.openPopup is not supported in Electron", + "type": "function", + "description": "Opens the extension's popup.", + "parameters": [ + { + "$ref": "OpenPopupOptions", + "name": "options", + "optional": true, + "description": "Specifies options for opening the popup." + } + ], + "returns_async": { + "name": "callback", + "parameters": [] + } + } + ], + "events": [ + { + "name": "onClicked", + "deprecated": "chrome.action.onClicked is not supported in Electron", + "type": "function", + "description": "Fired when an action icon is clicked. This event will not fire if the action has a popup.", + "parameters": [ + { + "name": "tab", + "$ref": "tabs.Tab" + } + ] + } + ] + } +]