Google Git
Sign in
ara-mdk / platform / external / chromium / 28d70d1c88bc8a94e9a6608d68678895e6ea483b / . / chrome / common / render_messages_internal.h
blob: b3e2b53ded240f7c58787ad6b6e846d43ce3b03b [file] [log] [blame]
// Copyright (c) 2010 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.
// This header is meant to be included in multiple passes, hence no traditional
// header guard.
// See ipc_message_macros.h for explanation of the macros and passes.
#include <map>
#include <string>
#include <vector>
#include "build/build_config.h"
#include "base/file_path.h"
#include "base/nullable_string16.h"
#include "base/platform_file.h"
#include "base/sync_socket.h"
#include "chrome/common/content_settings.h"
#include "chrome/common/geoposition.h"
#include "chrome/common/nacl_types.h"
#include "chrome/common/notification_type.h"
#include "chrome/common/page_zoom.h"
#include "chrome/common/translate_errors.h"
#include "chrome/common/window_container_type.h"
#include "ipc/ipc_message_macros.h"
#include "media/audio/audio_buffers_state.h"
#if defined(OS_POSIX)
#include "base/file_descriptor_posix.h"
#endif
#if defined(OS_MACOSX)
#include "chrome/common/font_descriptor_mac.h"
#endif
// TODO(mpcomplete): rename ViewMsg and ViewHostMsg to something that makes
// more sense with our current design.
// 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;
class GPUInfo;
class SerializedScriptValue;
class SkBitmap;
struct ThumbnailScore;
class WebCursor;
namespace base {
namespace file_util_proxy {
struct Entry;
}
}
namespace IPC {
struct ChannelHandle;
class Message;
}
namespace webkit_blob {
class BlobData;
}
namespace file_util {
struct FileInfo;
}
//-----------------------------------------------------------------------------
// RenderView messages
// These are messages sent from the browser to the renderer process.
IPC_BEGIN_MESSAGES(View)
// Used typically when recovering from a crash. The new rendering process
// sets its global "next page id" counter to the given value.
IPC_MESSAGE_CONTROL1(ViewMsg_SetNextPageID,
int32 /* next_page_id */)
// Sends System Colors corresponding to a set of CSS color keywords
// down the pipe.
// This message must be sent to the renderer immediately on launch
// before creating any new views.
// The message can also be sent during a renderer's lifetime if system colors
// are updated.
// TODO(jeremy): Possibly change IPC format once we have this all hooked up.
IPC_MESSAGE_ROUTED1(ViewMsg_SetCSSColors,
std::vector<CSSColors::CSSColorMapping>)
// Tells the renderer to create a new view.
// This message is slightly different, the view it takes (via
// ViewMsg_New_Params) is the view to create, the message itself is sent as a
// non-view control message.
IPC_MESSAGE_CONTROL1(ViewMsg_New,
ViewMsg_New_Params)
// Tells the renderer to set its maximum cache size to the supplied value
IPC_MESSAGE_CONTROL3(ViewMsg_SetCacheCapacities,
size_t /* min_dead_capacity */,
size_t /* max_dead_capacity */,
size_t /* capacity */)
// Reply in response to ViewHostMsg_ShowView or ViewHostMsg_ShowWidget.
// similar to the new command, but used when the renderer created a view
// first, and we need to update it
IPC_MESSAGE_ROUTED1(ViewMsg_CreatingNew_ACK,
gfx::NativeViewId /* parent_hwnd */)
// Sends updated preferences to the renderer.
IPC_MESSAGE_ROUTED1(ViewMsg_SetRendererPrefs,
RendererPreferences)
// Tells the renderer to perform the given action on the media player
// located at the given point.
IPC_MESSAGE_ROUTED2(ViewMsg_MediaPlayerActionAt,
gfx::Point, /* location */
WebKit::WebMediaPlayerAction)
// Tells the render view to close.
IPC_MESSAGE_ROUTED0(ViewMsg_Close)
// Tells the render view to change its size. A ViewHostMsg_PaintRect message
// is generated in response provided new_size is not empty and not equal to
// the view's current size. The generated ViewHostMsg_PaintRect message will
// have the IS_RESIZE_ACK flag set. It also receives the resizer rect so that
// we don't have to fetch it every time WebKit asks for it.
IPC_MESSAGE_ROUTED2(ViewMsg_Resize,
gfx::Size /* new_size */,
gfx::Rect /* resizer_rect */)
// Sent to inform the view that it was hidden. This allows it to reduce its
// resource utilization.
IPC_MESSAGE_ROUTED0(ViewMsg_WasHidden)
// Tells the render view that it is no longer hidden (see WasHidden), and the
// render view is expected to respond with a full repaint if needs_repainting
// is true. In that case, the generated ViewHostMsg_PaintRect message will
// have the IS_RESTORE_ACK flag set. If needs_repainting is false, then this
// message does not trigger a message in response.
IPC_MESSAGE_ROUTED1(ViewMsg_WasRestored,
bool /* needs_repainting */)
// Tells the render view to capture a thumbnail image of the page. The
// render view responds with a ViewHostMsg_Thumbnail.
IPC_MESSAGE_ROUTED0(ViewMsg_CaptureThumbnail)
// Tells the render view to capture a thumbnail image of the page. The
// render view responds with a ViewHostMsg_Snapshot.
IPC_MESSAGE_ROUTED0(ViewMsg_CaptureSnapshot)
// Tells the render view to switch the CSS to print media type, renders every
// requested pages and switch back the CSS to display media type.
IPC_MESSAGE_ROUTED0(ViewMsg_PrintPages)
// Tells the render view that printing is done so it can clean up.
IPC_MESSAGE_ROUTED2(ViewMsg_PrintingDone,
int /* document_cookie */,
bool /* success */)
// Tells the renderer to dump as much memory as it can, perhaps because we
// have memory pressure or the renderer is (or will be) paged out. This
// should only result in purging objects we can recalculate, e.g. caches or
// JS garbage, not in purging irreplaceable objects.
IPC_MESSAGE_CONTROL0(ViewMsg_PurgeMemory)
// Sent to render the view into the supplied transport DIB, resize
// the web widget to match the |page_size|, scale it by the
// appropriate scale to make it fit the |desired_size|, and return
// it. In response to this message, the host generates a
// ViewHostMsg_PaintAtSize_ACK message. Note that the DIB *must* be
// the right size to receive an RGBA image at the |desired_size|.
// |tag| is sent along with ViewHostMsg_PaintAtSize_ACK unmodified to
// identify the PaintAtSize message the ACK belongs to.
IPC_MESSAGE_ROUTED4(ViewMsg_PaintAtSize,
TransportDIB::Handle /* dib_handle */,
int /* tag */,
gfx::Size /* page_size */,
gfx::Size /* desired_size */)
// Tells the render view that a ViewHostMsg_UpdateRect message was processed.
// This signals the render view that it can send another UpdateRect message.
IPC_MESSAGE_ROUTED0(ViewMsg_UpdateRect_ACK)
// Replies to creating and updating videos.
IPC_MESSAGE_ROUTED1(ViewMsg_CreateVideo_ACK,
int32 /* video_id */)
IPC_MESSAGE_ROUTED1(ViewMsg_UpdateVideo_ACK,
int32 /* video_id */)
// Message payload includes:
// 1. A blob that should be cast to WebInputEvent
// 2. An optional boolean value indicating if a RawKeyDown event is associated
// to a keyboard shortcut of the browser.
IPC_MESSAGE_ROUTED0(ViewMsg_HandleInputEvent)
// This message notifies the renderer that the next key event is bound to one
// or more pre-defined edit commands. If the next key event is not handled
// by webkit, the specified edit commands shall be executed against current
// focused frame.
// Parameters
// * edit_commands (see chrome/common/edit_command_types.h)
// Contains one or more edit commands.
// See third_party/WebKit/WebCore/editing/EditorCommand.cpp for detailed
// definition of webkit edit commands.
//
// This message must be sent just before sending a key event.
IPC_MESSAGE_ROUTED1(ViewMsg_SetEditCommandsForNextKeyEvent,
std::vector<EditCommand> /* edit_commands */)
// Message payload is the name/value of a WebCore edit command to execute.
IPC_MESSAGE_ROUTED2(ViewMsg_ExecuteEditCommand,
std::string, /* name */
std::string /* value */)
IPC_MESSAGE_ROUTED0(ViewMsg_MouseCaptureLost)
// TODO(darin): figure out how this meshes with RestoreFocus
IPC_MESSAGE_ROUTED1(ViewMsg_SetFocus, bool /* enable */)
// Tells the renderer to focus the first (last if reverse is true) focusable
// node.
IPC_MESSAGE_ROUTED1(ViewMsg_SetInitialFocus, bool /* reverse */)
// Tells the renderer to perform the specified navigation, interrupting any
// existing navigation.
IPC_MESSAGE_ROUTED1(ViewMsg_Navigate, ViewMsg_Navigate_Params)
IPC_MESSAGE_ROUTED0(ViewMsg_Stop)
// Tells the renderer to reload the current focused frame
IPC_MESSAGE_ROUTED0(ViewMsg_ReloadFrame)
// This message notifies the renderer that the user has closed the FindInPage
// window (and what action to take regarding the selection).
IPC_MESSAGE_ROUTED1(ViewMsg_StopFinding,
ViewMsg_StopFinding_Params /* action */)
// These messages are typically generated from context menus and request the
// renderer to apply the specified operation to the current selection.
IPC_MESSAGE_ROUTED0(ViewMsg_Undo)
IPC_MESSAGE_ROUTED0(ViewMsg_Redo)
IPC_MESSAGE_ROUTED0(ViewMsg_Cut)
IPC_MESSAGE_ROUTED0(ViewMsg_Copy)
#if defined(OS_MACOSX)
IPC_MESSAGE_ROUTED0(ViewMsg_CopyToFindPboard)
#endif
IPC_MESSAGE_ROUTED0(ViewMsg_Paste)
// Replaces the selected region or a word around the cursor with the
// specified string.
IPC_MESSAGE_ROUTED1(ViewMsg_Replace, string16)
IPC_MESSAGE_ROUTED0(ViewMsg_ToggleSpellCheck)
IPC_MESSAGE_ROUTED0(ViewMsg_Delete)
IPC_MESSAGE_ROUTED0(ViewMsg_SelectAll)
IPC_MESSAGE_ROUTED1(ViewMsg_ToggleSpellPanel, bool)
// This message tells the renderer to advance to the next misspelling. It is
// sent when the user clicks the "Find Next" button on the spelling panel.
IPC_MESSAGE_ROUTED0(ViewMsg_AdvanceToNextMisspelling)
// Copies the image at location x, y to the clipboard (if there indeed is an
// image at that location).
IPC_MESSAGE_ROUTED2(ViewMsg_CopyImageAt,
int /* x */,
int /* y */)
// History system notification that the visited link database has been
// replaced. It has one SharedMemoryHandle argument consisting of the table
// handle. This handle is valid in the context of the renderer
IPC_MESSAGE_CONTROL1(ViewMsg_VisitedLink_NewTable, base::SharedMemoryHandle)
// History system notification that a link has been added and the link
// coloring state for the given hash must be re-calculated.
IPC_MESSAGE_CONTROL1(ViewMsg_VisitedLink_Add, std::vector<uint64>)
// History system notification that one or more history items have been
// deleted, which at this point means that all link coloring state must be
// re-calculated.
IPC_MESSAGE_CONTROL0(ViewMsg_VisitedLink_Reset)
// 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.
IPC_MESSAGE_CONTROL1(ViewMsg_UserScripts_UpdatedScripts,
base::SharedMemoryHandle)
// Sent when the user wants to search for a word on the page (find in page).
IPC_MESSAGE_ROUTED3(ViewMsg_Find,
int /* request_id */,
string16 /* search_text */,
WebKit::WebFindOptions)
// Send from the renderer to the browser to return the script running result.
IPC_MESSAGE_ROUTED2(ViewMsg_ExecuteCodeFinished,
int, /* request id */
bool /* whether the script ran successfully */)
// Sent when the headers are available for a resource request.
IPC_MESSAGE_ROUTED2(ViewMsg_Resource_ReceivedResponse,
int /* request_id */,
ResourceResponseHead)
// Sent when cached metadata from a resource request is ready.
IPC_MESSAGE_ROUTED2(ViewMsg_Resource_ReceivedCachedMetadata,
int /* request_id */,
std::vector<char> /* data */)
// Sent as upload progress is being made.
IPC_MESSAGE_ROUTED3(ViewMsg_Resource_UploadProgress,
int /* request_id */,
int64 /* position */,
int64 /* size */)
// Sent when the request has been redirected. The receiver is expected to
// respond with either a FollowRedirect message (if the redirect is to be
// followed) or a CancelRequest message (if it should not be followed).
IPC_MESSAGE_ROUTED3(ViewMsg_Resource_ReceivedRedirect,
int /* request_id */,
GURL /* new_url */,
ResourceResponseHead)
// Sent when some data from a resource request is ready. The handle should
// already be mapped into the process that receives this message.
IPC_MESSAGE_ROUTED3(ViewMsg_Resource_DataReceived,
int /* request_id */,
base::SharedMemoryHandle /* data */,
int /* data_len */)
// Sent when some data from a resource request has been downloaded to
// file. This is only called in the 'download_to_file' case and replaces
// ViewMsg_Resource_DataReceived in the call sequence in that case.
IPC_MESSAGE_ROUTED2(ViewMsg_Resource_DataDownloaded,
int /* request_id */,
int /* data_len */)
// Sent when the request has been completed.
IPC_MESSAGE_ROUTED4(ViewMsg_Resource_RequestComplete,
int /* request_id */,
URLRequestStatus /* status */,
std::string /* security info */,
base::Time /* completion_time */)
// Sent when user prompting is required before a ViewHostMsg_GetCookies
// message can complete. This message indicates that the renderer should
// pump messages while waiting for cookies.
IPC_MESSAGE_CONTROL0(ViewMsg_SignalCookiePromptEvent)
// Request for the renderer to evaluate an xpath to a frame and execute a
// javascript: url in that frame's context. The message is completely
// asynchronous and no corresponding response message is sent back.
//
// frame_xpath contains the modified xpath notation to identify an inner
// subframe (starting from the root frame). It is a concatenation of
// number of smaller xpaths delimited by '\n'. Each chunk in the string can
// be evaluated to a frame in its parent-frame's context.
//
// Example: /html/body/iframe/\n/html/body/div/iframe/\n/frameset/frame[0]
// can be broken into 3 xpaths
// /html/body/iframe evaluates to an iframe within the root frame
// /html/body/div/iframe evaluates to an iframe within the level-1 iframe
// /frameset/frame[0] evaluates to first frame within the level-2 iframe
//
// jscript_url is the string containing the javascript: url to be executed
// in the target frame's context. The string should start with "javascript:"
// and continue with a valid JS text.
IPC_MESSAGE_ROUTED2(ViewMsg_ScriptEvalRequest,
std::wstring, /* frame_xpath */
std::wstring /* jscript_url */)
// Request for the renderer to evaluate an xpath to a frame and insert css
// into that frame's document. See ViewMsg_ScriptEvalRequest for details on
// allowed xpath expressions.
IPC_MESSAGE_ROUTED3(ViewMsg_CSSInsertRequest,
std::wstring, /* frame_xpath */
std::string, /* css string */
std::string /* element id */)
// Log a message to the console of the target frame
IPC_MESSAGE_ROUTED3(ViewMsg_AddMessageToConsole,
string16 /* frame_xpath */,
string16 /* message */,
WebKit::WebConsoleMessage::Level /* message_level */)
// RenderViewHostDelegate::RenderViewCreated method sends this message to a
// new renderer to notify it that it will host developer tools UI and should
// set up all neccessary bindings and create DevToolsClient instance that
// will handle communication with inspected page DevToolsAgent.
IPC_MESSAGE_ROUTED0(ViewMsg_SetupDevToolsClient)
// Change the zoom level for the current main frame. If the level actually
// changes, a ViewHostMsg_DidZoomURL message will be sent back to the browser
// telling it what url got zoomed and what its current zoom level is.
IPC_MESSAGE_ROUTED1(ViewMsg_Zoom,
PageZoom::Function /* function */)
// Set the zoom level for a particular url that the renderer is in the
// process of loading. This will be stored, to be used if the load commits
// and ignored otherwise.
IPC_MESSAGE_ROUTED2(ViewMsg_SetZoomLevelForLoadingURL,
GURL /* url */,
int /* zoom_level */)
// Set the zoom level for a particular url, so all render views
// displaying this url can update their zoom levels to match.
IPC_MESSAGE_CONTROL2(ViewMsg_SetZoomLevelForCurrentURL,
GURL /* url */,
int /* zoom_level */)
// Set the content settings for a particular url that the renderer is in the
// process of loading. This will be stored, to be used if the load commits
// and ignored otherwise.
IPC_MESSAGE_ROUTED2(ViewMsg_SetContentSettingsForLoadingURL,
GURL /* url */,
ContentSettings /* content_settings */)
// Set the content settings for a particular url, so all render views
// displaying this host url update their content settings to match.
IPC_MESSAGE_CONTROL2(ViewMsg_SetContentSettingsForCurrentURL,
GURL /* url */,
ContentSettings /* content_settings */)
// Change encoding of page in the renderer.
IPC_MESSAGE_ROUTED1(ViewMsg_SetPageEncoding,
std::string /*new encoding name*/)
// Reset encoding of page in the renderer back to default.
IPC_MESSAGE_ROUTED0(ViewMsg_ResetPageEncodingToDefault)
// Requests the renderer to reserve a range of page ids.
IPC_MESSAGE_ROUTED1(ViewMsg_ReservePageIDRange,
int /* size_of_range */)
// Fill a form with data and optionally submit it
IPC_MESSAGE_ROUTED1(ViewMsg_FormFill,
webkit_glue::FormData /* form */)
// Fill a password form and prepare field autocomplete for multiple
// matching logins.
IPC_MESSAGE_ROUTED1(ViewMsg_FillPasswordForm,
webkit_glue::PasswordFormFillData)
// D&d drop target messages.
IPC_MESSAGE_ROUTED4(ViewMsg_DragTargetDragEnter,
WebDropData /* drop_data */,
gfx::Point /* client_pt */,
gfx::Point /* screen_pt */,
WebKit::WebDragOperationsMask /* ops_allowed */)
IPC_MESSAGE_ROUTED3(ViewMsg_DragTargetDragOver,
gfx::Point /* client_pt */,
gfx::Point /* screen_pt */,
WebKit::WebDragOperationsMask /* ops_allowed */)
IPC_MESSAGE_ROUTED0(ViewMsg_DragTargetDragLeave)
IPC_MESSAGE_ROUTED2(ViewMsg_DragTargetDrop,
gfx::Point /* client_pt */,
gfx::Point /* screen_pt */)
// Notifies the renderer of updates in mouse position of an in-progress
// drag. if |ended| is true, then the user has ended the drag operation.
IPC_MESSAGE_ROUTED4(ViewMsg_DragSourceEndedOrMoved,
gfx::Point /* client_pt */,
gfx::Point /* screen_pt */,
bool /* ended */,
WebKit::WebDragOperation /* drag_operation */)
// Notifies the renderer that the system DoDragDrop call has ended.
IPC_MESSAGE_ROUTED0(ViewMsg_DragSourceSystemDragEnded)
// Used to tell a render view whether it should expose various bindings
// that allow JS content extended privileges. See BindingsPolicy for valid
// flag values.
IPC_MESSAGE_ROUTED1(ViewMsg_AllowBindings,
int /* enabled_bindings_flags */)
// Tell the renderer to add a property to the DOMUI binding object. This
// only works if we allowed DOMUI bindings.
IPC_MESSAGE_ROUTED2(ViewMsg_SetDOMUIProperty,
std::string /* property_name */,
std::string /* property_value_json */)
// This message starts/stop monitoring the input method status of the focused
// edit control of a renderer process.
// Parameters
// * is_active (bool)
// Indicates if an input method is active in the browser process.
// The possible actions when a renderer process receives this message are
// listed below:
// Value Action
// true Start sending IPC message ViewHostMsg_ImeUpdateTextInputState
// to notify the input method status of the focused edit control.
// false Stop sending IPC message ViewHostMsg_ImeUpdateTextInputState.
IPC_MESSAGE_ROUTED1(ViewMsg_SetInputMethodActive,
bool /* is_active */)
// This message sends a string being composed with an input method.
IPC_MESSAGE_ROUTED4(
ViewMsg_ImeSetComposition,
string16, /* text */
std::vector<WebKit::WebCompositionUnderline>, /* underlines */
int, /* selectiont_start */
int /* selection_end */)
// This message confirms an ongoing composition.
IPC_MESSAGE_ROUTED0(ViewMsg_ImeConfirmComposition)
// This passes a set of webkit preferences down to the renderer.
IPC_MESSAGE_ROUTED1(ViewMsg_UpdateWebPreferences, WebPreferences)
// Used to notify the render-view that the browser has received a reply for
// the Find operation and is interested in receiving the next one. This is
// used to prevent the renderer from spamming the browser process with
// results.
IPC_MESSAGE_ROUTED0(ViewMsg_FindReplyACK)
// Used to notify the render-view that we have received a target URL. Used
// to prevent target URLs spamming the browser.
IPC_MESSAGE_ROUTED0(ViewMsg_UpdateTargetURL_ACK)
// Sets the alternate error page URL (link doctor) for the renderer process.
IPC_MESSAGE_ROUTED1(ViewMsg_SetAltErrorPageURL, GURL)
// Install the first missing pluign.
IPC_MESSAGE_ROUTED0(ViewMsg_InstallMissingPlugin)
// Tells the renderer to empty its plugin list cache, optional reloading
// pages containing plugins.
IPC_MESSAGE_CONTROL1(ViewMsg_PurgePluginListCache,
bool /* reload_pages */)
// Tells the render view to load all blocked plugins.
IPC_MESSAGE_ROUTED0(ViewMsg_LoadBlockedPlugins)
IPC_MESSAGE_ROUTED1(ViewMsg_RunFileChooserResponse,
std::vector<FilePath> /* selected files */)
// Used to instruct the RenderView to go into "view source" mode.
IPC_MESSAGE_ROUTED0(ViewMsg_EnableViewSourceMode)
// Get all savable resource links from current webpage, include main
// frame and sub-frame.
IPC_MESSAGE_ROUTED1(ViewMsg_GetAllSavableResourceLinksForCurrentPage,
GURL /* url of page which is needed to save */)
// Get html data by serializing all frames of current page with lists
// which contain all resource links that have local copy.
IPC_MESSAGE_ROUTED3(ViewMsg_GetSerializedHtmlDataForCurrentPageWithLocalLinks,
std::vector<GURL> /* urls that have local copy */,
std::vector<FilePath> /* paths of local copy */,
FilePath /* local directory path */)
// Requests application info for the page. The renderer responds back with
// ViewHostMsg_DidGetApplicationInfo.
IPC_MESSAGE_ROUTED1(ViewMsg_GetApplicationInfo, int32 /*page_id*/)
// Requests the renderer to download the specified favicon image encode it as
// PNG and send the PNG data back ala ViewHostMsg_DidDownloadFavIcon.
IPC_MESSAGE_ROUTED3(ViewMsg_DownloadFavIcon,
int /* identifier for the request */,
GURL /* URL of the image */,
int /* Size of the image. Normally 0, but set if you have
a preferred image size to request, such as when
downloading the favicon */)
// When a renderer sends a ViewHostMsg_Focus to the browser process,
// the browser has the option of sending a ViewMsg_CantFocus back to
// the renderer.
IPC_MESSAGE_ROUTED0(ViewMsg_CantFocus)
// Instructs the renderer to invoke the frame's shouldClose method, which
// runs the onbeforeunload event handler. Expects the result to be returned
// via ViewHostMsg_ShouldClose.
IPC_MESSAGE_ROUTED0(ViewMsg_ShouldClose)
// Instructs the renderer to close the current page, including running the
// onunload event handler. See the struct in render_messages.h for more.
//
// Expects a ClosePage_ACK message when finished, where the parameters are
// echoed back.
IPC_MESSAGE_ROUTED1(ViewMsg_ClosePage,
ViewMsg_ClosePage_Params)
// Asks the renderer to send back stats on the WebCore cache broken down by
// resource types.
IPC_MESSAGE_CONTROL0(ViewMsg_GetCacheResourceStats)
// Asks the renderer to send back Histograms.
IPC_MESSAGE_CONTROL1(ViewMsg_GetRendererHistograms,
int /* sequence number of Renderer Histograms. */)
#if defined(USE_TCMALLOC)
// Asks the renderer to send back tcmalloc stats.
IPC_MESSAGE_CONTROL0(ViewMsg_GetRendererTcmalloc)
#endif
// Asks the renderer to send back V8 heap stats.
IPC_MESSAGE_CONTROL0(ViewMsg_GetV8HeapStats)
// Notifies the renderer about ui theme changes
IPC_MESSAGE_ROUTED0(ViewMsg_ThemeChanged)
// Notifies the renderer that a paint is to be generated for the rectangle
// passed in.
IPC_MESSAGE_ROUTED1(ViewMsg_Repaint,
gfx::Size /* The view size to be repainted */)
// Posts a message to the renderer.
IPC_MESSAGE_ROUTED3(ViewMsg_HandleMessageFromExternalHost,
std::string /* The message */,
std::string /* The origin */,
std::string /* The target*/)
// Sent to the renderer when a popup window should no longer count against
// the current popup count (either because it's not a popup or because it was
// a generated by a user action or because a constrained popup got turned
// into a full window).
IPC_MESSAGE_ROUTED0(ViewMsg_DisassociateFromPopupCount)
// The browser sends this to a renderer process in response to a
// ViewHostMsg_EstablishGpuChannel message.
IPC_MESSAGE_CONTROL2(ViewMsg_GpuChannelEstablished,
IPC::ChannelHandle /* handle to channel */,
GPUInfo /* stats about GPU process*/)
// Notifies the renderer of the appcache that has been selected for a
// a particular host. This is sent in reply to AppCacheMsg_SelectCache.
IPC_MESSAGE_CONTROL2(AppCacheMsg_CacheSelected,
int /* host_id */,
appcache::AppCacheInfo)
// Notifies the renderer of an AppCache status change.
IPC_MESSAGE_CONTROL2(AppCacheMsg_StatusChanged,
std::vector<int> /* host_ids */,
appcache::Status)
// Notifies the renderer of an AppCache event other than the
// progress event which has a seperate message.
IPC_MESSAGE_CONTROL2(AppCacheMsg_EventRaised,
std::vector<int> /* host_ids */,
appcache::EventID)
// Notifies the renderer of an AppCache progress event.
IPC_MESSAGE_CONTROL4(AppCacheMsg_ProgressEventRaised,
std::vector<int> /* host_ids */,
GURL /* url being processed */,
int /* total */,
int /* complete */)
// Notifies the renderer of an AppCache error event.
IPC_MESSAGE_CONTROL2(AppCacheMsg_ErrorEventRaised,
std::vector<int> /* host_ids */,
std::string /* error_message */)
// Notifies the renderer of an AppCache logging message.
IPC_MESSAGE_CONTROL3(AppCacheMsg_LogMessage,
int /* host_id */,
int /* log_level */,
std::string /* message */)
// Notifies the renderer of the fact that AppCache access was blocked.
IPC_MESSAGE_CONTROL2(AppCacheMsg_ContentBlocked,
int /* host_id */,
GURL /* manifest_url */)
// Reply to the ViewHostMsg_QueryFormFieldAutoFill message with the
// AutoFill suggestions.
IPC_MESSAGE_ROUTED5(ViewMsg_AutoFillSuggestionsReturned,
int /* id of the request message */,
std::vector<string16> /* names */,
std::vector<string16> /* labels */,
std::vector<string16> /* icons */,
std::vector<int> /* unique_ids */)
// Reply to the ViewHostMsg_FillAutoFillFormData message with the
// AutoFill form data.
IPC_MESSAGE_ROUTED2(ViewMsg_AutoFillFormDataFilled,
int /* id of the request message */,
webkit_glue::FormData /* form data */)
// Sent by the Browser process to alert a window about whether a it should
// allow a scripted window.close(). The renderer assumes every new window is a
// blocked popup until notified otherwise.
IPC_MESSAGE_ROUTED1(ViewMsg_AllowScriptToClose,
bool /* script_can_close */)
// Sent by AudioRendererHost to renderer to request an audio packet.
IPC_MESSAGE_ROUTED2(ViewMsg_RequestAudioPacket,
int /* stream id */,
AudioBuffersState)
// Tell the renderer process that the audio stream has been created, renderer
// process would be given a ShareMemoryHandle that it should write to from
// then on.
IPC_MESSAGE_ROUTED3(ViewMsg_NotifyAudioStreamCreated,
int /* stream id */,
base::SharedMemoryHandle /* handle */,
uint32 /* length */)
// Tell the renderer process that a low latency audio stream has been created,
// renderer process would be given a SyncSocket that it should write to from
// then on.
#if defined(OS_WIN)
IPC_MESSAGE_ROUTED4(ViewMsg_NotifyLowLatencyAudioStreamCreated,
int /* stream id */,
base::SharedMemoryHandle /* handle */,
base::SyncSocket::Handle /* socket handle */,
uint32 /* length */)
#else
IPC_MESSAGE_ROUTED4(ViewMsg_NotifyLowLatencyAudioStreamCreated,
int /* stream id */,
base::SharedMemoryHandle /* handle */,
base::FileDescriptor /* socket handle */,
uint32 /* length */)
#endif
// Notification message sent from AudioRendererHost to renderer for state
// update after the renderer has requested a Create/Start/Close.
IPC_MESSAGE_ROUTED2(ViewMsg_NotifyAudioStreamStateChanged,
int /* stream id */,
ViewMsg_AudioStreamState_Params /* new state */)
IPC_MESSAGE_ROUTED2(ViewMsg_NotifyAudioStreamVolume,
int /* stream id */,
double /* volume */)
// Notification that a move or resize renderer's containing window has
// started.
IPC_MESSAGE_ROUTED0(ViewMsg_MoveOrResizeStarted)
// The browser sends this message in response to all extension api calls.
IPC_MESSAGE_ROUTED4(ViewMsg_ExtensionResponse,
int /* request_id */,
bool /* success */,
std::string /* response */,
std::string /* error */)
// This message is optionally routed. If used as a control message, it
// will call a javascript function in every registered context in the
// target process. If routed, it will be restricted to the contexts that
// are part of the target RenderView.
// |args| is a list of primitive Value types that are passed to the function.
IPC_MESSAGE_ROUTED4(ViewMsg_ExtensionMessageInvoke,
std::string /* function_name */,
ListValue /* args */,
bool /* requires incognito access */,
GURL /* event URL */)
// Tell the renderer process all known extension function names.
IPC_MESSAGE_CONTROL1(ViewMsg_Extension_SetFunctionNames,
std::vector<std::string>)
// Tell the renderer process which permissions the given extension has. See
// Extension::Permissions for which elements correspond to which permissions.
IPC_MESSAGE_CONTROL2(ViewMsg_Extension_SetAPIPermissions,
std::string /* extension_id */,
std::set<std::string> /* permissions */)
// Tell the renderer process which host permissions the given extension has.
IPC_MESSAGE_CONTROL2(
ViewMsg_Extension_SetHostPermissions,
GURL /* source extension's origin */,
std::vector<URLPattern> /* URLPatterns the extension can access */)
// Tell the renderer process that the given extension is enabled or disabled
// for incognito mode, and what kind of incognito behavior it has.
IPC_MESSAGE_CONTROL3(ViewMsg_Extension_ExtensionSetIncognitoEnabled,
std::string /* extension_id */,
bool /* enabled */,
bool /* incognito_split_mode */)
// Tell the renderer process all known page action ids for a particular
// extension.
IPC_MESSAGE_CONTROL2(ViewMsg_Extension_UpdatePageActions,
std::string /* extension_id */,
std::vector<std::string> /* page_action_ids */)
// Changes the text direction of the currently selected input field (if any).
IPC_MESSAGE_ROUTED1(ViewMsg_SetTextDirection,
WebKit::WebTextDirection /* direction */)
// Tells the renderer to clear the focused node (if any).
IPC_MESSAGE_ROUTED0(ViewMsg_ClearFocusedNode)
// Make the RenderView transparent and render it onto a custom background. The
// background will be tiled in both directions if it is not large enough.
IPC_MESSAGE_ROUTED1(ViewMsg_SetBackground,
SkBitmap /* background */)
// Reply to ViewHostMsg_RequestMove, ViewHostMsg_ShowView, and
// ViewHostMsg_ShowWidget to inform the renderer that the browser has
// processed the move. The browser may have ignored the move, but it finished
// processing. This is used because the renderer keeps a temporary cache of
// the widget position while these asynchronous operations are in progress.
IPC_MESSAGE_ROUTED0(ViewMsg_Move_ACK)
// Used to instruct the RenderView to send back updates to the preferred size.
IPC_MESSAGE_ROUTED1(ViewMsg_EnablePreferredSizeChangedMode, int /*flags*/)
// Used to tell the renderer not to add scrollbars with height and
// width below a threshold.
IPC_MESSAGE_ROUTED1(ViewMsg_DisableScrollbarsForSmallWindows,
gfx::Size /* disable_scrollbar_size_limit */)
// Used to inform the renderer that the browser has displayed its
// requested notification.
IPC_MESSAGE_ROUTED1(ViewMsg_PostDisplayToNotificationObject,
int /* notification_id */)
// Used to inform the renderer that the browser has encountered an error
// trying to display a notification.
IPC_MESSAGE_ROUTED2(ViewMsg_PostErrorToNotificationObject,
int /* notification_id */,
string16 /* message */)
// Informs the renderer that the one if its notifications has closed.
IPC_MESSAGE_ROUTED2(ViewMsg_PostCloseToNotificationObject,
int /* notification_id */,
bool /* by_user */)
// Informs the renderer that one of its notifications was clicked on.
IPC_MESSAGE_ROUTED1(ViewMsg_PostClickToNotificationObject,
int /* notification_id */)
// Informs the renderer that the one if its notifications has closed.
IPC_MESSAGE_ROUTED1(ViewMsg_PermissionRequestDone,
int /* request_id */)
// Activate/deactivate the RenderView (i.e., set its controls' tint
// accordingly, etc.).
IPC_MESSAGE_ROUTED1(ViewMsg_SetActive,
bool /* active */)
#if defined(OS_MACOSX)
// Let the RenderView know its window has changed visibility.
IPC_MESSAGE_ROUTED1(ViewMsg_SetWindowVisibility,
bool /* visibile */)
// Let the RenderView know its window's frame has changed.
IPC_MESSAGE_ROUTED2(ViewMsg_WindowFrameChanged,
gfx::Rect /* window frame */,
gfx::Rect /* content view frame */)
#endif
// Response message to ViewHostMsg_CreateShared/DedicatedWorker.
// Sent when the worker has started.
IPC_MESSAGE_ROUTED0(ViewMsg_WorkerCreated)
// Tell the renderer which browser window it's being attached to.
IPC_MESSAGE_ROUTED1(ViewMsg_UpdateBrowserWindowId,
int /* id of browser window */)
// Tell the renderer which type this view is.
IPC_MESSAGE_ROUTED1(ViewMsg_NotifyRenderViewType,
ViewType::Type /* view_type */)
// Notification that renderer should run some JavaScript code.
IPC_MESSAGE_ROUTED1(ViewMsg_ExecuteCode,
ViewMsg_ExecuteCode_Params)
// Notifies the child process of the new database size
IPC_MESSAGE_CONTROL4(ViewMsg_DatabaseUpdateSize,
string16 /* the origin */,
string16 /* the database name */,
int64 /* the new database size */,
int64 /* space available to origin */)
// Asks the child process to close a database immediately
IPC_MESSAGE_CONTROL2(ViewMsg_DatabaseCloseImmediately,
string16 /* the origin */,
string16 /* the database name */)
// Storage events are broadcast to renderer processes.
IPC_MESSAGE_CONTROL1(ViewMsg_DOMStorageEvent,
ViewMsg_DOMStorageEvent_Params)
// IDBCallback message handlers.
IPC_MESSAGE_CONTROL1(ViewMsg_IDBCallbacksSuccessNull,
int32 /* response_id */)
IPC_MESSAGE_CONTROL2(ViewMsg_IDBCallbacksSuccessIDBDatabase,
int32 /* response_id */,
int32 /* idb_database_id */)
IPC_MESSAGE_CONTROL2(ViewMsg_IDBCallbacksSuccessIndexedDBKey,
int32 /* response_id */,
IndexedDBKey /* indexed_db_key */)
IPC_MESSAGE_CONTROL2(ViewMsg_IDBCallbacksSuccessIDBObjectStore,
int32 /* response_id */,
int32 /* idb_object_store_id */)
IPC_MESSAGE_CONTROL2(ViewMsg_IDBCallbacksSuccessIDBIndex,
int32 /* response_id */,
int32 /* idb_index_id */)
IPC_MESSAGE_CONTROL2(ViewMsg_IDBCallbacksSuccessSerializedScriptValue,
int32 /* response_id */,
SerializedScriptValue /* serialized_script_value */)
IPC_MESSAGE_CONTROL2(ViewMsg_IDBCallbackSuccessOpenCursor,
int32 /* response_id */,
int32 /* cursor_id */)
IPC_MESSAGE_CONTROL3(ViewMsg_IDBCallbacksError,
int32 /* response_id */,
int /* code */,
string16 /* message */)
// IDBTransactionCallback message handlers.
IPC_MESSAGE_CONTROL1(ViewMsg_IDBTransactionCallbacksAbort,
int /* transaction_id */)
#if defined(IPC_MESSAGE_LOG_ENABLED)
// Tell the renderer process to begin or end IPC message logging.
IPC_MESSAGE_CONTROL1(ViewMsg_SetIPCLoggingEnabled,
bool /* on or off */)
#endif
// Socket Stream messages:
// These are messages from the browser to the SocketStreamHandle on
// a renderer.
// A |socket_id| is assigned by ViewHostMsg_SocketStream_Connect.
// The Socket Stream is connected. The SocketStreamHandle should keep track
// of how much it has pending (how much it has requested to be sent) and
// shouldn't go over |max_pending_send_allowed| bytes.
IPC_MESSAGE_CONTROL2(ViewMsg_SocketStream_Connected,
int /* socket_id */,
int /* max_pending_send_allowed */)
// |data| is received on the Socket Stream.
IPC_MESSAGE_CONTROL2(ViewMsg_SocketStream_ReceivedData,
int /* socket_id */,
std::vector<char> /* data */)
// |amount_sent| bytes of data requested by
// ViewHostMsg_SocketStream_SendData has been sent on the Socket Stream.
IPC_MESSAGE_CONTROL2(ViewMsg_SocketStream_SentData,
int /* socket_id */,
int /* amount_sent */)
// The Socket Stream is closed.
IPC_MESSAGE_CONTROL1(ViewMsg_SocketStream_Closed,
int /* socket_id */)
// SpellChecker messages.
// Passes some initialization params to the renderer's spellchecker. This can
// be called directly after startup or in (async) response to a
// RequestDictionary ViewHost message.
IPC_MESSAGE_CONTROL4(ViewMsg_SpellChecker_Init,
IPC::PlatformFileForTransit /* bdict_file */,
std::vector<std::string> /* custom_dict_words */,
std::string /* language */,
bool /* auto spell correct */)
// A word has been added to the custom dictionary; update the local custom
// word list.
IPC_MESSAGE_CONTROL1(ViewMsg_SpellChecker_WordAdded,
std::string /* word */)
// Toggle the auto spell correct functionality.
IPC_MESSAGE_CONTROL1(ViewMsg_SpellChecker_EnableAutoSpellCorrect,
bool /* enable */)
// Executes custom context menu action that was provided from WebKit.
IPC_MESSAGE_ROUTED1(ViewMsg_CustomContextMenuAction,
unsigned /* action */)
// Tells the renderer to translate the page contents from one language to
// another.
IPC_MESSAGE_ROUTED4(ViewMsg_TranslatePage,
int /* page id */,
std::string, /* the script injected in the page */
std::string, /* BCP 47/RFC 5646 language code the page
is in */
std::string /* BCP 47/RFC 5646 language code to translate
to */)
// Tells the renderer to revert the text of translated page to its original
// contents.
IPC_MESSAGE_ROUTED1(ViewMsg_RevertTranslation,
int /* page id */)
// Reply in response to ViewHostMsg_Geolocation_RequestPermission.
IPC_MESSAGE_ROUTED2(ViewMsg_Geolocation_PermissionSet,
int /* bridge_id */,
bool /* is_allowed */)
// Sent after ViewHostMsg_Geolocation_StartUpdating iff the user has granted
// permission and we have a position available or an error occurs (such as
// permission denied, position unavailable, etc.)
IPC_MESSAGE_ROUTED1(ViewMsg_Geolocation_PositionUpdated,
Geoposition /* geoposition */)
// Sent on process startup to indicate whether this process is running in
// incognito mode.
IPC_MESSAGE_CONTROL1(ViewMsg_SetIsIncognitoProcess,
bool /* is_incognito_processs */)
// Notification that the list of extensions has been updated.
IPC_MESSAGE_CONTROL1(ViewMsg_ExtensionsUpdated,
ViewMsg_ExtensionsUpdated_Params)
// Enable accessibility in the renderer process.
IPC_MESSAGE_ROUTED0(ViewMsg_EnableAccessibility)
// Relay a request from assistive technology to set focus to a given node.
IPC_MESSAGE_ROUTED1(ViewMsg_SetAccessibilityFocus,
int /* object id */)
// Relay a request from assistive technology to perform the default action
// on a given node.
IPC_MESSAGE_ROUTED1(ViewMsg_AccessibilityDoDefaultAction,
int /* object id */)
// Tells the render view that a ViewHostMsg_AccessibilityNotifications
// message was processed and it can send addition notifications.
IPC_MESSAGE_ROUTED0(ViewMsg_AccessibilityNotifications_ACK)
// Relay a speech recognition result, either partial or final.
IPC_MESSAGE_ROUTED2(ViewMsg_SpeechInput_SetRecognitionResult,
int /* request id */,
string16 /* result */)
// Indicate that speech recognizer has stopped recording and started
// recognition.
IPC_MESSAGE_ROUTED1(ViewMsg_SpeechInput_RecordingComplete,
int /* request id */)
// Indicate that speech recognizer has completed recognition. This will be
// the last message sent in response to a
// ViewHostMsg_SpeechInput_StartRecognition.
IPC_MESSAGE_ROUTED1(ViewMsg_SpeechInput_RecognitionComplete,
int /* request id */)
// Notification that the device's orientation has changed.
IPC_MESSAGE_ROUTED1(ViewMsg_DeviceOrientationUpdated,
ViewMsg_DeviceOrientationUpdated_Params)
// WebFrameClient::openFileSystem response messages.
IPC_MESSAGE_CONTROL4(ViewMsg_OpenFileSystemRequest_Complete,
int /* request_id */,
bool /* accepted */,
std::string /* name */,
FilePath /* root_path */)
// WebFileSystem response messages.
IPC_MESSAGE_CONTROL1(ViewMsg_FileSystem_DidSucceed,
int /* request_id */)
IPC_MESSAGE_CONTROL2(ViewMsg_FileSystem_DidReadMetadata,
int /* request_id */,
base::PlatformFileInfo)
IPC_MESSAGE_CONTROL3(ViewMsg_FileSystem_DidReadDirectory,
int /* request_id */,
std::vector<base::file_util_proxy::Entry> /* entries */,
bool /* has_more */)
IPC_MESSAGE_CONTROL3(ViewMsg_FileSystem_DidWrite,
int /* request_id */,
int64 /* byte count */,
bool /* complete */)
IPC_MESSAGE_CONTROL2(ViewMsg_FileSystem_DidFail,
int /* request_id */,
base::PlatformFileError /* error_code */)
// The response to ViewHostMsg_AsyncOpenFile.
IPC_MESSAGE_ROUTED3(ViewMsg_AsyncOpenFile_ACK,
base::PlatformFileError /* error_code */,
IPC::PlatformFileForTransit /* file descriptor */,
int /* message_id */)
// A classification model for client-side phishing detection.
// The given file contains an encoded safe_browsing::ClientSideModel
// protocol buffer.
IPC_MESSAGE_CONTROL1(ViewMsg_SetPhishingModel,
IPC::PlatformFileForTransit /* model_file */)
IPC_END_MESSAGES(View)
//-----------------------------------------------------------------------------
// TabContents messages
// These are messages sent from the renderer to the browser process.
IPC_BEGIN_MESSAGES(ViewHost)
// Sent by the renderer when it is creating a new window. The browser creates
// a tab for it and responds with a ViewMsg_CreatingNew_ACK. If route_id is
// MSG_ROUTING_NONE, the view couldn't be created.
IPC_SYNC_MESSAGE_CONTROL1_2(ViewHostMsg_CreateWindow,
ViewHostMsg_CreateWindow_Params,
int /* route_id */,
int64 /* cloned_session_storage_namespace_id */)
// Similar to ViewHostMsg_CreateWindow, except used for sub-widgets, like
// <select> dropdowns. This message is sent to the TabContents that
// contains the widget being created.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_CreateWidget,
int /* opener_id */,
WebKit::WebPopupType /* popup type */,
int /* route_id */)
// Similar to ViewHostMsg_CreateWidget except the widget is a full screen
// window.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_CreateFullscreenWidget,
int /* opener_id */,
WebKit::WebPopupType /* popup type */,
int /* route_id */)
// These three messages are sent to the parent RenderViewHost to display the
// page/widget that was created by
// CreateWindow/CreateWidget/CreateFullscreenWidget. routing_id
// refers to the id that was returned from the Create message above.
// The initial_position parameter is a rectangle in screen coordinates.
//
// FUTURE: there will probably be flags here to control if the result is
// in a new window.
IPC_MESSAGE_ROUTED4(ViewHostMsg_ShowView,
int /* route_id */,
WindowOpenDisposition /* disposition */,
gfx::Rect /* initial_pos */,
bool /* opened_by_user_gesture */)
IPC_MESSAGE_ROUTED2(ViewHostMsg_ShowWidget,
int /* route_id */,
gfx::Rect /* initial_pos */)
// Message to show a full screen widget.
IPC_MESSAGE_ROUTED1(ViewHostMsg_ShowFullscreenWidget,
int /* route_id */)
// Message to show a popup menu using native cocoa controls (Mac only).
IPC_MESSAGE_ROUTED1(ViewHostMsg_ShowPopup,
ViewHostMsg_ShowPopup_Params)
// This message is sent after ViewHostMsg_ShowView to cause the RenderView
// to run in a modal fashion until it is closed.
IPC_SYNC_MESSAGE_ROUTED0_0(ViewHostMsg_RunModal)
IPC_MESSAGE_CONTROL1(ViewHostMsg_UpdatedCacheStats,
WebKit::WebCache::UsageStats /* stats */)
// Indicates the renderer is ready in response to a ViewMsg_New or
// a ViewMsg_CreatingNew_ACK.
IPC_MESSAGE_ROUTED0(ViewHostMsg_RenderViewReady)
// Indicates the renderer process is gone. This actually is sent by the
// browser process to itself, but keeps the interface cleaner.
IPC_MESSAGE_ROUTED0(ViewHostMsg_RenderViewGone)
// Sent by the renderer process to request that the browser close the view.
// This corresponds to the window.close() API, and the browser may ignore
// this message. Otherwise, the browser will generates a ViewMsg_Close
// message to close the view.
IPC_MESSAGE_ROUTED0(ViewHostMsg_Close)
// Sent by the renderer process to request that the browser move the view.
// This corresponds to the window.resizeTo() and window.moveTo() APIs, and
// the browser may ignore this message.
IPC_MESSAGE_ROUTED1(ViewHostMsg_RequestMove,
gfx::Rect /* position */)
// Notifies the browser that a frame in the view has changed. This message
// has a lot of parameters and is packed/unpacked by functions defined in
// render_messages.h.
IPC_MESSAGE_ROUTED1(ViewHostMsg_FrameNavigate,
ViewHostMsg_FrameNavigate_Params)
// Notifies the browser that we have session history information.
// page_id: unique ID that allows us to distinguish between history entries.
IPC_MESSAGE_ROUTED2(ViewHostMsg_UpdateState,
int32 /* page_id */,
std::string /* state */)
// Notifies the browser that a document has been loaded in a frame.
IPC_MESSAGE_ROUTED0(ViewHostMsg_DocumentLoadedInFrame)
// Changes the title for the page in the UI when the page is navigated or the
// title changes.
// TODO(darin): use a UTF-8 string to reduce data size
IPC_MESSAGE_ROUTED2(ViewHostMsg_UpdateTitle, int32, std::wstring)
// Changes the icon url for the page in the UI.
IPC_MESSAGE_ROUTED2(ViewHostMsg_UpdateIconURL, int32, GURL)
// Change the encoding name of the page in UI when the page has detected
// proper encoding name.
IPC_MESSAGE_ROUTED1(ViewHostMsg_UpdateEncoding,
std::string /* new encoding name */)
// Notifies the browser that we want to show a destination url for a potential
// action (e.g. when the user is hovering over a link).
IPC_MESSAGE_ROUTED2(ViewHostMsg_UpdateTargetURL, int32, GURL)
// Sent when the renderer starts loading the page. This corresponds to
// WebKit's notion of the throbber starting. Note that sometimes you may get
// duplicates of these during a single load.
IPC_MESSAGE_ROUTED0(ViewHostMsg_DidStartLoading)
// Sent when the renderer is done loading a page. This corresponds to WebKit's
// noption of the throbber stopping.
IPC_MESSAGE_ROUTED0(ViewHostMsg_DidStopLoading)
// Sent when the document element is available for the toplevel frame. This
// happens after the page starts loading, but before all resources are
// finished.
IPC_MESSAGE_ROUTED0(ViewHostMsg_DocumentAvailableInMainFrame)
// Sent when after the onload handler has been invoked for the document
// in the toplevel frame.
IPC_MESSAGE_ROUTED1(ViewHostMsg_DocumentOnLoadCompletedInMainFrame,
int32 /* page_id */)
// Sent when the renderer loads a resource from its memory cache.
// The security info is non empty if the resource was originally loaded over
// a secure connection.
// Note: May only be sent once per URL per frame per committed load.
IPC_MESSAGE_ROUTED4(ViewHostMsg_DidLoadResourceFromMemoryCache,
GURL /* url */,
std::string /* frame_origin */,
std::string /* main_frame_origin */,
std::string /* security info */)
// Sent when the renderer displays insecure content in a secure page.
IPC_MESSAGE_ROUTED0(ViewHostMsg_DidDisplayInsecureContent)
// Sent when the renderer runs insecure content in a secure origin.
IPC_MESSAGE_ROUTED1(ViewHostMsg_DidRunInsecureContent,
std::string /* security_origin */)
// Sent when the renderer starts a provisional load for a frame.
IPC_MESSAGE_ROUTED2(ViewHostMsg_DidStartProvisionalLoadForFrame,
bool /* true if it is the main frame */,
GURL /* url */)
// Sent when the renderer fails a provisional load with an error.
IPC_MESSAGE_ROUTED4(ViewHostMsg_DidFailProvisionalLoadWithError,
bool /* true if it is the main frame */,
int /* error_code */,
GURL /* url */,
bool /* true if the failure is the result of
navigating to a POST again and we're going to
show the POST interstitial */ )
// Tells the render view that a ViewHostMsg_PaintAtSize message was
// processed, and the DIB is ready for use. |tag| has the same value that
// the tag sent along with ViewMsg_PaintAtSize.
IPC_MESSAGE_ROUTED2(ViewHostMsg_PaintAtSize_ACK,
int /* tag */,
gfx::Size /* size */)
// Sent to update part of the view. In response to this message, the host
// generates a ViewMsg_UpdateRect_ACK message.
IPC_MESSAGE_ROUTED1(ViewHostMsg_UpdateRect,
ViewHostMsg_UpdateRect_Params)
// Sent to create, update and destroy video layers.
IPC_MESSAGE_ROUTED1(ViewHostMsg_CreateVideo,
gfx::Size /* size */)
IPC_MESSAGE_ROUTED2(ViewHostMsg_UpdateVideo,
TransportDIB::Id /* bitmap */,
gfx::Rect /* bitmap_rect */)
IPC_MESSAGE_ROUTED0(ViewHostMsg_DestroyVideo)
// Sent by the renderer when GPU compositing is enabled or disabled to notify
// the browser whether or not is should do paiting.
IPC_MESSAGE_ROUTED1(ViewHostMsg_GpuRenderingActivated,
bool /* true if the GPU process renders to window */)
// Acknowledges receipt of a ViewMsg_HandleInputEvent message.
// Payload is a WebInputEvent::Type which is the type of the event, followed
// by an optional WebInputEvent which is provided only if the event was not
// processed.
IPC_MESSAGE_ROUTED0(ViewHostMsg_HandleInputEvent_ACK)
IPC_MESSAGE_ROUTED0(ViewHostMsg_Focus)
IPC_MESSAGE_ROUTED0(ViewHostMsg_Blur)
IPC_MESSAGE_ROUTED0(ViewHostMsg_FocusedNodeChanged)
// Returns the window location of the given window.
// TODO(shess): Provide a mapping from reply_msg->routing_id() to
// HWND so that we can eliminate the NativeViewId parameter.
IPC_SYNC_MESSAGE_ROUTED1_1(ViewHostMsg_GetWindowRect,
gfx::NativeViewId /* window */,
gfx::Rect /* Out: Window location */)
IPC_MESSAGE_ROUTED1(ViewHostMsg_SetCursor, WebCursor)
// Result of string search in the page.
// Response to ViewMsg_Find with the results of the requested find-in-page
// search, the number of matches found and the selection rect (in screen
// coordinates) for the string found. If |final_update| is false, it signals
// that this is not the last Find_Reply message - more will be sent as the
// scoping effort continues.
IPC_MESSAGE_ROUTED5(ViewHostMsg_Find_Reply,
int /* request_id */,
int /* number of matches */,
gfx::Rect /* selection_rect */,
int /* active_match_ordinal */,
bool /* final_update */)
// Makes a resource request via the browser.
IPC_MESSAGE_ROUTED2(ViewHostMsg_RequestResource,
int /* request_id */,
ViewHostMsg_Resource_Request)
// Cancels a resource request with the ID given as the parameter.
IPC_MESSAGE_ROUTED1(ViewHostMsg_CancelRequest,
int /* request_id */)
// Follows a redirect that occured for the resource request with the ID given
// as the parameter.
IPC_MESSAGE_ROUTED3(ViewHostMsg_FollowRedirect,
int /* request_id */,
bool /* has_new_first_party_for_cookies */,
GURL /* new_first_party_for_cookies */)
// Makes a synchronous resource request via the browser.
IPC_SYNC_MESSAGE_ROUTED2_1(ViewHostMsg_SyncLoad,
int /* request_id */,
ViewHostMsg_Resource_Request,
SyncLoadResult)
// Used to set a cookie. The cookie is set asynchronously, but will be
// available to a subsequent ViewHostMsg_GetCookies request.
IPC_MESSAGE_ROUTED3(ViewHostMsg_SetCookie,
GURL /* url */,
GURL /* first_party_for_cookies */,
std::string /* cookie */)
// Used to get cookies for the given URL. This may be blocked by a user
// prompt to validate a previous SetCookie message.
IPC_SYNC_MESSAGE_ROUTED2_1(ViewHostMsg_GetCookies,
GURL /* url */,
GURL /* first_party_for_cookies */,
std::string /* cookies */)
// Used to get raw cookie information for the given URL. This may be blocked
// by a user prompt to validate a previous SetCookie message.
IPC_SYNC_MESSAGE_ROUTED2_1(ViewHostMsg_GetRawCookies,
GURL /* url */,
GURL /* first_party_for_cookies */,
std::vector<webkit_glue::WebCookie>
/* raw_cookies */)
// Used to delete cookie for the given URL and name
IPC_SYNC_MESSAGE_CONTROL2_0(ViewHostMsg_DeleteCookie,
GURL /* url */,
std::string /* cookie_name */)
// Used to get the list of plugins
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetPlugins,
bool /* refresh*/,
std::vector<WebPluginInfo> /* plugins */)
// Return information about a plugin for the given URL and MIME type. If there
// is no matching plugin, |found| is set to false.
// If |enabled| in the WebPluginInfo struct is false, the plug-in is basically
// treated as if it was not installed at all.
// If |setting| is set to CONTENT_SETTING_BLOCK, the plug-in is blocked by the
// content settings for |policy_url|. It still appears in navigator.plugins in
// Javascript though, and can be loaded via click-to-play.
// If |setting| is set to CONTENT_SETTING_ALLOW, the domain is explicitly
// white-listed for the plug-in, or the user has chosen not to block
// nonsandboxed plugins.
// If |setting| is set to CONTENT_SETTING_DEFAULT, the plug-in is neither
// blocked nor white-listed, which means that it's allowed by default and
// can still be blocked if it's non-sandboxed.
IPC_SYNC_MESSAGE_CONTROL3_4(ViewHostMsg_GetPluginInfo,
GURL /* url */,
GURL /* policy_url */,
std::string /* mime_type */,
bool /* found */,
WebPluginInfo /* plugin info */,
ContentSetting /* setting */,
std::string /* actual_mime_type */)
// Requests spellcheck for a word.
IPC_SYNC_MESSAGE_ROUTED2_2(ViewHostMsg_SpellCheck,
string16 /* word to check */,
int /* document tag*/,
int /* misspell location */,
int /* misspell length */)
// Asks the browser for a unique document tag.
IPC_SYNC_MESSAGE_ROUTED0_1(ViewHostMsg_GetDocumentTag,
int /* the tag */)
// This message tells the spellchecker that a document, identified by an int
// tag, has been closed and all of the ignored words for that document can be
// forgotten.
IPC_MESSAGE_ROUTED1(ViewHostMsg_DocumentWithTagClosed,
int /* the tag */)
// Tells the browser to display or not display the SpellingPanel
IPC_MESSAGE_ROUTED1(ViewHostMsg_ShowSpellingPanel,
bool /* if true, then show it, otherwise hide it*/)
// Tells the browser to update the spelling panel with the given word.
IPC_MESSAGE_ROUTED1(ViewHostMsg_UpdateSpellingPanelWithMisspelledWord,
string16 /* the word to update the panel with */)
// Tells the browser that content in the current page was blocked due to the
// user's content settings.
IPC_MESSAGE_ROUTED2(ViewHostMsg_ContentBlocked,
ContentSettingsType, /* type of blocked content */
std::string /* resource identifier */)
// Tells the browser that a specific Appcache manifest in the current page
// was accessed.
IPC_MESSAGE_ROUTED2(ViewHostMsg_AppCacheAccessed,
GURL /* manifest url */,
bool /* blocked by policy */)
// Tells the browser that a specific Web database in the current page was
// accessed.
IPC_MESSAGE_ROUTED5(ViewHostMsg_WebDatabaseAccessed,
GURL /* origin url */,
string16 /* database name */,
string16 /* database display name */,
unsigned long /* estimated size */,
bool /* blocked by policy */)
// Initiates a download based on user actions like 'ALT+click'.
IPC_MESSAGE_ROUTED2(ViewHostMsg_DownloadUrl,
GURL /* url */,
GURL /* referrer */)
// Used to go to the session history entry at the given offset (ie, -1 will
// return the "back" item).
IPC_MESSAGE_ROUTED1(ViewHostMsg_GoToEntryAtOffset,
int /* offset (from current) of history item to get */)
IPC_SYNC_MESSAGE_ROUTED4_2(ViewHostMsg_RunJavaScriptMessage,
std::wstring /* in - alert message */,
std::wstring /* in - default prompt */,
GURL /* in - originating page URL */,
int /* in - dialog flags */,
bool /* out - success */,
std::wstring /* out - prompt field */)
// Provides the contents for the given page that was loaded recently.
IPC_MESSAGE_ROUTED5(ViewHostMsg_PageContents,
GURL /* URL of the page */,
int32 /* page id */,
string16 /* page contents */,
std::string /* page ISO639_1 language code */,
bool /* whether the page can be translated */)
// Used to get the extension message bundle.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetExtensionMessageBundle,
std::string /* extension id */,
SubstitutionMap /* message bundle */)
// Specifies the URL as the first parameter (a wstring) and thumbnail as
// binary data as the second parameter.
IPC_MESSAGE_ROUTED3(ViewHostMsg_Thumbnail,
GURL /* url */,
ThumbnailScore /* score */,
SkBitmap /* bitmap */)
// Send a snapshot of the tab contents to the render host.
IPC_MESSAGE_ROUTED1(ViewHostMsg_Snapshot,
SkBitmap /* bitmap */)
// Notification that the url for the favicon of a site has been determined.
IPC_MESSAGE_ROUTED2(ViewHostMsg_UpdateFavIconURL,
int32 /* page_id */,
GURL /* url of the favicon */)
// Used to tell the parent that the user right clicked on an area of the
// content area, and a context menu should be shown for it. The params
// object contains information about the node(s) that were selected when the
// user right clicked.
IPC_MESSAGE_ROUTED1(ViewHostMsg_ContextMenu, ContextMenuParams)
// Requests that the given URL be opened in the specified manner.
IPC_MESSAGE_ROUTED3(ViewHostMsg_OpenURL,
GURL /* url */,
GURL /* referrer */,
WindowOpenDisposition /* disposition */)
// Notifies that the preferred size of the content changed.
IPC_MESSAGE_ROUTED1(ViewHostMsg_DidContentsPreferredSizeChange,
gfx::Size /* pref_size */)
// Following message is used to communicate the values received by the
// callback binding the JS to Cpp.
// An instance of browser that has an automation host listening to it can
// have a javascript send a native value (string, number, boolean) to the
// listener in Cpp. (DomAutomationController)
IPC_MESSAGE_ROUTED2(ViewHostMsg_DomOperationResponse,
std::string /* json_string */,
int /* automation_id */)
// A message from HTML-based UI. When (trusted) Javascript calls
// send(message, args), this message is sent to the browser.
IPC_MESSAGE_ROUTED3(ViewHostMsg_DOMUISend,
GURL /* source_url */,
std::string /* message */,
std::string /* args (as a JSON string) */)
// A message for an external host.
IPC_MESSAGE_ROUTED3(ViewHostMsg_ForwardMessageToExternalHost,
std::string /* message */,
std::string /* origin */,
std::string /* target */)
// A renderer sends this to the browser process when it wants to
// create a plugin. The browser will create the plugin process if
// necessary, and will return a handle to the channel on success.
// On error an empty string is returned.
IPC_SYNC_MESSAGE_CONTROL3_2(ViewHostMsg_OpenChannelToPlugin,
GURL /* url */,
std::string /* mime_type */,
std::string /* locale */,
IPC::ChannelHandle /* handle to channel */,
WebPluginInfo /* info */)
// A renderer sends this to the browser process when it wants to
// create connect to the GPU. The browser will create the GPU process if
// necessary, and will return a handle to the channel via
// a GpuChannelEstablished message.
IPC_MESSAGE_CONTROL0(ViewHostMsg_EstablishGpuChannel)
// A renderer sends this to the browser process to provide a synchronization
// point for GPU operations, in particular to make sure the GPU channel has
// been established.
IPC_SYNC_MESSAGE_CONTROL0_0(ViewHostMsg_SynchronizeGpu)
// A renderer sends this to the browser process when it wants to start
// a new instance of the Native Client process. The browser will launch
// the process and return a handle to an IMC channel.
IPC_SYNC_MESSAGE_CONTROL2_3(ViewHostMsg_LaunchNaCl,
std::wstring /* url for the NaCl module */,
int /* socket count */,
std::vector<nacl::FileDescriptor>
/* imc channel handles */,
base::ProcessHandle /* NaCl process handle */,
base::ProcessId /* NaCl process id */)
#if defined(USE_X11)
// A renderer sends this when it needs a browser-side widget for
// hosting a windowed plugin. id is the XID of the plugin window, for which
// the container is created.
IPC_SYNC_MESSAGE_ROUTED1_0(ViewHostMsg_CreatePluginContainer,
gfx::PluginWindowHandle /* id */)
// Destroy a plugin container previously created using CreatePluginContainer.
// id is the XID of the plugin window corresponding to the container that is
// to be destroyed.
IPC_SYNC_MESSAGE_ROUTED1_0(ViewHostMsg_DestroyPluginContainer,
gfx::PluginWindowHandle /* id */)
#endif
// Clipboard IPC messages
// This message is used when the object list does not contain a bitmap.
IPC_MESSAGE_CONTROL1(ViewHostMsg_ClipboardWriteObjectsAsync,
Clipboard::ObjectMap /* objects */)
// This message is used when the object list contains a bitmap.
// It is synchronized so that the renderer knows when it is safe to
// free the shared memory used to transfer the bitmap.
IPC_SYNC_MESSAGE_CONTROL2_0(ViewHostMsg_ClipboardWriteObjectsSync,
Clipboard::ObjectMap /* objects */,
base::SharedMemoryHandle /* bitmap handle */)
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_ClipboardIsFormatAvailable,
std::string /* format */,
Clipboard::Buffer /* buffer */,
bool /* result */)
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_ClipboardReadText,
Clipboard::Buffer /* buffer */,
string16 /* result */)
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_ClipboardReadAsciiText,
Clipboard::Buffer /* buffer */,
std::string /* result */)
IPC_SYNC_MESSAGE_CONTROL1_2(ViewHostMsg_ClipboardReadHTML,
Clipboard::Buffer /* buffer */,
string16 /* markup */,
GURL /* url */)
IPC_SYNC_MESSAGE_CONTROL1_3(ViewHostMsg_ClipboardReadAvailableTypes,
Clipboard::Buffer /* buffer */,
bool /* result */,
std::vector<string16> /* types */,
bool /* contains filenames */)
IPC_SYNC_MESSAGE_CONTROL2_3(ViewHostMsg_ClipboardReadData,
Clipboard::Buffer /* buffer */,
string16 /* type */,
bool /* succeeded */,
string16 /* data */,
string16 /* metadata */)
IPC_SYNC_MESSAGE_CONTROL1_2(ViewHostMsg_ClipboardReadFilenames,
Clipboard::Buffer /* buffer */,
bool /* result */,
std::vector<string16> /* filenames */)
#if defined(OS_MACOSX)
IPC_MESSAGE_CONTROL1(ViewHostMsg_ClipboardFindPboardWriteStringAsync,
string16 /* text */)
// Request that the browser load a font into shared memory for us.
IPC_SYNC_MESSAGE_CONTROL1_2(ViewHostMsg_LoadFont,
FontDescriptor /* font to load */,
uint32 /* buffer size */,
base::SharedMemoryHandle /* font data */)
#endif
#if defined(OS_WIN)
// Request that the given font be loaded by the browser so it's cached by the
// OS. Please see ChildProcessHost::PreCacheFont for details.
IPC_SYNC_MESSAGE_CONTROL1_0(ViewHostMsg_PreCacheFont,
LOGFONT /* font data */)
#endif // defined(OS_WIN)
// Returns WebScreenInfo corresponding to the view.
// TODO(shess): Provide a mapping from reply_msg->routing_id() to
// HWND so that we can eliminate the NativeViewId parameter.
IPC_SYNC_MESSAGE_ROUTED1_1(ViewHostMsg_GetScreenInfo,
gfx::NativeViewId /* view */,
WebKit::WebScreenInfo /* results */)
// Send the tooltip text for the current mouse position to the browser.
IPC_MESSAGE_ROUTED2(ViewHostMsg_SetTooltipText,
std::wstring /* tooltip text string */,
WebKit::WebTextDirection /* text direction hint */)
// Notification that the text selection has changed.
IPC_MESSAGE_ROUTED1(ViewHostMsg_SelectionChanged,
std::string /* currently selected text */)
// Asks the browser to display the file chooser. The result is returned in a
// ViewHost_RunFileChooserResponse message.
IPC_MESSAGE_ROUTED1(ViewHostMsg_RunFileChooser,
ViewHostMsg_RunFileChooser_Params)
// Notification that forms have been seen that are candidates for
// filling/submitting by the AutoFillManager.
IPC_MESSAGE_ROUTED1(ViewHostMsg_FormsSeen,
std::vector<webkit_glue::FormData> /* forms */)
// Notification that password forms have been seen that are candidates for
// filling/submitting by the password manager.
IPC_MESSAGE_ROUTED1(ViewHostMsg_PasswordFormsFound,
std::vector<webkit_glue::PasswordForm> /* forms */)
// Notification that initial layout has occurred and the following password
// forms are visible on the page (e.g. not set to display:none.)
IPC_MESSAGE_ROUTED1(ViewHostMsg_PasswordFormsVisible,
std::vector<webkit_glue::PasswordForm> /* forms */)
// Notification that a form has been submitted. The user hit the button.
IPC_MESSAGE_ROUTED1(ViewHostMsg_FormSubmitted,
webkit_glue::FormData /* form */)
// Used to tell the parent the user started dragging in the content area. The
// WebDropData struct contains contextual information about the pieces of the
// page the user dragged. The parent uses this notification to initiate a
// drag session at the OS level.
IPC_MESSAGE_ROUTED4(ViewHostMsg_StartDragging,
WebDropData /* drop_data */,
WebKit::WebDragOperationsMask /* ops_allowed */,
SkBitmap /* image */,
gfx::Point /* image_offset */)
// The page wants to update the mouse cursor during a drag & drop operation.
// |is_drop_target| is true if the mouse is over a valid drop target.
IPC_MESSAGE_ROUTED1(ViewHostMsg_UpdateDragCursor,
WebKit::WebDragOperation /* drag_operation */)
// Tells the browser to move the focus to the next (previous if reverse is
// true) focusable element.
IPC_MESSAGE_ROUTED1(ViewHostMsg_TakeFocus, bool /* reverse */)
// Notification that the page has an OpenSearch description document
// associated with it.
IPC_MESSAGE_ROUTED3(ViewHostMsg_PageHasOSDD,
int32 /* page_id */,
GURL /* url of OS description document */,
bool /* autodetected */)
// Find out if the given url's security origin is installed as a search
// provider.
IPC_SYNC_MESSAGE_ROUTED2_1(
ViewHostMsg_GetSearchProviderInstallState,
GURL /* page url */,
GURL /* inquiry url */,
ViewHostMsg_GetSearchProviderInstallState_Params /* install */)
// Required for updating text input state.
IPC_MESSAGE_ROUTED2(ViewHostMsg_ImeUpdateTextInputState,
WebKit::WebTextInputType, /* text_input_type */
gfx::Rect /* caret_rect */)
// Required for cancelling an ongoing input method composition.
IPC_MESSAGE_ROUTED0(ViewHostMsg_ImeCancelComposition)
// Tells the browser that the renderer is done calculating the number of
// rendered pages according to the specified settings.
IPC_MESSAGE_ROUTED2(ViewHostMsg_DidGetPrintedPagesCount,
int /* rendered document cookie */,
int /* number of rendered pages */)
// Sends back to the browser the rendered "printed page" that was requested by
// a ViewMsg_PrintPage message or from scripted printing. The memory handle in
// this message is already valid in the browser process.
IPC_MESSAGE_ROUTED1(ViewHostMsg_DidPrintPage,
ViewHostMsg_DidPrintPage_Params /* page content */)
// The renderer wants to know the default print settings.
IPC_SYNC_MESSAGE_ROUTED0_1(ViewHostMsg_GetDefaultPrintSettings,
ViewMsg_Print_Params /* default_settings */)
// It's the renderer that controls the printing process when it is generated
// by javascript. This step is about showing UI to the user to select the
// final print settings. The output parameter is the same as
// ViewMsg_PrintPages which is executed implicitly.
IPC_SYNC_MESSAGE_ROUTED1_1(ViewHostMsg_ScriptedPrint,
ViewHostMsg_ScriptedPrint_Params,
ViewMsg_PrintPages_Params
/* settings chosen by the user*/)
// WebKit and JavaScript error messages to log to the console
// or debugger UI.
IPC_MESSAGE_ROUTED3(ViewHostMsg_AddMessageToConsole,
std::wstring, /* msg */
int32, /* line number */
std::wstring /* source id */)
// Stores new inspector setting in the profile.
IPC_MESSAGE_ROUTED2(ViewHostMsg_UpdateInspectorSetting,
std::string, /* key */
std::string /* value */)
// Wraps an IPC message that's destined to the DevToolsClient on
// DevToolsAgent->browser hop.
IPC_MESSAGE_ROUTED1(ViewHostMsg_ForwardToDevToolsClient,
IPC::Message /* one of DevToolsClientMsg_XXX types */)
// Wraps an IPC message that's destined to the DevToolsAgent on
// DevToolsClient->browser hop.
IPC_MESSAGE_ROUTED1(ViewHostMsg_ForwardToDevToolsAgent,
IPC::Message /* one of DevToolsAgentMsg_XXX types */)
// Activates (brings to the front) corresponding dev tools window.
IPC_MESSAGE_ROUTED0(ViewHostMsg_ActivateDevToolsWindow)
// Closes dev tools window that is inspecting current render_view_host.
IPC_MESSAGE_ROUTED0(ViewHostMsg_CloseDevToolsWindow)
// Attaches dev tools window that is inspecting current render_view_host.
IPC_MESSAGE_ROUTED0(ViewHostMsg_RequestDockDevToolsWindow)
// Detaches dev tools window that is inspecting current render_view_host.
IPC_MESSAGE_ROUTED0(ViewHostMsg_RequestUndockDevToolsWindow)
// Updates runtime features store in devtools manager in order to support
// cross-navigation instrumentation.
IPC_MESSAGE_ROUTED2(ViewHostMsg_DevToolsRuntimePropertyChanged,
std::string /* name */,
std::string /* value */)
// Send back a string to be recorded by UserMetrics.
IPC_MESSAGE_ROUTED1(ViewHostMsg_UserMetricsRecordAction,
std::string /* action */)
// Send back histograms as vector of pickled-histogram strings.
IPC_MESSAGE_CONTROL2(ViewHostMsg_RendererHistograms,
int, /* sequence number of Renderer Histograms. */
std::vector<std::string>)
#if defined USE_TCMALLOC
// Send back tcmalloc stats output.
IPC_MESSAGE_CONTROL2(ViewHostMsg_RendererTcmalloc,
int /* pid */,
std::string /* tcmalloc debug output */)
#endif
// Sends back stats about the V8 heap.
IPC_MESSAGE_CONTROL2(ViewHostMsg_V8HeapStats,
int /* size of heap (allocated from the OS) */,
int /* bytes in use */)
// Request for a DNS prefetch of the names in the array.
// NameList is typedef'ed std::vector<std::string>
IPC_MESSAGE_CONTROL1(ViewHostMsg_DnsPrefetch,
std::vector<std::string> /* hostnames */)
// Notifies when default plugin updates status of the missing plugin.
IPC_MESSAGE_ROUTED1(ViewHostMsg_MissingPluginStatus,
int /* status */)
// Notifies when a non-sandboxed plugin was blocked.
// |plugin| is the identifier for the plugin (currently its path),
// |name| is its user-visible name.
IPC_MESSAGE_ROUTED2(ViewHostMsg_NonSandboxedPluginBlocked,
std::string /* plugin */,
string16 /* name */)
// Notifies when a blocked plugin was loaded via click-to-load.
IPC_MESSAGE_ROUTED0(ViewHostMsg_BlockedPluginLoaded)
// Sent by the renderer process to indicate that a plugin instance has
// crashed.
IPC_MESSAGE_ROUTED1(ViewHostMsg_CrashedPlugin,
FilePath /* plugin_path */)
// Notifies when a plugin couldn't be loaded because it's outdated.
IPC_MESSAGE_ROUTED2(ViewHostMsg_DisabledOutdatedPlugin,
string16, /* name */
GURL /* update_url */)
// Displays a JavaScript out-of-memory message in the infobar.
IPC_MESSAGE_ROUTED0(ViewHostMsg_JSOutOfMemory)
// Displays a box to confirm that the user wants to navigate away from the
// page. Replies true if yes, false otherwise, the reply string is ignored,
// but is included so that we can use OnJavaScriptMessageBoxClosed.
IPC_SYNC_MESSAGE_ROUTED2_2(ViewHostMsg_RunBeforeUnloadConfirm,
GURL, /* in - originating frame URL */
std::wstring /* in - alert message */,
bool /* out - success */,
std::wstring /* out - This is ignored.*/)
IPC_MESSAGE_ROUTED3(ViewHostMsg_SendCurrentPageAllSavableResourceLinks,
std::vector<GURL> /* all savable resource links */,
std::vector<GURL> /* all referrers of resource links */,
std::vector<GURL> /* all frame links */)
IPC_MESSAGE_ROUTED3(ViewHostMsg_SendSerializedHtmlData,
GURL /* frame's url */,
std::string /* data buffer */,
int32 /* complete status */)
IPC_SYNC_MESSAGE_ROUTED4_1(ViewHostMsg_ShowModalHTMLDialog,
GURL /* url */,
int /* width */,
int /* height */,
std::string /* json_arguments */,
std::string /* json_retval */)
IPC_MESSAGE_ROUTED2(ViewHostMsg_DidGetApplicationInfo,
int32 /* page_id */,
webkit_glue::WebApplicationInfo)
// Provides the result from running OnMsgShouldClose. |proceed| matches the
// return value of the the frame's shouldClose method (which includes the
// onbeforeunload handler): true if the user decided to proceed with leaving
// the page.
IPC_MESSAGE_ROUTED1(ViewHostMsg_ShouldClose_ACK,
bool /* proceed */)
// Indicates that the current page has been closed, after a ClosePage
// message. The parameters are just echoed from the ClosePage request.
IPC_MESSAGE_ROUTED1(ViewHostMsg_ClosePage_ACK,
ViewMsg_ClosePage_Params)
IPC_MESSAGE_ROUTED4(ViewHostMsg_DidDownloadFavIcon,
int /* Identifier of the request */,
GURL /* URL of the image */,
bool /* true if there was a network error */,
SkBitmap /* image_data */)
// Sent to query MIME information.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetMimeTypeFromExtension,
FilePath::StringType /* extension */,
std::string /* mime_type */)
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetMimeTypeFromFile,
FilePath /* file_path */,
std::string /* mime_type */)
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetPreferredExtensionForMimeType,
std::string /* mime_type */,
FilePath::StringType /* extension */)
// Get the CPBrowsingContext associated with the renderer sending this
// message.
IPC_SYNC_MESSAGE_CONTROL0_1(ViewHostMsg_GetCPBrowsingContext,
uint32 /* context */)
// Sent when the renderer process is done processing a DataReceived
// message.
IPC_MESSAGE_ROUTED1(ViewHostMsg_DataReceived_ACK,
int /* request_id */)
// Sent when the renderer has processed a DataDownloaded message.
IPC_MESSAGE_ROUTED1(ViewHostMsg_DataDownloaded_ACK,
int /* request_id */)
// Sent when the renderer process deletes a resource loader.
IPC_MESSAGE_CONTROL1(ViewHostMsg_ReleaseDownloadedFile,
int /* request_id */)
// Sent when a provisional load on the main frame redirects.
IPC_MESSAGE_ROUTED3(ViewHostMsg_DidRedirectProvisionalLoad,
int /* page_id */,
GURL /* last url */,
GURL /* url redirected to */)
// Sent by the renderer process to acknowledge receipt of a
// UploadProgress message.
IPC_MESSAGE_ROUTED1(ViewHostMsg_UploadProgress_ACK,
int /* request_id */)
// Sent when the renderer changes the zoom level for a particular url, so the
// browser can update its records.
IPC_MESSAGE_CONTROL2(ViewHostMsg_DidZoomURL,
GURL /* url */,
int /* zoom_level */)
#if defined(OS_WIN)
// Duplicates a shared memory handle from the renderer to the browser. Then
// the renderer can flush the handle.
IPC_SYNC_MESSAGE_ROUTED1_1(ViewHostMsg_DuplicateSection,
base::SharedMemoryHandle /* renderer handle */,
base::SharedMemoryHandle /* browser handle */)
#endif
#if defined(USE_X11)
// Asks the browser to create a temporary file for the renderer to fill
// in resulting NativeMetafile in printing.
IPC_SYNC_MESSAGE_CONTROL0_2(ViewHostMsg_AllocateTempFileForPrinting,
base::FileDescriptor /* temp file fd */,
int /* fd in browser*/)
IPC_MESSAGE_CONTROL1(ViewHostMsg_TempFileForPrintingWritten,
int /* fd in browser */)
#endif
#if defined(OS_MACOSX)
// Asks the browser to create a block of shared memory for the renderer to
// pass NativeMetafile data to the browser.
IPC_SYNC_MESSAGE_ROUTED1_1(ViewHostMsg_AllocatePDFTransport,
uint32 /* buffer size */,
base::SharedMemoryHandle /* browser handle */)
#endif
#if defined(OS_POSIX)
// Asks the browser to create a block of shared memory for the renderer to
// fill in and pass back to the browser.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_AllocateSharedMemoryBuffer,
uint32 /* buffer size */,
base::SharedMemoryHandle /* browser handle */)
#endif
// Provide the browser process with information about the WebCore resource
// cache.
IPC_MESSAGE_CONTROL1(ViewHostMsg_ResourceTypeStats,
WebKit::WebCache::ResourceTypeStats)
// Notify the browser that this render process can or can't be suddenly
// terminated.
IPC_MESSAGE_CONTROL1(ViewHostMsg_SuddenTerminationChanged,
bool /* enabled */)
// Returns the window location of the window this widget is embeded.
// TODO(shess): Provide a mapping from reply_msg->routing_id() to
// HWND so that we can eliminate the NativeViewId parameter.
IPC_SYNC_MESSAGE_ROUTED1_1(ViewHostMsg_GetRootWindowRect,
gfx::NativeViewId /* window */,
gfx::Rect /* Out: Window location */)
// Informs the browser of a new appcache host.
IPC_MESSAGE_CONTROL1(AppCacheMsg_RegisterHost,
int /* host_id */)
// Informs the browser of an appcache host being destroyed.
IPC_MESSAGE_CONTROL1(AppCacheMsg_UnregisterHost,
int /* host_id */)
// Initiates the cache selection algorithm for the given host.
// This is sent prior to any subresource loads. An AppCacheMsg_CacheSelected
// message will be sent in response.
// 'host_id' indentifies a specific document or worker
// 'document_url' the url of the main resource
// 'appcache_document_was_loaded_from' the id of the appcache the main
// resource was loaded from or kNoCacheId
// 'opt_manifest_url' the manifest url specified in the <html> tag if any
IPC_MESSAGE_CONTROL4(AppCacheMsg_SelectCache,
int /* host_id */,
GURL /* document_url */,
int64 /* appcache_document_was_loaded_from */,
GURL /* opt_manifest_url */)
// Initiates worker specific cache selection algorithm for the given host.
IPC_MESSAGE_CONTROL3(AppCacheMsg_SelectCacheForWorker,
int /* host_id */,
int /* parent_process_id */,
int /* parent_host_id */)
IPC_MESSAGE_CONTROL2(AppCacheMsg_SelectCacheForSharedWorker,
int /* host_id */,
int64 /* appcache_id */)
// Informs the browser of a 'foreign' entry in an appcache.
IPC_MESSAGE_CONTROL3(AppCacheMsg_MarkAsForeignEntry,
int /* host_id */,
GURL /* document_url */,
int64 /* appcache_document_was_loaded_from */)
// Returns the status of the appcache associated with host_id.
IPC_SYNC_MESSAGE_CONTROL1_1(AppCacheMsg_GetStatus,
int /* host_id */,
appcache::Status)
// Initiates an update of the appcache associated with host_id.
IPC_SYNC_MESSAGE_CONTROL1_1(AppCacheMsg_StartUpdate,
int /* host_id */,
bool /* success */)
// Swaps a new pending appcache, if there is one, into use for host_id.
IPC_SYNC_MESSAGE_CONTROL1_1(AppCacheMsg_SwapCache,
int /* host_id */,
bool /* success */)
// Gets resource list from appcache synchronously.
IPC_SYNC_MESSAGE_CONTROL1_1(AppCacheMsg_GetResourceList,
int /* host_id in*/,
std::vector<appcache::AppCacheResourceInfo>
/* resources out */)
// Queries the browser for AutoFill suggestions for a form input field.
IPC_MESSAGE_ROUTED3(ViewHostMsg_QueryFormFieldAutoFill,
int /* id of this message */,
bool /* form_autofilled */,
webkit_glue::FormField /* the form field */)
// Instructs the browser to fill in the values for a form using AutoFill
// profile data.
IPC_MESSAGE_ROUTED3(ViewHostMsg_FillAutoFillFormData,
int /* id of this message */,
webkit_glue::FormData /* the form */,
int /* profile unique ID */)
// Instructs the browser to remove the specified Autocomplete entry from the
// database.
IPC_MESSAGE_ROUTED2(ViewHostMsg_RemoveAutocompleteEntry,
string16 /* field name */,
string16 /* value */)
// Instructs the browser to show the AutoFill dialog.
IPC_MESSAGE_ROUTED0(ViewHostMsg_ShowAutoFillDialog)
// Get the list of proxies to use for |url|, as a semicolon delimited list
// of "<TYPE> <HOST>:<PORT>" | "DIRECT". See also
// PluginProcessHostMsg_ResolveProxy which does the same thing.
IPC_SYNC_MESSAGE_CONTROL1_2(ViewHostMsg_ResolveProxy,
GURL /* url */,
int /* network error */,
std::string /* proxy list */)
// Request that got sent to browser for creating an audio output stream
IPC_MESSAGE_ROUTED3(ViewHostMsg_CreateAudioStream,
int /* stream_id */,
ViewHostMsg_Audio_CreateStream_Params,
bool /* low-latency */)
// Tell the browser the audio buffer prepared for stream
// (render_view_id, stream_id) is filled and is ready to be consumed.
IPC_MESSAGE_ROUTED2(ViewHostMsg_NotifyAudioPacketReady,
int /* stream_id */,
uint32 /* packet size */)
// Start buffering and play the audio stream specified by
// (render_view_id, stream_id).
IPC_MESSAGE_ROUTED1(ViewHostMsg_PlayAudioStream,
int /* stream_id */)
// Pause the audio stream specified by (render_view_id, stream_id).
IPC_MESSAGE_ROUTED1(ViewHostMsg_PauseAudioStream,
int /* stream_id */)
// Discard all buffered audio data for the specified audio stream.
IPC_MESSAGE_ROUTED1(ViewHostMsg_FlushAudioStream,
int /* stream_id */)
// Close an audio stream specified by (render_view_id, stream_id).
IPC_MESSAGE_ROUTED1(ViewHostMsg_CloseAudioStream,
int /* stream_id */)
// Get audio volume of the stream specified by (render_view_id, stream_id).
IPC_MESSAGE_ROUTED1(ViewHostMsg_GetAudioVolume,
int /* stream_id */)
// Set audio volume of the stream specified by (render_view_id, stream_id).
// TODO(hclam): change this to vector if we have channel numbers other than 2.
IPC_MESSAGE_ROUTED2(ViewHostMsg_SetAudioVolume,
int /* stream_id */,
double /* volume */)
// A renderer sends this message when an extension process starts an API
// request. The browser will always respond with a ViewMsg_ExtensionResponse.
IPC_MESSAGE_ROUTED1(ViewHostMsg_ExtensionRequest,
ViewHostMsg_DomMessage_Params)
// Notify the browser that this renderer added a listener to an event.
IPC_MESSAGE_CONTROL1(ViewHostMsg_ExtensionAddListener,
std::string /* name */)
// Notify the browser that this renderer removed a listener from an event.
IPC_MESSAGE_CONTROL1(ViewHostMsg_ExtensionRemoveListener,
std::string /* name */)
#if defined(OS_MACOSX)
// On OSX, we cannot allocated shared memory from within the sandbox, so
// this call exists for the renderer to ask the browser to allocate memory
// on its behalf. We return a file descriptor to the POSIX shared memory.
// If the |cache_in_browser| flag is |true|, then a copy of the shmem is kept
// by the browser, and it is the caller's repsonsibility to send a
// ViewHostMsg_FreeTransportDIB message in order to release the cached shmem.
// In all cases, the caller is responsible for deleting the resulting
// TransportDIB.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_AllocTransportDIB,
size_t, /* bytes requested */
bool, /* cache in the browser */
TransportDIB::Handle /* DIB */)
// Since the browser keeps handles to the allocated transport DIBs, this
// message is sent to tell the browser that it may release them when the
// renderer is finished with them.
IPC_MESSAGE_CONTROL1(ViewHostMsg_FreeTransportDIB,
TransportDIB::Id /* DIB id */)
//---------------------------------------------------------------------------
// Messages related to the GPU plugin on Mac OS X 10.6 and later
// This is sent from the renderer to the browser to allocate a fake
// PluginWindowHandle on the browser side which is used to identify
// the plugin to the browser later when backing store is allocated
// or reallocated. |opaque| indicates whether the plugin's output is
// considered to be opaque, as opposed to translucent. This message
// is reused for rendering the accelerated compositor's output.
// |root| indicates whether the output is supposed to cover the
// entire window.
IPC_SYNC_MESSAGE_ROUTED2_1(ViewHostMsg_AllocateFakePluginWindowHandle,
bool /* opaque */,
bool /* root */,
gfx::PluginWindowHandle /* id */)
// Destroys a fake window handle previously allocated using
// AllocateFakePluginWindowHandle.
IPC_MESSAGE_ROUTED1(ViewHostMsg_DestroyFakePluginWindowHandle,
gfx::PluginWindowHandle /* id */)
// This message, used on Mac OS X 10.5 and earlier (no IOSurface support),
// is sent from the renderer to the browser on behalf of the plug-in
// to indicate that a new backing store was allocated for that plug-in
// instance.
IPC_MESSAGE_ROUTED4(ViewHostMsg_AcceleratedSurfaceSetTransportDIB,
gfx::PluginWindowHandle /* window */,
int32 /* width */,
int32 /* height */,
TransportDIB::Handle /* handle for the DIB */)
// This message, used on Mac OS X 10.6 and later (where IOSurface is
// supported), is sent from the renderer to the browser on behalf of the
// plug-in to indicate that a new backing store was allocated for that
// plug-in instance.
//
// NOTE: the original intent was to pass a mach port as the IOSurface
// identifier but it looks like that will be a lot of work. For now we pass an
// ID from IOSurfaceGetID.
IPC_MESSAGE_ROUTED4(ViewHostMsg_AcceleratedSurfaceSetIOSurface,
gfx::PluginWindowHandle /* window */,
int32 /* width */,
int32 /* height */,
uint64 /* identifier for IOSurface */)
// This message notifies the browser process that the plug-in
// swapped the buffers associated with the given "window", which
// should cause the browser to redraw the various plug-ins'
// contents.
IPC_MESSAGE_ROUTED1(ViewHostMsg_AcceleratedSurfaceBuffersSwapped,
gfx::PluginWindowHandle /* window */)
#endif
// A renderer sends this to the browser process when it wants to create a
// worker. The browser will create the worker process if necessary, and
// will return the route id on success. On error returns MSG_ROUTING_NONE.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_CreateWorker,
ViewHostMsg_CreateWorker_Params,
int /* route_id */)
// This message is sent to the browser to see if an instance of this shared
// worker already exists. If so, it returns exists == true. If a
// non-empty name is passed, also validates that the url matches the url of
// the existing worker. If a matching worker is found, the passed-in
// document_id is associated with that worker, to ensure that the worker
// stays alive until the document is detached.
// The route_id returned can be used to forward messages to the worker via
// ForwardToWorker if it exists, otherwise it should be passed in to any
// future call to CreateWorker to avoid creating duplicate workers.
IPC_SYNC_MESSAGE_CONTROL1_3(ViewHostMsg_LookupSharedWorker,
ViewHostMsg_CreateWorker_Params,
bool /* exists */,
int /* route_id */,
bool /* url_mismatch */)
// A renderer sends this to the browser process when a document has been
// detached. The browser will use this to constrain the lifecycle of worker
// processes (SharedWorkers are shut down when their last associated document
// is detached).
IPC_MESSAGE_CONTROL1(ViewHostMsg_DocumentDetached,
uint64 /* document_id */)
// A message sent to the browser on behalf of a renderer which wants to show
// a desktop notification.
IPC_MESSAGE_ROUTED1(ViewHostMsg_ShowDesktopNotification,
ViewHostMsg_ShowNotification_Params)
IPC_MESSAGE_ROUTED1(ViewHostMsg_CancelDesktopNotification,
int /* notification_id */ )
IPC_MESSAGE_ROUTED2(ViewHostMsg_RequestNotificationPermission,
GURL /* origin */,
int /* callback_context */)
IPC_SYNC_MESSAGE_ROUTED1_1(ViewHostMsg_CheckNotificationPermission,
GURL /* source page */,
int /* permission_result */)
// Sent if the worker object has sent a ViewHostMsg_CreateDedicatedWorker
// message and not received a ViewMsg_WorkerCreated reply, but in the
// mean time it's destroyed. This tells the browser to not create the queued
// worker.
IPC_MESSAGE_CONTROL1(ViewHostMsg_CancelCreateDedicatedWorker,
int /* route_id */)
// Wraps an IPC message that's destined to the worker on the renderer->browser
// hop.
IPC_MESSAGE_CONTROL1(ViewHostMsg_ForwardToWorker,
IPC::Message /* message */)
// 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(ViewHostMsg_OpenChannelToExtension,
int /* routing_id */,
std::string /* source_extension_id */,
std::string /* target_extension_id */,
std::string /* channel_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(ViewHostMsg_OpenChannelToTab,
int /* routing_id */,
int /* tab_id */,
std::string /* extension_id */,
std::string /* channel_name */,
int /* port_id */)
// Send a message to an extension process. The handle is the value returned
// by ViewHostMsg_OpenChannelTo*.
IPC_MESSAGE_ROUTED2(ViewHostMsg_ExtensionPostMessage,
int /* port_id */,
std::string /* message */)
// Send a message to an extension process. The handle is the value returned
// by ViewHostMsg_OpenChannelTo*.
IPC_MESSAGE_CONTROL1(ViewHostMsg_ExtensionCloseChannel,
int /* port_id */)
// Sent to notify the browser about renderer accessibility notifications.
// The browser responds with a ViewMsg_AccessibilityNotifications_ACK.
IPC_MESSAGE_ROUTED1(
ViewHostMsg_AccessibilityNotifications,
std::vector<ViewHostMsg_AccessibilityNotification_Params>)
// Message sent from the renderer to the browser to request that the browser
// close all sockets. Used for debugging/testing.
IPC_MESSAGE_CONTROL0(ViewHostMsg_CloseCurrentConnections)
// Message sent from the renderer to the browser to request that the browser
// enable or disable the cache. Used for debugging/testing.
IPC_MESSAGE_CONTROL1(ViewHostMsg_SetCacheMode,
bool /* enabled */)
// Message sent from the renderer to the browser to request that the browser
// clear the cache. Used for debugging/testing.
IPC_SYNC_MESSAGE_CONTROL0_1(ViewHostMsg_ClearCache,
int /* result */)
// Message sent from the renderer to the browser to request that the browser
// enable or disable spdy. Used for debugging/testing/benchmarking.
IPC_MESSAGE_CONTROL1(ViewHostMsg_EnableSpdy,
bool /* enable */)
// Message sent from the renderer to the browser to request that the browser
// cache |data| associated with |url|.
IPC_MESSAGE_CONTROL3(ViewHostMsg_DidGenerateCacheableMetadata,
GURL /* url */,
double /* expected_response_time */,
std::vector<char> /* data */)
// Get the storage area id for a particular origin within a namespace.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_DOMStorageStorageAreaId,
int64 /* namespace_id */,
string16 /* origin */,
int64 /* storage_area_id */)
// Get the length of a storage area.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_DOMStorageLength,
int64 /* storage_area_id */,
unsigned /* length */)
// Get a the ith key within a storage area.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_DOMStorageKey,
int64 /* storage_area_id */,
unsigned /* index */,
NullableString16 /* key */)
// Get a value based on a key from a storage area.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_DOMStorageGetItem,
int64 /* storage_area_id */,
string16 /* key */,
NullableString16 /* value */)
// Set a value that's associated with a key in a storage area.
IPC_SYNC_MESSAGE_ROUTED4_2(ViewHostMsg_DOMStorageSetItem,
int64 /* storage_area_id */,
string16 /* key */,
string16 /* value */,
GURL /* url */,
WebKit::WebStorageArea::Result /* result */,
NullableString16 /* old_value */)
// Remove the value associated with a key in a storage area.
IPC_SYNC_MESSAGE_CONTROL3_1(ViewHostMsg_DOMStorageRemoveItem,
int64 /* storage_area_id */,
string16 /* key */,
GURL /* url */,
NullableString16 /* old_value */)
// Clear the storage area.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_DOMStorageClear,
int64 /* storage_area_id */,
GURL /* url */,
bool /* something_cleared */)
// WebIDBCursor::direction() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBCursorDirection,
int32, /* idb_cursor_id */
int32 /* direction */)
// WebIDBCursor::key() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBCursorKey,
int32, /* idb_cursor_id */
IndexedDBKey)
// WebIDBCursor::value() message.
IPC_SYNC_MESSAGE_CONTROL1_2(ViewHostMsg_IDBCursorValue,
int32, /* idb_cursor_id */
SerializedScriptValue, /* script_value */
IndexedDBKey /* key */)
// WebIDBCursor::update() message.
IPC_MESSAGE_CONTROL3(ViewHostMsg_IDBCursorUpdate,
int32, /* idb_cursor_id */
int32, /* response_id */
SerializedScriptValue /* value */)
// WebIDBCursor::continue() message.
IPC_MESSAGE_CONTROL3(ViewHostMsg_IDBCursorContinue,
int32, /* idb_cursor_id */
int32, /* response_id */
IndexedDBKey /* key */)
// WebIDBCursor::remove() message.
IPC_MESSAGE_CONTROL2(ViewHostMsg_IDBCursorRemove,
int32, /* idb_cursor_id */
int32 /* response_id */)
// WebIDBFactory::open() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBFactoryOpen,
ViewHostMsg_IDBFactoryOpen_Params)
// WebIDBDatabase::name() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBDatabaseName,
int32, /* idb_database_id */
string16 /* name */)
// WebIDBDatabase::description() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBDatabaseDescription,
int32, /* idb_database_id */
string16 /* description */)
// WebIDBDatabase::version() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBDatabaseVersion,
int32, /* idb_database_id */
string16 /* vesion */)
// WebIDBDatabase::objectStores() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBDatabaseObjectStores,
int32, /* idb_database_id */
std::vector<string16> /* objectStores */)
// WebIDBDatabase::createObjectStore() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBDatabaseCreateObjectStore,
ViewHostMsg_IDBDatabaseCreateObjectStore_Params)
// WebIDBDatabase::objectStore() message.
IPC_SYNC_MESSAGE_CONTROL3_2(ViewHostMsg_IDBDatabaseObjectStore,
int32, /* idb_database_id */
string16, /* name */
int32, /* mode */
bool, /* success */
int32 /* idb_object_store_id */)
// WebIDBDatabase::removeObjectStore() message.
IPC_MESSAGE_CONTROL3(ViewHostMsg_IDBDatabaseRemoveObjectStore,
int32, /* idb_database_id */
int32, /* response_id */
string16 /* name */)
// WebIDBDatabase::setVersion() message.
IPC_MESSAGE_CONTROL3(ViewHostMsg_IDBDatabaseSetVersion,
int32, /* idb_database_id */
int32, /* response_id */
string16 /* version */)
// WebIDBDatabase::transaction() message.
// TODO: make this message async. Have the renderer create a
// temporary ID and keep a map in the browser process of real
// IDs to temporary IDs. We can then update the transaction
// to its real ID asynchronously.
IPC_SYNC_MESSAGE_CONTROL4_1(ViewHostMsg_IDBDatabaseTransaction,
int32, /* idb_database_id */
std::vector<string16>, /* object_stores */
int32, /* mode */
int32, /* timeout */
int32 /* idb_transaction_id */)
// WebIDBDatabase::~WebIDBDatabase() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBDatabaseDestroyed,
int32 /* idb_database_id */)
// WebIDBIndex::name() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBIndexName,
int32, /* idb_index_id */
string16 /* name */)
// WebIDBIndex::storeName() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBIndexStoreName,
int32, /* idb_index_id */
string16 /* store_name */)
// WebIDBIndex::keyPath() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBIndexKeyPath,
int32, /* idb_index_id */
NullableString16 /* key_path */)
// WebIDBIndex::unique() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBIndexUnique,
int32, /* idb_unique_id */
bool /* unique */)
// WebIDBIndex::openObjectCursor() message. (Uses openCursor's params though.)
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBIndexOpenObjectCursor,
ViewHostMsg_IDBIndexOpenCursor_Params)
// WebIDBIndex::openCursor() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBIndexOpenCursor,
ViewHostMsg_IDBIndexOpenCursor_Params)
// WebIDBIndex::getObject() message.
IPC_MESSAGE_CONTROL4(ViewHostMsg_IDBIndexGetObject,
int32, /* idb_index_id */
int32, /* response_id */
IndexedDBKey, /* key */
int /* transaction_id */)
// WebIDBIndex::get() message.
IPC_MESSAGE_CONTROL4(ViewHostMsg_IDBIndexGet,
int32, /* idb_index_id */
int32, /* response_id */
IndexedDBKey, /* key */
int /* transaction_id */)
// WebIDBIndex::~WebIDBIndex() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBIndexDestroyed,
int32 /* idb_index_id */)
// WebIDBObjectStore::name() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBObjectStoreName,
int32, /* idb_object_store_id */
string16 /* name */)
// WebIDBObjectStore::keyPath() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBObjectStoreKeyPath,
int32, /* idb_object_store_id */
NullableString16 /* keyPath */)
// WebIDBObjectStore::indexNames() message.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_IDBObjectStoreIndexNames,
int32, /* idb_object_store_id */
std::vector<string16> /* index_names */)
// WebIDBObjectStore::get() message.
IPC_MESSAGE_CONTROL4(ViewHostMsg_IDBObjectStoreGet,
int32, /* idb_object_store_id */
int32, /* response_id */
IndexedDBKey, /* key */
int /* transaction_id */)
// WebIDBObjectStore::put() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBObjectStorePut,
ViewHostMsg_IDBObjectStorePut_Params)
// WebIDBObjectStore::remove() message.
IPC_MESSAGE_CONTROL4(ViewHostMsg_IDBObjectStoreRemove,
int32, /* idb_object_store_id */
int32, /* response_id */
IndexedDBKey, /* key */
int /* transaction_id */)
// WebIDBObjectStore::createIndex() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBObjectStoreCreateIndex,
ViewHostMsg_IDBObjectStoreCreateIndex_Params)
// WebIDBObjectStore::index() message.
IPC_SYNC_MESSAGE_CONTROL2_2(ViewHostMsg_IDBObjectStoreIndex,
int32, /* idb_object_store_id */
string16, /* name */
bool, /* success */
int32 /* idb_index_id */)
// WebIDBObjectStore::removeIndex() message.
IPC_MESSAGE_CONTROL3(ViewHostMsg_IDBObjectStoreRemoveIndex,
int32, /* idb_object_store_id */
int32, /* response_id */
string16 /* name */)
// WebIDBObjectStore::openCursor() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBObjectStoreOpenCursor,
ViewHostMsg_IDBObjectStoreOpenCursor_Params)
// WebIDBObjectStore::~WebIDBObjectStore() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBObjectStoreDestroyed,
int32 /* idb_object_store_id */)
// WebIDBDatabase::~WebIDBCursor() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBCursorDestroyed,
int32 /* idb_cursor_id */)
// IDBTransaction::ObjectStore message.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_IDBTransactionObjectStore,
int32, /* transaction_id */
string16, /* name */
int32 /* object_store_id */)
// WebIDBTransaction::abort() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBTransactionAbort,
int32 /* idb_transaction_id */)
// IDBTransaction::DidCompleteTaskEvents() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBTransactionDidCompleteTaskEvents,
int32 /* idb_transaction_id */)
// WebIDBTransaction::~WebIDBTransaction() message.
IPC_MESSAGE_CONTROL1(ViewHostMsg_IDBTransactionDestroyed,
int32 /* idb_transaction_id */)
// Get file size in bytes. Set result to -1 if failed to get the file size.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetFileSize,
FilePath /* path */,
int64 /* result */)
// Get file modification time in seconds. Set result to 0 if failed to get the
// file modification time.
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetFileModificationTime,
FilePath /* path */,
base::Time /* result */)
// Open the file.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_OpenFile,
FilePath /* path */,
int /* mode */,
IPC::PlatformFileForTransit /* result */)
// Opens a file asynchronously. The response returns a file descriptor
// and an error code from base/platform_file.h.
IPC_MESSAGE_ROUTED3(ViewHostMsg_AsyncOpenFile,
FilePath /* file path */,
int /* flags */,
int /* message_id */)
// Sent by the renderer process to acknowledge receipt of a
// ViewMsg_CSSInsertRequest message and css has been inserted into the frame.
IPC_MESSAGE_ROUTED0(ViewHostMsg_OnCSSInserted)
// Sent by the renderer process to check whether access to web databases is
// granted by content settings. This may block and trigger a cookie prompt.
IPC_SYNC_MESSAGE_ROUTED4_1(ViewHostMsg_AllowDatabase,
std::string /* origin_url */,
string16 /* database name */,
string16 /* database display name */,
unsigned long /* estimated size */,
bool /* result */)
// Asks the browser process to open a DB file with the given name.
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_DatabaseOpenFile,
string16 /* vfs file name */,
int /* desired flags */,
IPC::PlatformFileForTransit /* file_handle */)
// Asks the browser process to delete a DB file
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_DatabaseDeleteFile,
string16 /* vfs file name */,
bool /* whether or not to sync the directory */,
int /* SQLite error code */)
// Asks the browser process to return the attributes of a DB file
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_DatabaseGetFileAttributes,
string16 /* vfs file name */,
int32 /* the attributes for the given DB file */)
// Asks the browser process to return the size of a DB file
IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_DatabaseGetFileSize,
string16 /* vfs file name */,
int64 /* the size of the given DB file */)
// Notifies the browser process that a new database has been opened
IPC_MESSAGE_CONTROL4(ViewHostMsg_DatabaseOpened,
string16 /* origin identifier */,
string16 /* database name */,
string16 /* database description */,
int64 /* estimated size */)
// Notifies the browser process that a database might have been modified
IPC_MESSAGE_CONTROL2(ViewHostMsg_DatabaseModified,
string16 /* origin identifier */,
string16 /* database name */)
// Notifies the browser process that a database is about to close
IPC_MESSAGE_CONTROL2(ViewHostMsg_DatabaseClosed,
string16 /* origin identifier */,
string16 /* database name */)
// Notifies the browser of the language (ISO 639_1 code language, such as fr,
// en, zh...) of the current page.
IPC_MESSAGE_ROUTED1(ViewHostMsg_PageLanguageDetermined,
std::string /* the language */)
// Notifies the browser that a page has been translated.
IPC_MESSAGE_ROUTED4(ViewHostMsg_PageTranslated,
int, /* page id */
std::string /* the original language */,
std::string /* the translated language */,
TranslateErrors::Type /* the error type if available */)
//---------------------------------------------------------------------------
// Socket Stream messages:
// These are messages from the SocketStreamHandle to the browser.
// Open new Socket Stream for the |socket_url| identified by |socket_id|
// in the renderer process.
// The browser starts connecting asynchronously.
// Once Socket Stream connection is established, the browser will send
// ViewMsg_SocketStream_Connected back.
IPC_MESSAGE_CONTROL2(ViewHostMsg_SocketStream_Connect,
GURL /* socket_url */,
int /* socket_id */)
// Request to send data on the Socket Stream.
// SocketStreamHandle can send data at most |max_pending_send_allowed| bytes,
// which is given by ViewMsg_SocketStream_Connected at any time.
// The number of pending bytes can be tracked by size of |data| sent
// and |amount_sent| parameter of ViewMsg_SocketStream_DataSent.
// That is, the following constraints is applied:
// (accumulated total of |data|) - (accumulated total of |amount_sent|)
// <= |max_pending_send_allowed|
// If the SocketStreamHandle ever tries to exceed the
// |max_pending_send_allowed|, the connection will be closed.
IPC_MESSAGE_CONTROL2(ViewHostMsg_SocketStream_SendData,
int /* socket_id */,
std::vector<char> /* data */)
// Request to close the Socket Stream.
// The browser will send ViewMsg_SocketStream_Closed back when the Socket
// Stream is completely closed.
IPC_MESSAGE_CONTROL1(ViewHostMsg_SocketStream_Close,
int /* socket_id */)
//---------------------------------------------------------------------------
// Request for cryptographic operation messages:
// These are messages from the renderer to the browser to perform a
// cryptographic operation.
// Asks the browser process to generate a keypair for grabbing a client
// certificate from a CA (<keygen> tag), and returns the signed public
// key and challenge string.
IPC_SYNC_MESSAGE_CONTROL3_1(ViewHostMsg_Keygen,
uint32 /* key size index */,
std::string /* challenge string */,
GURL /* URL of requestor */,
std::string /* signed public key and challenge */)
// The renderer has tried to spell check a word, but couldn't because no
// dictionary was available to load. Request that the browser find an
// appropriate dictionary and return it.
IPC_MESSAGE_CONTROL0(ViewHostMsg_SpellChecker_RequestDictionary)
IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_SpellChecker_PlatformCheckSpelling,
string16 /* word */,
int /* document tag */,
bool /* correct */)
IPC_SYNC_MESSAGE_CONTROL1_1(
ViewHostMsg_SpellChecker_PlatformFillSuggestionList,
string16 /* word */,
std::vector<string16> /* suggestions */)
//---------------------------------------------------------------------------
// Geolocation services messages
// A GeolocationServiceBridgeImpl in the renderer process has been created.
// This is used to lazily initialize the host dispatchers and related
// Geolocation infrastructure in the browser process.
IPC_MESSAGE_CONTROL1(ViewHostMsg_Geolocation_RegisterDispatcher,
int /* render_view_id */)
// A GeolocationServiceBridgeImpl has been destroyed.
// This is used to let the Geolocation infrastructure do its cleanup.
IPC_MESSAGE_CONTROL1(ViewHostMsg_Geolocation_UnregisterDispatcher,
int /* render_view_id */)
// The |render_view_id| and |bridge_id| representing |host| is requesting
// permission to access geolocation position.
// This will be replied by ViewMsg_Geolocation_PermissionSet.
IPC_MESSAGE_CONTROL3(ViewHostMsg_Geolocation_RequestPermission,
int /* render_view_id */,
int /* bridge_id */,
GURL /* GURL of the frame requesting geolocation */)
// The |render_view_id| and |bridge_id| representing |GURL| is cancelling its
// previous permission request to access geolocation position.
IPC_MESSAGE_CONTROL3(ViewHostMsg_Geolocation_CancelPermissionRequest,
int /* render_view_id */,
int /* bridge_id */,
GURL /* GURL of the frame */)
// The |render_view_id| and |bridge_id| requests Geolocation service to start
// updating.
// This is an asynchronous call, and the browser process may eventually reply
// with the updated geoposition, or an error (access denied, location
// unavailable, etc.)
IPC_MESSAGE_CONTROL4(ViewHostMsg_Geolocation_StartUpdating,
int /* render_view_id */,
int /* bridge_id */,
GURL /* GURL of the frame requesting geolocation */,
bool /* enable_high_accuracy */)
// The |render_view_id| and |bridge_id| requests Geolocation service to stop
// updating.
// Note that the geolocation service may continue to fetch geolocation data
// for other origins.
IPC_MESSAGE_CONTROL2(ViewHostMsg_Geolocation_StopUpdating,
int /* render_view_id */,
int /* bridge_id */)
// The |render_view_id| and |bridge_id| requests Geolocation service to
// suspend.
// Note that the geolocation service may continue to fetch geolocation data
// for other origins.
IPC_MESSAGE_CONTROL2(ViewHostMsg_Geolocation_Suspend,
int /* render_view_id */,
int /* bridge_id */)
// The |render_view_id| and |bridge_id| requests Geolocation service to
// resume.
IPC_MESSAGE_CONTROL2(ViewHostMsg_Geolocation_Resume,
int /* render_view_id */,
int /* bridge_id */)
// Notifies the TabContents that the content being displayed is PDF.
// This allows the browser to handle things such as zooming differently.
IPC_MESSAGE_ROUTED0(ViewHostMsg_SetDisplayingPDFContent)
// Requests the speech input service to start speech recognition on behalf of
// the given |render_view_id|.
IPC_MESSAGE_CONTROL3(ViewHostMsg_SpeechInput_StartRecognition,
int /* render_view_id */,
int /* request id */,
gfx::Rect /* element rect in render view coordinates */)
// Requests the speech input service to cancel speech recognition on behalf of
// the given |render_view_id|. If speech recognition is not happening nor or
// is happening on behalf of some other render view, this call does nothing.
IPC_MESSAGE_CONTROL2(ViewHostMsg_SpeechInput_CancelRecognition,
int /* render_view_id */,
int /* request id */)
// Requests the speech input service to stop audio recording on behalf of
// the given |render_view_id|. Any audio recorded so far will be fed to the
// speech recognizer. If speech recognition is not happening nor or is
// happening on behalf of some other render view, this call does nothing.
IPC_MESSAGE_CONTROL2(ViewHostMsg_SpeechInput_StopRecording,
int /* render_view_id */,
int /* request id */)
//---------------------------------------------------------------------------
// Device orientation services messages:
// A RenderView requests to start receiving device orientation updates.
IPC_MESSAGE_CONTROL1(ViewHostMsg_DeviceOrientation_StartUpdating,
int /* render_view_id */)
// A RenderView requests to stop receiving device orientation updates.
IPC_MESSAGE_CONTROL1(ViewHostMsg_DeviceOrientation_StopUpdating,
int /* render_view_id */)
//---------------------------------------------------------------------------
// FileSystem API messages
// These are messages sent from the renderer to the browser process.
// WebFrameClient::openFileSystem() message.
IPC_MESSAGE_CONTROL4(ViewHostMsg_OpenFileSystemRequest,
int /* request_id */,
GURL /* origin_url */,
fileapi::FileSystemType /* type */,
int64 /* requested_size */)
// WebFileSystem::move() message.
IPC_MESSAGE_CONTROL3(ViewHostMsg_FileSystem_Move,
int /* request_id */,
FilePath /* src path */,
FilePath /* dest path */)
// WebFileSystem::copy() message.
IPC_MESSAGE_CONTROL3(ViewHostMsg_FileSystem_Copy,
int /* request_id */,
FilePath /* src path */,
FilePath /* dest path */)
// WebFileSystem::remove() message.
IPC_MESSAGE_CONTROL2(ViewHostMsg_FileSystem_Remove,
int /* request_id */,
FilePath /* path */)
// WebFileSystem::readMetadata() message.
IPC_MESSAGE_CONTROL2(ViewHostMsg_FileSystem_ReadMetadata,
int /* request_id */,
FilePath /* path */)
// WebFileSystem::create() message.
IPC_MESSAGE_CONTROL5(ViewHostMsg_FileSystem_Create,
int /* request_id */,
FilePath /* path */,
bool /* exclusive */,
bool /* is_directory */,
bool /* recursive */)
// WebFileSystem::exists() messages.
IPC_MESSAGE_CONTROL3(ViewHostMsg_FileSystem_Exists,
int /* request_id */,
FilePath /* path */,
bool /* is_directory */)
// WebFileSystem::readDirectory() message.
IPC_MESSAGE_CONTROL2(ViewHostMsg_FileSystem_ReadDirectory,
int /* request_id */,
FilePath /* path */)
// WebFileWriter::write() message.
IPC_MESSAGE_CONTROL4(ViewHostMsg_FileSystem_Write,
int /* request id */,
FilePath /* file path */,
GURL /* blob URL */,
int64 /* position */)
// WebFileWriter::truncate() message.
IPC_MESSAGE_CONTROL3(ViewHostMsg_FileSystem_Truncate,
int /* request id */,
FilePath /* file path */,
int64 /* length */)
// Pepper's Touch() message.
IPC_MESSAGE_CONTROL4(ViewHostMsg_FileSystem_TouchFile,
int /* request_id */,
FilePath /* path */,
base::Time /* last_access_time */,
base::Time /* last_modified_time */)
// WebFileWriter::cancel() message.
IPC_MESSAGE_CONTROL2(ViewHostMsg_FileSystem_CancelWrite,
int /* request id */,
int /* id of request to cancel */)
//---------------------------------------------------------------------------
// Blob messages:
// Registers a blob URL referring to the specified blob data.
IPC_MESSAGE_CONTROL2(ViewHostMsg_RegisterBlobUrl,
GURL /* url */,
scoped_refptr<webkit_blob::BlobData> /* blob_data */)
// Registers a blob URL referring to the blob data identified by the specified
// source URL.
IPC_MESSAGE_CONTROL2(ViewHostMsg_RegisterBlobUrlFrom,
GURL /* url */,
GURL /* src_url */)
// Unregister a blob URL.
IPC_MESSAGE_CONTROL1(ViewHostMsg_UnregisterBlobUrl, GURL /* url */)
// Suggest results -----------------------------------------------------------
IPC_MESSAGE_ROUTED2(ViewHostMsg_SetSuggestResult,
int32 /* page_id */,
std::string /* suggest */)
// Client-Side Phishing Detector ---------------------------------------------
// Inform the browser that the current URL is phishing according to the
// client-side phishing detector.
IPC_MESSAGE_ROUTED3(ViewHostMsg_DetectedPhishingSite,
GURL /* phishing_url */,
double /* phishing_score */,
SkBitmap /* thumbnail */)
IPC_END_MESSAGES(ViewHost)