blob: 320bda7ac3622a32fcd3a76fae908b12b0f5ba33 [file] [log] [blame]
// Copyright 2014 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.
// IPC messages for extensions.
// Multiply-included message file, hence no include guard.
#include <stdint.h>
#include <string>
#include <vector>
#include "base/memory/shared_memory.h"
#include "base/values.h"
#include "components/version_info/version_info.h"
#include "content/public/common/common_param_traits.h"
#include "content/public/common/socket_permission_request.h"
#include "extensions/common/api/messaging/message.h"
#include "extensions/common/draggable_region.h"
#include "extensions/common/extension.h"
#include "extensions/common/extensions_client.h"
#include "extensions/common/host_id.h"
#include "extensions/common/permissions/media_galleries_permission_data.h"
#include "extensions/common/permissions/permission_set.h"
#include "extensions/common/permissions/socket_permission_data.h"
#include "extensions/common/permissions/usb_device_permission_data.h"
#include "extensions/common/stack_frame.h"
#include "extensions/common/url_pattern.h"
#include "extensions/common/url_pattern_set.h"
#include "extensions/common/user_script.h"
#include "extensions/common/view_type.h"
#include "ipc/ipc_message_macros.h"
#include "url/gurl.h"
#define IPC_MESSAGE_START ExtensionMsgStart
IPC_ENUM_TRAITS_MAX_VALUE(extensions::ViewType, extensions::VIEW_TYPE_LAST)
IPC_ENUM_TRAITS_MAX_VALUE(content::SocketPermissionRequest::OperationType,
content::SocketPermissionRequest::OPERATION_TYPE_LAST)
IPC_ENUM_TRAITS_MAX_VALUE(extensions::UserScript::InjectionType,
extensions::UserScript::INJECTION_TYPE_LAST)
IPC_ENUM_TRAITS_MAX_VALUE(extensions::UserScript::RunLocation,
extensions::UserScript::RUN_LOCATION_LAST - 1)
IPC_ENUM_TRAITS_MAX_VALUE(HostID::HostType, HostID::HOST_TYPE_LAST)
IPC_ENUM_TRAITS_MAX_VALUE(version_info::Channel, version_info::Channel::STABLE)
// Parameters structure for ExtensionHostMsg_AddAPIActionToActivityLog and
// ExtensionHostMsg_AddEventToActivityLog.
IPC_STRUCT_BEGIN(ExtensionHostMsg_APIActionOrEvent_Params)
// API name.
IPC_STRUCT_MEMBER(std::string, api_call)
// List of arguments.
IPC_STRUCT_MEMBER(base::ListValue, arguments)
// Extra logging information.
IPC_STRUCT_MEMBER(std::string, extra)
IPC_STRUCT_END()
// Parameters structure for ExtensionHostMsg_AddDOMActionToActivityLog.
IPC_STRUCT_BEGIN(ExtensionHostMsg_DOMAction_Params)
// URL of the page.
IPC_STRUCT_MEMBER(GURL, url)
// Title of the page.
IPC_STRUCT_MEMBER(base::string16, url_title)
// API name.
IPC_STRUCT_MEMBER(std::string, api_call)
// List of arguments.
IPC_STRUCT_MEMBER(base::ListValue, arguments)
// Type of DOM API call.
IPC_STRUCT_MEMBER(int, call_type)
IPC_STRUCT_END()
// Parameters structure for ExtensionHostMsg_Request.
IPC_STRUCT_BEGIN(ExtensionHostMsg_Request_Params)
// Message name.
IPC_STRUCT_MEMBER(std::string, name)
// List of message arguments.
IPC_STRUCT_MEMBER(base::ListValue, arguments)
// Extension ID this request was sent from. This can be empty, in the case
// where we expose APIs to normal web pages using the extension function
// system.
IPC_STRUCT_MEMBER(std::string, extension_id)
// URL of the frame the request was sent from. This isn't necessarily an
// extension url. Extension requests can also originate from content scripts,
// in which case extension_id will indicate the ID of the associated
// extension. Or, they can originate from hosted apps or normal web pages.
IPC_STRUCT_MEMBER(GURL, source_url)
// The id of the tab that sent this request, or -1 if there is no source tab.
IPC_STRUCT_MEMBER(int, source_tab_id)
// Unique request id to match requests and responses.
IPC_STRUCT_MEMBER(int, request_id)
// True if request has a callback specified.
IPC_STRUCT_MEMBER(bool, has_callback)
// True if request is executed in response to an explicit user gesture.
IPC_STRUCT_MEMBER(bool, user_gesture)
// If this API call is for a service worker, then this is the worker thread
// id. Otherwise, this is -1.
IPC_STRUCT_MEMBER(int, worker_thread_id)
// If this API call is for a service worker, then this is the embedded
// worker id. Otherwise, this is -1.
IPC_STRUCT_MEMBER(int, embedded_worker_id)
IPC_STRUCT_END()
// Allows an extension to execute code in a tab.
IPC_STRUCT_BEGIN(ExtensionMsg_ExecuteCode_Params)
// The extension API request id, for responding.
IPC_STRUCT_MEMBER(int, request_id)
// The ID of the requesting injection host.
IPC_STRUCT_MEMBER(HostID, host_id)
// Whether the code is JavaScript or CSS.
IPC_STRUCT_MEMBER(bool, is_javascript)
// String of code to execute.
IPC_STRUCT_MEMBER(std::string, code)
// The webview guest source who calls to execute code.
IPC_STRUCT_MEMBER(GURL, webview_src)
// Whether to inject into about:blank (sub)frames.
IPC_STRUCT_MEMBER(bool, match_about_blank)
// When to inject the code.
IPC_STRUCT_MEMBER(int, run_at)
// Whether to execute code in the main world (as opposed to an isolated
// world).
IPC_STRUCT_MEMBER(bool, in_main_world)
// Whether the request is coming from a <webview>.
IPC_STRUCT_MEMBER(bool, is_web_view)
// Whether the caller is interested in the result value. Manifest-declared
// content scripts and executeScript() calls without a response callback
// are examples of when this will be false.
IPC_STRUCT_MEMBER(bool, wants_result)
// The URL of the file that was injected, if any.
IPC_STRUCT_MEMBER(GURL, file_url)
// Whether the code to be executed should be associated with a user gesture.
IPC_STRUCT_MEMBER(bool, user_gesture)
IPC_STRUCT_END()
// Struct containing information about the sender of connect() calls that
// originate from a tab.
IPC_STRUCT_BEGIN(ExtensionMsg_TabConnectionInfo)
// The tab from where the connection was created.
IPC_STRUCT_MEMBER(base::DictionaryValue, tab)
// The ID of the frame that initiated the connection.
// 0 if main frame, positive otherwise. -1 if not initiated from a frame.
IPC_STRUCT_MEMBER(int, frame_id)
IPC_STRUCT_END()
// Struct containing information about the destination of tab.connect().
IPC_STRUCT_BEGIN(ExtensionMsg_TabTargetConnectionInfo)
// The destination tab's ID.
IPC_STRUCT_MEMBER(int, tab_id)
// Frame ID of the destination. -1 for all frames, 0 for main frame and
// positive if the destination is a specific child frame.
IPC_STRUCT_MEMBER(int, frame_id)
IPC_STRUCT_END()
// Struct containing the data for external connections to extensions. Used to
// handle the IPCs initiated by both connect() and onConnect().
IPC_STRUCT_BEGIN(ExtensionMsg_ExternalConnectionInfo)
// The ID of the extension that is the target of the request.
IPC_STRUCT_MEMBER(std::string, target_id)
// The ID of the extension that initiated the request. May be empty if it
// wasn't initiated by an extension.
IPC_STRUCT_MEMBER(std::string, source_id)
// The URL of the frame that initiated the request.
IPC_STRUCT_MEMBER(GURL, source_url)
// The process ID of the webview that initiated the request.
IPC_STRUCT_MEMBER(int, guest_process_id)
// The render frame routing ID of the webview that initiated the request.
IPC_STRUCT_MEMBER(int, guest_render_frame_routing_id)
IPC_STRUCT_END()
IPC_STRUCT_TRAITS_BEGIN(extensions::DraggableRegion)
IPC_STRUCT_TRAITS_MEMBER(draggable)
IPC_STRUCT_TRAITS_MEMBER(bounds)
IPC_STRUCT_TRAITS_END()
IPC_STRUCT_TRAITS_BEGIN(content::SocketPermissionRequest)
IPC_STRUCT_TRAITS_MEMBER(type)
IPC_STRUCT_TRAITS_MEMBER(host)
IPC_STRUCT_TRAITS_MEMBER(port)
IPC_STRUCT_TRAITS_END()
IPC_STRUCT_TRAITS_BEGIN(extensions::SocketPermissionEntry)
IPC_STRUCT_TRAITS_MEMBER(pattern_)
IPC_STRUCT_TRAITS_MEMBER(match_subdomains_)
IPC_STRUCT_TRAITS_END()
IPC_STRUCT_TRAITS_BEGIN(extensions::SocketPermissionData)
IPC_STRUCT_TRAITS_MEMBER(entry())
IPC_STRUCT_TRAITS_END()
IPC_STRUCT_TRAITS_BEGIN(extensions::StackFrame)
IPC_STRUCT_TRAITS_MEMBER(line_number)
IPC_STRUCT_TRAITS_MEMBER(column_number)
IPC_STRUCT_TRAITS_MEMBER(source)
IPC_STRUCT_TRAITS_MEMBER(function)
IPC_STRUCT_TRAITS_END()
IPC_STRUCT_TRAITS_BEGIN(extensions::UsbDevicePermissionData)
IPC_STRUCT_TRAITS_MEMBER(vendor_id())
IPC_STRUCT_TRAITS_MEMBER(product_id())
IPC_STRUCT_TRAITS_END()
IPC_STRUCT_TRAITS_BEGIN(extensions::MediaGalleriesPermissionData)
IPC_STRUCT_TRAITS_MEMBER(permission())
IPC_STRUCT_TRAITS_END()
IPC_STRUCT_TRAITS_BEGIN(extensions::Message)
IPC_STRUCT_TRAITS_MEMBER(data)
IPC_STRUCT_TRAITS_MEMBER(user_gesture)
IPC_STRUCT_TRAITS_END()
// Singly-included section for custom IPC traits.
#ifndef EXTENSIONS_COMMON_EXTENSION_MESSAGES_H_
#define EXTENSIONS_COMMON_EXTENSION_MESSAGES_H_
// IPC_MESSAGE macros choke on extra , in the std::map, when expanding. We need
// to typedef it to avoid that.
// Substitution map for l10n messages.
typedef std::map<std::string, std::string> SubstitutionMap;
// Map of extensions IDs to the executing script paths.
typedef std::map<std::string, std::set<std::string> > ExecutingScriptsMap;
struct ExtensionMsg_PermissionSetStruct {
ExtensionMsg_PermissionSetStruct();
explicit ExtensionMsg_PermissionSetStruct(
const extensions::PermissionSet& permissions);
ExtensionMsg_PermissionSetStruct(
const ExtensionMsg_PermissionSetStruct& other);
~ExtensionMsg_PermissionSetStruct();
std::unique_ptr<const extensions::PermissionSet> ToPermissionSet() const;
extensions::APIPermissionSet apis;
extensions::ManifestPermissionSet manifest_permissions;
extensions::URLPatternSet explicit_hosts;
extensions::URLPatternSet scriptable_hosts;
};
struct ExtensionMsg_Loaded_Params {
ExtensionMsg_Loaded_Params();
~ExtensionMsg_Loaded_Params();
ExtensionMsg_Loaded_Params(const extensions::Extension* extension,
bool include_tab_permissions);
ExtensionMsg_Loaded_Params(const ExtensionMsg_Loaded_Params& other);
// Creates a new extension from the data in this object.
scoped_refptr<extensions::Extension> ConvertToExtension(
std::string* error) const;
// The subset of the extension manifest data we send to renderers.
linked_ptr<base::DictionaryValue> manifest;
// The location the extension was installed from.
extensions::Manifest::Location location;
// The path the extension was loaded from. This is used in the renderer only
// to generate the extension ID for extensions that are loaded unpacked.
base::FilePath path;
// The extension's active and withheld permissions.
ExtensionMsg_PermissionSetStruct active_permissions;
ExtensionMsg_PermissionSetStruct withheld_permissions;
std::map<int, ExtensionMsg_PermissionSetStruct> tab_specific_permissions;
// We keep this separate so that it can be used in logging.
std::string id;
// Send creation flags so extension is initialized identically.
int creation_flags;
};
struct ExtensionHostMsg_AutomationQuerySelector_Error {
enum Value { kNone, kNoMainFrame, kNoDocument, kNodeDestroyed };
ExtensionHostMsg_AutomationQuerySelector_Error() : value(kNone) {}
Value value;
};
namespace IPC {
template <>
struct ParamTraits<URLPattern> {
typedef URLPattern param_type;
static void GetSize(base::PickleSizer* s, const param_type& p);
static void Write(base::Pickle* m, const param_type& p);
static bool Read(const base::Pickle* m,
base::PickleIterator* iter,
param_type* p);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<extensions::URLPatternSet> {
typedef extensions::URLPatternSet param_type;
static void GetSize(base::PickleSizer* s, const param_type& p);
static void Write(base::Pickle* m, const param_type& p);
static bool Read(const base::Pickle* m,
base::PickleIterator* iter,
param_type* p);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<extensions::APIPermission::ID> {
typedef extensions::APIPermission::ID param_type;
static void GetSize(base::PickleSizer* s, const param_type& p);
static void Write(base::Pickle* m, const param_type& p);
static bool Read(const base::Pickle* m,
base::PickleIterator* iter,
param_type* p);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<extensions::APIPermissionSet> {
typedef extensions::APIPermissionSet param_type;
static void GetSize(base::PickleSizer* s, const param_type& p);
static void Write(base::Pickle* m, const param_type& p);
static bool Read(const base::Pickle* m,
base::PickleIterator* iter,
param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<extensions::ManifestPermissionSet> {
typedef extensions::ManifestPermissionSet param_type;
static void GetSize(base::PickleSizer* s, const param_type& p);
static void Write(base::Pickle* m, const param_type& p);
static bool Read(const base::Pickle* m,
base::PickleIterator* iter,
param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<HostID> {
typedef HostID param_type;
static void GetSize(base::PickleSizer* s, const param_type& p);
static void Write(base::Pickle* m, const param_type& p);
static bool Read(const base::Pickle* m,
base::PickleIterator* iter,
param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<ExtensionMsg_PermissionSetStruct> {
typedef ExtensionMsg_PermissionSetStruct param_type;
static void GetSize(base::PickleSizer* s, const param_type& p);
static void Write(base::Pickle* m, const param_type& p);
static bool Read(const base::Pickle* m,
base::PickleIterator* iter,
param_type* p);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<ExtensionMsg_Loaded_Params> {
typedef ExtensionMsg_Loaded_Params param_type;
static void Write(base::Pickle* m, const param_type& p);
static bool Read(const base::Pickle* m,
base::PickleIterator* iter,
param_type* p);
static void Log(const param_type& p, std::string* l);
};
} // namespace IPC
#endif // EXTENSIONS_COMMON_EXTENSION_MESSAGES_H_
IPC_ENUM_TRAITS_MAX_VALUE(
ExtensionHostMsg_AutomationQuerySelector_Error::Value,
ExtensionHostMsg_AutomationQuerySelector_Error::kNodeDestroyed)
IPC_STRUCT_TRAITS_BEGIN(ExtensionHostMsg_AutomationQuerySelector_Error)
IPC_STRUCT_TRAITS_MEMBER(value)
IPC_STRUCT_TRAITS_END()
// Parameters structure for ExtensionMsg_UpdatePermissions.
IPC_STRUCT_BEGIN(ExtensionMsg_UpdatePermissions_Params)
IPC_STRUCT_MEMBER(std::string, extension_id)
IPC_STRUCT_MEMBER(ExtensionMsg_PermissionSetStruct, active_permissions)
IPC_STRUCT_MEMBER(ExtensionMsg_PermissionSetStruct, withheld_permissions)
IPC_STRUCT_END()
// Messages sent from the browser to the renderer:
// The browser sends this message in response to all extension api calls. The
// response data (if any) is one of the base::Value subclasses, wrapped as the
// first element in a ListValue.
IPC_MESSAGE_ROUTED4(ExtensionMsg_Response,
int /* request_id */,
bool /* success */,
base::ListValue /* response wrapper (see comment above) */,
std::string /* error */)
// This message is optionally routed. If used as a control message, it will
// call a javascript function |function_name| from module |module_name| in
// every registered context in the target process. If routed, it will be
// restricted to the contexts that are part of the target RenderView.
//
// If |extension_id| is non-empty, the function will be invoked only in
// contexts owned by the extension. |args| is a list of primitive Value types
// that are passed to the function.
IPC_MESSAGE_ROUTED5(ExtensionMsg_MessageInvoke,
std::string /* extension_id */,
std::string /* module_name */,
std::string /* function_name */,
base::ListValue /* args */,
bool /* delivered as part of a user gesture */)
// Set the top-level frame to the provided name.
IPC_MESSAGE_ROUTED1(ExtensionMsg_SetFrameName,
std::string /* frame_name */)
// Tell the renderer process the platforms system font.
IPC_MESSAGE_CONTROL2(ExtensionMsg_SetSystemFont,
std::string /* font_family */,
std::string /* font_size */)
// Marks an extension as 'active' in an extension process. 'Active' extensions
// have more privileges than other extension content that might end up running
// in the process (e.g. because of iframes or content scripts).
IPC_MESSAGE_CONTROL1(ExtensionMsg_ActivateExtension,
std::string /* extension_id */)
// Notifies the renderer that extensions were loaded in the browser.
IPC_MESSAGE_CONTROL1(ExtensionMsg_Loaded,
std::vector<ExtensionMsg_Loaded_Params>)
// Notifies the renderer that an extension was unloaded in the browser.
IPC_MESSAGE_CONTROL1(ExtensionMsg_Unloaded,
std::string)
// Updates the scripting whitelist for extensions in the render process. This is
// only used for testing.
IPC_MESSAGE_CONTROL1(ExtensionMsg_SetScriptingWhitelist,
// extension ids
extensions::ExtensionsClient::ScriptingWhitelist)
// Notification that renderer should run some JavaScript code.
IPC_MESSAGE_ROUTED1(ExtensionMsg_ExecuteCode,
ExtensionMsg_ExecuteCode_Params)
// Notification that the user scripts have been updated. It has one
// SharedMemoryHandle argument consisting of the pickled script data. This
// handle is valid in the context of the renderer.
// If |owner| is not empty, then the shared memory handle refers to |owner|'s
// programmatically-defined scripts. Otherwise, the handle refers to all
// hosts' statically defined scripts. So far, only extension-hosts support
// statically defined scripts; WebUI-hosts don't.
// If |changed_hosts| is not empty, only the host in that set will
// be updated. Otherwise, all hosts that have scripts in the shared memory
// region will be updated. Note that the empty set => all hosts case is not
// supported for per-extension programmatically-defined script regions; in such
// regions, the owner is expected to list itself as the only changed host.
// If |whitelisted_only| is true, this process should only run whitelisted
// scripts and not all user scripts.
IPC_MESSAGE_CONTROL4(ExtensionMsg_UpdateUserScripts,
base::SharedMemoryHandle,
HostID /* owner */,
std::set<HostID> /* changed hosts */,
bool /* whitelisted_only */)
// Trigger to execute declarative content script under browser control.
IPC_MESSAGE_ROUTED4(ExtensionMsg_ExecuteDeclarativeScript,
int /* tab identifier */,
extensions::ExtensionId /* extension identifier */,
int /* script identifier */,
GURL /* page URL where script should be injected */)
// Tell the render view which browser window it's being attached to.
IPC_MESSAGE_ROUTED1(ExtensionMsg_UpdateBrowserWindowId,
int /* id of browser window */)
// Tell the render view what its tab ID is.
IPC_MESSAGE_ROUTED1(ExtensionMsg_SetTabId,
int /* id of tab */)
// Tell the renderer to update an extension's permission set.
IPC_MESSAGE_CONTROL1(ExtensionMsg_UpdatePermissions,
ExtensionMsg_UpdatePermissions_Params)
// Tell the render view about new tab-specific permissions for an extension.
IPC_MESSAGE_CONTROL5(ExtensionMsg_UpdateTabSpecificPermissions,
GURL /* url */,
std::string /* extension_id */,
extensions::URLPatternSet /* hosts */,
bool /* update origin whitelist */,
int /* tab_id */)
// Tell the render view to clear tab-specific permissions for some extensions.
IPC_MESSAGE_CONTROL3(ExtensionMsg_ClearTabSpecificPermissions,
std::vector<std::string> /* extension_ids */,
bool /* update origin whitelist */,
int /* tab_id */)
// Tell the renderer which type this view is.
IPC_MESSAGE_ROUTED1(ExtensionMsg_NotifyRenderViewType,
extensions::ViewType /* view_type */)
// Deliver a message sent with ExtensionHostMsg_PostMessage.
IPC_MESSAGE_CONTROL1(ExtensionMsg_UsingWebRequestAPI,
bool /* webrequest_used */)
// The browser's response to the ExtensionMsg_WakeEventPage IPC.
IPC_MESSAGE_CONTROL2(ExtensionMsg_WakeEventPageResponse,
int /* request_id */,
bool /* success */)
// Ask the lazy background page if it is ready to be suspended. This is sent
// when the page is considered idle. The renderer will reply with the same
// sequence_id so that we can tell which message it is responding to.
IPC_MESSAGE_CONTROL2(ExtensionMsg_ShouldSuspend,
std::string /* extension_id */,
uint64_t /* sequence_id */)
// If we complete a round of ShouldSuspend->ShouldSuspendAck messages without
// the lazy background page becoming active again, we are ready to unload. This
// message tells the page to dispatch the suspend event.
IPC_MESSAGE_CONTROL1(ExtensionMsg_Suspend,
std::string /* extension_id */)
// The browser changed its mind about suspending this extension.
IPC_MESSAGE_CONTROL1(ExtensionMsg_CancelSuspend,
std::string /* extension_id */)
// Response to the renderer for ExtensionHostMsg_GetAppInstallState.
IPC_MESSAGE_ROUTED2(ExtensionMsg_GetAppInstallStateResponse,
std::string /* state */,
int32_t /* callback_id */)
// Check whether the Port for extension messaging exists in the frame. If the
// port ID is unknown, the frame replies with ExtensionHostMsg_CloseMessagePort.
IPC_MESSAGE_ROUTED1(ExtensionMsg_ValidateMessagePort,
int /* port_id */)
// Dispatch the Port.onConnect event for message channels.
IPC_MESSAGE_ROUTED5(ExtensionMsg_DispatchOnConnect,
int /* target_port_id */,
std::string /* channel_name */,
ExtensionMsg_TabConnectionInfo /* source */,
ExtensionMsg_ExternalConnectionInfo,
std::string /* tls_channel_id */)
// Deliver a message sent with ExtensionHostMsg_PostMessage.
IPC_MESSAGE_ROUTED3(ExtensionMsg_DeliverMessage,
int /* target_port_id */,
int /* source_tab_id */,
extensions::Message)
// Dispatch the Port.onDisconnect event for message channels.
IPC_MESSAGE_ROUTED2(ExtensionMsg_DispatchOnDisconnect,
int /* port_id */,
std::string /* error_message */)
// Informs the renderer what channel (dev, beta, stable, etc) is running.
IPC_MESSAGE_CONTROL1(ExtensionMsg_SetChannel,
version_info::Channel /* channel */)
// Notify the renderer that its window has closed.
IPC_MESSAGE_ROUTED0(ExtensionMsg_AppWindowClosed)
// Notify the renderer that an extension wants notifications when certain
// searches match the active page. This message replaces the old set of
// searches, and triggers ExtensionHostMsg_OnWatchedPageChange messages from
// each tab to keep the browser updated about changes.
IPC_MESSAGE_CONTROL1(ExtensionMsg_WatchPages,
std::vector<std::string> /* CSS selectors */)
// Send by the browser to indicate a Blob handle has been transferred to the
// renderer. This is sent after the actual extension response, and depends on
// the sequential nature of IPCs so that the blob has already been caught.
// This is a separate control message, so that the renderer process will send
// an acknowledgement even if the RenderView has closed or navigated away.
IPC_MESSAGE_CONTROL1(ExtensionMsg_TransferBlobs,
std::vector<std::string> /* blob_uuids */)
// Report the WebView partition ID to the WebView guest renderer process.
IPC_MESSAGE_CONTROL1(ExtensionMsg_SetWebViewPartitionID,
std::string /* webview_partition_id */)
// Messages sent from the renderer to the browser:
// A renderer sends this message when an extension process starts an API
// request. The browser will always respond with a ExtensionMsg_Response.
IPC_MESSAGE_ROUTED1(ExtensionHostMsg_Request,
ExtensionHostMsg_Request_Params)
// A renderer sends this message when an extension process starts an API
// request. The browser will always respond with a ExtensionMsg_Response.
IPC_MESSAGE_CONTROL2(ExtensionHostMsg_RequestForIOThread,
int /* routing_id */,
ExtensionHostMsg_Request_Params)
// Notify the browser that the given extension added a listener to an event.
IPC_MESSAGE_CONTROL3(ExtensionHostMsg_AddListener,
std::string /* extension_id */,
GURL /* listener_url */,
std::string /* name */)
// Notify the browser that the given extension removed a listener from an
// event.
IPC_MESSAGE_CONTROL3(ExtensionHostMsg_RemoveListener,
std::string /* extension_id */,
GURL /* listener_url */,
std::string /* name */)
// Notify the browser that the given extension added a listener to an event from
// a lazy background page.
IPC_MESSAGE_CONTROL2(ExtensionHostMsg_AddLazyListener,
std::string /* extension_id */,
std::string /* name */)
// Notify the browser that the given extension is no longer interested in
// receiving the given event from a lazy background page.
IPC_MESSAGE_CONTROL2(ExtensionHostMsg_RemoveLazyListener,
std::string /* extension_id */,
std::string /* name */)
// Notify the browser that the given extension added a listener to instances of
// the named event that satisfy the filter.
IPC_MESSAGE_CONTROL4(ExtensionHostMsg_AddFilteredListener,
std::string /* extension_id */,
std::string /* name */,
base::DictionaryValue /* filter */,
bool /* lazy */)
// Notify the browser that the given extension is no longer interested in
// instances of the named event that satisfy the filter.
IPC_MESSAGE_CONTROL4(ExtensionHostMsg_RemoveFilteredListener,
std::string /* extension_id */,
std::string /* name */,
base::DictionaryValue /* filter */,
bool /* lazy */)
// Notify the browser that an event has finished being dispatched.
IPC_MESSAGE_ROUTED1(ExtensionHostMsg_EventAck, int /* message_id */)
// Open a channel to all listening contexts owned by the extension with
// the given ID. This always returns a valid port ID which can be used for
// sending messages. If an error occurred, the opener will be notified
// asynchronously.
IPC_SYNC_MESSAGE_CONTROL4_1(ExtensionHostMsg_OpenChannelToExtension,
int /* frame_routing_id */,
ExtensionMsg_ExternalConnectionInfo,
std::string /* channel_name */,
bool /* include_tls_channel_id */,
int /* port_id */)
IPC_SYNC_MESSAGE_CONTROL2_1(ExtensionHostMsg_OpenChannelToNativeApp,
int /* frame_routing_id */,
std::string /* native_app_name */,
int /* port_id */)
// Get a port handle to the given tab. The handle can be used for sending
// messages to the extension.
IPC_SYNC_MESSAGE_CONTROL4_1(ExtensionHostMsg_OpenChannelToTab,
int /* frame_routing_id */,
ExtensionMsg_TabTargetConnectionInfo,
std::string /* extension_id */,
std::string /* channel_name */,
int /* port_id */)
// Sent in response to ExtensionMsg_DispatchOnConnect when the port is accepted.
// The handle is the value returned by ExtensionHostMsg_OpenChannelTo*.
IPC_MESSAGE_CONTROL2(ExtensionHostMsg_OpenMessagePort,
int /* frame_routing_id */,
int /* port_id */)
// Sent in response to ExtensionMsg_DispatchOnConnect and whenever the port is
// closed. The handle is the value returned by ExtensionHostMsg_OpenChannelTo*.
IPC_MESSAGE_CONTROL3(ExtensionHostMsg_CloseMessagePort,
int /* frame_routing_id */,
int /* port_id */,
bool /* force_close */)
// Send a message to an extension process. The handle is the value returned
// by ExtensionHostMsg_OpenChannelTo*.
IPC_MESSAGE_ROUTED2(ExtensionHostMsg_PostMessage,
int /* port_id */,
extensions::Message)
// Used to get the extension message bundle.
IPC_SYNC_MESSAGE_CONTROL1_1(ExtensionHostMsg_GetMessageBundle,
std::string /* extension id */,
SubstitutionMap /* message bundle */)
// Sent from the renderer to the browser to return the script running result.
IPC_MESSAGE_ROUTED4(
ExtensionHostMsg_ExecuteCodeFinished,
int /* request id */,
std::string /* error; empty implies success */,
GURL /* URL of the code executed on. May be empty if unsuccessful. */,
base::ListValue /* result of the script */)
// Sent from the renderer to the browser to notify that content scripts are
// running in the renderer that the IPC originated from.
IPC_MESSAGE_ROUTED2(ExtensionHostMsg_ContentScriptsExecuting,
ExecutingScriptsMap,
GURL /* url of the _topmost_ frame */)
// Sent from the renderer to the browser to request permission for a script
// injection.
// If request id is -1, this signals that the request has already ran, and this
// merely serves as a notification. This happens when the feature to disable
// scripts running without user consent is not enabled.
IPC_MESSAGE_ROUTED4(ExtensionHostMsg_RequestScriptInjectionPermission,
std::string /* extension id */,
extensions::UserScript::InjectionType /* script type */,
extensions::UserScript::RunLocation /* run location */,
int64_t /* request id */)
// Sent from the browser to the renderer in reply to a
// RequestScriptInjectionPermission message, granting permission for a script
// script to run.
IPC_MESSAGE_ROUTED1(ExtensionMsg_PermitScriptInjection,
int64_t /* request id */)
// Sent by the renderer when a web page is checking if its app is installed.
IPC_MESSAGE_ROUTED3(ExtensionHostMsg_GetAppInstallState,
GURL /* requestor_url */,
int32_t /* return_route_id */,
int32_t /* callback_id */)
// Optional Ack message sent to the browser to notify that the response to a
// function has been processed.
IPC_MESSAGE_ROUTED1(ExtensionHostMsg_ResponseAck,
int /* request_id */)
// Response to ExtensionMsg_ShouldSuspend.
IPC_MESSAGE_CONTROL2(ExtensionHostMsg_ShouldSuspendAck,
std::string /* extension_id */,
uint64_t /* sequence_id */)
// Response to ExtensionMsg_Suspend, after we dispatch the suspend event.
IPC_MESSAGE_CONTROL1(ExtensionHostMsg_SuspendAck,
std::string /* extension_id */)
// Informs the browser to increment the keepalive count for the lazy background
// page, keeping it alive.
IPC_MESSAGE_ROUTED0(ExtensionHostMsg_IncrementLazyKeepaliveCount)
// Informs the browser there is one less thing keeping the lazy background page
// alive.
IPC_MESSAGE_ROUTED0(ExtensionHostMsg_DecrementLazyKeepaliveCount)
// Fetches a globally unique ID (for the lifetime of the browser) from the
// browser process.
IPC_SYNC_MESSAGE_CONTROL0_1(ExtensionHostMsg_GenerateUniqueID,
int /* unique_id */)
// Notify the browser that an app window is ready and can resume resource
// requests.
IPC_MESSAGE_CONTROL1(ExtensionHostMsg_AppWindowReady, int /* route_id */)
// Sent by the renderer when the draggable regions are updated.
IPC_MESSAGE_ROUTED1(ExtensionHostMsg_UpdateDraggableRegions,
std::vector<extensions::DraggableRegion> /* regions */)
// Sent by the renderer to log an API action to the extension activity log.
IPC_MESSAGE_CONTROL2(ExtensionHostMsg_AddAPIActionToActivityLog,
std::string /* extension_id */,
ExtensionHostMsg_APIActionOrEvent_Params)
// Sent by the renderer to log an event to the extension activity log.
IPC_MESSAGE_CONTROL2(ExtensionHostMsg_AddEventToActivityLog,
std::string /* extension_id */,
ExtensionHostMsg_APIActionOrEvent_Params)
// Sent by the renderer to log a DOM action to the extension activity log.
IPC_MESSAGE_CONTROL2(ExtensionHostMsg_AddDOMActionToActivityLog,
std::string /* extension_id */,
ExtensionHostMsg_DOMAction_Params)
// Notifies the browser process that a tab has started or stopped matching
// certain conditions. This message is sent in response to several events:
//
// * ExtensionMsg_WatchPages was received, updating the set of conditions.
// * A new page is loaded. This will be sent after
// FrameHostMsg_DidCommitProvisionalLoad. Currently this only fires for the
// main frame.
// * Something changed on an existing frame causing the set of matching searches
// to change.
IPC_MESSAGE_ROUTED1(ExtensionHostMsg_OnWatchedPageChange,
std::vector<std::string> /* Matching CSS selectors */)
// Sent by the renderer when it has received a Blob handle from the browser.
IPC_MESSAGE_CONTROL1(ExtensionHostMsg_TransferBlobsAck,
std::vector<std::string> /* blob_uuids */)
// Asks the browser to wake the event page of an extension.
// The browser will reply with ExtensionHostMsg_WakeEventPageResponse.
IPC_MESSAGE_CONTROL2(ExtensionHostMsg_WakeEventPage,
int /* request_id */,
std::string /* extension_id */)
// Tells listeners that a detailed message was reported to the console by
// WebKit.
IPC_MESSAGE_ROUTED4(ExtensionHostMsg_DetailedConsoleMessageAdded,
base::string16 /* message */,
base::string16 /* source */,
extensions::StackTrace /* stack trace */,
int32_t /* severity level */)
// Sent when a query selector request is made from the automation API.
// acc_obj_id is the accessibility tree ID of the starting element.
IPC_MESSAGE_ROUTED3(ExtensionMsg_AutomationQuerySelector,
int /* request_id */,
int /* acc_obj_id */,
base::string16 /* selector */)
// Result of a query selector request.
// result_acc_obj_id is the accessibility tree ID of the result element; 0
// indicates no result.
IPC_MESSAGE_ROUTED3(ExtensionHostMsg_AutomationQuerySelector_Result,
int /* request_id */,
ExtensionHostMsg_AutomationQuerySelector_Error /* error */,
int /* result_acc_obj_id */)
// Tells the renderer whether or not activity logging is enabled. This is only
// sent if logging is or was previously enabled; not being enabled is assumed
// otherwise.
IPC_MESSAGE_CONTROL1(ExtensionMsg_SetActivityLoggingEnabled, bool /* enabled */)
// Messages related to Extension Service Worker.
#undef IPC_MESSAGE_START
#define IPC_MESSAGE_START ExtensionWorkerMsgStart
// A service worker thread sends this message when an extension service worker
// starts an API request. The browser will always respond with a
// ExtensionMsg_ResponseWorker.
IPC_MESSAGE_CONTROL1(ExtensionHostMsg_RequestWorker,
ExtensionHostMsg_Request_Params)
// The browser sends this message in response to all service worker extension
// api calls. The response data (if any) is one of the base::Value subclasses,
// wrapped as the first element in a ListValue.
IPC_MESSAGE_CONTROL5(ExtensionMsg_ResponseWorker,
int /* thread_id */,
int /* request_id */,
bool /* success */,
base::ListValue /* response wrapper (see comment above) */,
std::string /* error */)