// 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 #include #include #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/features/feature_session_type.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) IPC_ENUM_TRAITS_MAX_VALUE(extensions::FeatureSessionType, extensions::FeatureSessionType::LAST) // 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 service // worker version id. Otherwise, this is -1. IPC_STRUCT_MEMBER(int64_t, service_worker_version_id) IPC_STRUCT_END() IPC_STRUCT_BEGIN(ExtensionMsg_DispatchEvent_Params) // The id of the extension to dispatch the event to. IPC_STRUCT_MEMBER(std::string, extension_id) // The name of the event to dispatch. IPC_STRUCT_MEMBER(std::string, event_name) // The id of the event for use in the EventAck response message. IPC_STRUCT_MEMBER(int, event_id) // Whether or not the event is part of a user gesture. IPC_STRUCT_MEMBER(bool, is_user_gesture) // Additional filtering info for the event. IPC_STRUCT_MEMBER(base::DictionaryValue, filtering_info) 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 . 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_MEMBER(interface_class()) 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 SubstitutionMap; // Map of extensions IDs to the executing script paths. typedef std::map > ExecutingScriptsMap; struct ExtensionMsg_PermissionSetStruct { ExtensionMsg_PermissionSetStruct(); explicit ExtensionMsg_PermissionSetStruct( const extensions::PermissionSet& permissions); ExtensionMsg_PermissionSetStruct( const ExtensionMsg_PermissionSetStruct& other); ~ExtensionMsg_PermissionSetStruct(); std::unique_ptr 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 ConvertToExtension( std::string* error) const; // The subset of the extension manifest data we send to renderers. linked_ptr 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 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 */) // Sent to the renderer to dispatch an event to an extension. // Note: |event_args| is separate from the params to avoid having the message // take ownership. IPC_MESSAGE_CONTROL2(ExtensionMsg_DispatchEvent, ExtensionMsg_DispatchEvent_Params /* params */, base::ListValue /* event_args */) // 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_ROUTED4(ExtensionMsg_MessageInvoke, std::string /* extension_id */, std::string /* module_name */, std::string /* function_name */, base::ListValue /* args */) // 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) // 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 /* 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 /* 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 */) // 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) and user session // type is running. IPC_MESSAGE_CONTROL2(ExtensionMsg_SetSessionInfo, version_info::Channel /* channel */, extensions::FeatureSessionType /* session_type */) // 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 /* 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 /* 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 responds asynchronously with ExtensionMsg_AssignPortId. // If an error occurred, the opener will be notified asynchronously. IPC_MESSAGE_CONTROL5(ExtensionHostMsg_OpenChannelToExtension, int /* frame_routing_id */, ExtensionMsg_ExternalConnectionInfo, std::string /* channel_name */, bool /* include_tls_channel_id */, int /* request_id */) // Same as ExtensionHostMsg_OpenChannelToExtension, but assigns the port id // synchronously. IPC_SYNC_MESSAGE_CONTROL4_1(ExtensionHostMsg_OpenChannelToExtensionSync, int /* frame_routing_id */, ExtensionMsg_ExternalConnectionInfo, std::string /* channel_name */, bool /* include_tls_channel_id */, int /* port_id */) // The response to a request to open an extension message port, including the // global port id and the request id. IPC_MESSAGE_ROUTED2(ExtensionMsg_AssignPortId, int /*port_id */, int /* request_id */) IPC_MESSAGE_CONTROL3(ExtensionHostMsg_OpenChannelToNativeApp, int /* frame_routing_id */, std::string /* native_app_name */, int /* request_id */) // Get a port handle to the given tab. The handle can be used for sending // messages to the extension. IPC_MESSAGE_CONTROL5(ExtensionHostMsg_OpenChannelToTab, int /* frame_routing_id */, ExtensionMsg_TabTargetConnectionInfo, std::string /* extension_id */, std::string /* channel_name */, int /* request_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 /* 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 /* Matching CSS selectors */) // Sent by the renderer when it has received a Blob handle from the browser. IPC_MESSAGE_CONTROL1(ExtensionHostMsg_TransferBlobsAck, std::vector /* 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 */) // Asks the browser to increment the pending activity count for // the worker with version id |service_worker_version_id|. // Each request to increment must use unique |request_uuid|. If a request with // |request_uuid| is already in progress (due to race condition or renderer // compromise), browser process ignores the IPC. IPC_MESSAGE_CONTROL2(ExtensionHostMsg_IncrementServiceWorkerActivity, int64_t /* service_worker_version_id */, std::string /* request_uuid */) // Asks the browser to decrement the pending activity count for // the worker with version id |service_worker_version_id|. // |request_uuid| must match the GUID of a previous request, otherwise the // browser process ignores the IPC. IPC_MESSAGE_CONTROL2(ExtensionHostMsg_DecrementServiceWorkerActivity, int64_t /* service_worker_version_id */, std::string /* request_uuid */)