diff options
Diffstat (limited to 'dom/ipc/PBrowser.ipdl')
| -rw-r--r-- | dom/ipc/PBrowser.ipdl | 928 |
1 files changed, 928 insertions, 0 deletions
diff --git a/dom/ipc/PBrowser.ipdl b/dom/ipc/PBrowser.ipdl new file mode 100644 index 000000000..249657c26 --- /dev/null +++ b/dom/ipc/PBrowser.ipdl @@ -0,0 +1,928 @@ +/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ +/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +include protocol PBlob; +include protocol PColorPicker; +include protocol PContent; +include protocol PContentBridge; +include protocol PDatePicker; +include protocol PDocAccessible; +include protocol PDocumentRenderer; +include protocol PFilePicker; +include protocol PIndexedDBPermissionRequest; +include protocol PRenderFrame; +include protocol PPluginWidget; +include protocol PRemotePrintJob; +include DOMTypes; +include JavaScriptTypes; +include URIParams; +include PPrintingTypes; +include PTabContext; + + +using class IPC::Principal from "mozilla/dom/PermissionMessageUtils.h"; +using class mozilla::gfx::Matrix from "mozilla/gfx/Matrix.h"; +using struct gfxSize from "gfxPoint.h"; +using CSSRect from "Units.h"; +using CSSSize from "Units.h"; +using mozilla::LayoutDeviceIntRect from "Units.h"; +using mozilla::LayoutDeviceIntPoint from "Units.h"; +using mozilla::LayoutDevicePoint from "Units.h"; +using mozilla::ScreenIntPoint from "Units.h"; +using ScreenIntSize from "Units.h"; +using struct mozilla::layers::FrameMetrics from "FrameMetrics.h"; +using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h"; +using struct mozilla::layers::ZoomConstraints from "FrameMetrics.h"; +using mozilla::layers::MaybeZoomConstraints from "FrameMetrics.h"; +using mozilla::layers::GeckoContentController::TapType from "mozilla/layers/GeckoContentController.h"; +using FrameMetrics::ViewID from "FrameMetrics.h"; +using struct mozilla::void_t from "ipc/IPCMessageUtils.h"; +using mozilla::WindowsHandle from "ipc/IPCMessageUtils.h"; +using nscolor from "nsColor.h"; +using class mozilla::WidgetCompositionEvent from "ipc/nsGUIEventIPC.h"; +using struct mozilla::widget::IMENotification from "nsIWidget.h"; +using struct nsIMEUpdatePreference from "nsIWidget.h"; +using mozilla::gfx::IntSize from "mozilla/gfx/Point.h"; +using mozilla::gfx::IntPoint from "mozilla/gfx/Point.h"; +using mozilla::gfx::IntRect from "mozilla/gfx/Rect.h"; +using class mozilla::ContentCache from "ipc/nsGUIEventIPC.h"; +using class mozilla::WidgetKeyboardEvent from "ipc/nsGUIEventIPC.h"; +using class mozilla::WidgetMouseEvent from "ipc/nsGUIEventIPC.h"; +using class mozilla::WidgetWheelEvent from "ipc/nsGUIEventIPC.h"; +using class mozilla::WidgetDragEvent from "ipc/nsGUIEventIPC.h"; +using struct nsRect from "nsRect.h"; +using class mozilla::WidgetSelectionEvent from "ipc/nsGUIEventIPC.h"; +using class mozilla::WidgetTouchEvent from "ipc/nsGUIEventIPC.h"; +using class mozilla::WidgetPluginEvent from "ipc/nsGUIEventIPC.h"; +using struct mozilla::dom::RemoteDOMEvent from "mozilla/dom/TabMessageUtils.h"; +using mozilla::dom::ScreenOrientationInternal from "mozilla/dom/ScreenOrientation.h"; +using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h"; +using mozilla::CSSToScreenScale from "Units.h"; +using mozilla::CommandInt from "mozilla/EventForwards.h"; +using mozilla::WritingMode from "mozilla/WritingModes.h"; +using mozilla::layers::TouchBehaviorFlags from "mozilla/layers/APZUtils.h"; +using nsIWidget::TouchPointerState from "nsIWidget.h"; +using struct LookAndFeelInt from "mozilla/widget/WidgetMessageUtils.h"; +using class mozilla::dom::MessagePort from "mozilla/dom/MessagePort.h"; +using class mozilla::dom::ipc::StructuredCloneData from "mozilla/dom/ipc/StructuredCloneData.h"; +using mozilla::EventMessage from "mozilla/EventForwards.h"; +using nsEventStatus from "mozilla/EventForwards.h"; +using mozilla::Modifiers from "mozilla/EventForwards.h"; +using nsSizeMode from "nsIWidgetListener.h"; +using mozilla::widget::CandidateWindowPosition from "ipc/nsGUIEventIPC.h"; +using class mozilla::NativeEventData from "ipc/nsGUIEventIPC.h"; +using mozilla::FontRange from "ipc/nsGUIEventIPC.h"; +using mozilla::a11y::IAccessibleHolder from "mozilla/a11y/IPCTypes.h"; + +namespace mozilla { +namespace dom { + +struct NativeKeyBinding +{ + CommandInt[] singleLineCommands; + CommandInt[] multiLineCommands; + CommandInt[] richTextCommands; +}; + +union MaybeNativeKeyBinding +{ + NativeKeyBinding; + void_t; +}; + +struct ShowInfo +{ + nsString name; + bool fullscreenAllowed; + bool isPrivate; + bool fakeShowInfo; + bool isTransparent; + float dpi; + int32_t widgetRounding; + double defaultScale; +}; + +union OptionalShmem +{ + void_t; + Shmem; +}; + +nested(upto inside_cpow) sync protocol PBrowser +{ + manager PContent or PContentBridge; + + manages PColorPicker; + manages PDatePicker; + manages PDocAccessible; + manages PDocumentRenderer; + manages PFilePicker; + manages PIndexedDBPermissionRequest; + manages PRenderFrame; + manages PPluginWidget; + +both: + async AsyncMessage(nsString aMessage, CpowEntry[] aCpows, + Principal aPrincipal, ClonedMessageData aData); + + /** + * Create a layout frame (encapsulating a remote layer tree) for + * the page that is currently loaded in the <browser>. + */ + async PRenderFrame(); + +parent: + /** + * Tell the parent process a new accessible document has been created. + * aParentDoc is the accessible document it was created in if any, and + * aParentAcc is the id of the accessible in that document the new document + * is a child of. aMsaaID is the MSAA id for this content process, and + * is only valid on Windows. Set to 0 on other platforms. aDocCOMProxy + * is also Windows-specific and should be set to 0 on other platforms. + */ + async PDocAccessible(nullable PDocAccessible aParentDoc, uint64_t aParentAcc, + uint32_t aMsaaID, IAccessibleHolder aDocCOMProxy); + + /* + * Creates a new remoted nsIWidget connection for windowed plugins + * in e10s mode. This is always initiated from the child in response + * to windowed plugin creation. + */ + sync PPluginWidget(); + + /** + * Return native data of root widget + */ + nested(inside_cpow) sync GetWidgetNativeData() returns (WindowsHandle value); + + /** + * Sends an NS_NATIVE_CHILD_OF_SHAREABLE_WINDOW to be adopted by the + * widget's shareable window on the chrome side. Only used on Windows. + */ + async SetNativeChildOfShareableWindow(uintptr_t childWindow); + + /** + * When content moves focus from a native plugin window that's a child + * of the native browser window we need to move native focus to the + * browser. Otherwise the plugin window will never relinquish focus. + */ + sync DispatchFocusToTopLevelWindow(); + +parent: + /** + * When child sends this message, parent should move focus to + * the next or previous focusable element or document. + */ + async MoveFocus(bool forward, bool forDocumentNavigation); + + /** + * SizeShellTo request propagation to parent. + * + * aFlag Can indicate if one of the dimensions should be ignored. + * If only one dimension has changed it has to be indicated + * by the nsIEmbeddingSiteWindow::DIM_FLAGS_IGNORE_* flags. + * aShellItemWidth, + * aShellItemHeight On parent side we won't be able to decide the dimensions + * of the shell item parameter in the original SizeShellTo + * call so we send over its dimensions that will be used + * for the actual resize. + **/ + async SizeShellTo(uint32_t aFlag, int32_t aWidth, int32_t aHeight, + int32_t aShellItemWidth, int32_t aShellItemHeight); + + /** + * Called by the child to inform the parent that links are dropped into + * content area. + * + * aLinks A flat array of url, name, and type for each link + */ + async DropLinks(nsString[] aLinks); + + async Event(RemoteDOMEvent aEvent); + + sync SyncMessage(nsString aMessage, ClonedMessageData aData, + CpowEntry[] aCpows, Principal aPrincipal) + returns (StructuredCloneData[] retval); + + nested(inside_sync) sync RpcMessage(nsString aMessage, ClonedMessageData aData, + CpowEntry[] aCpows, Principal aPrincipal) + returns (StructuredCloneData[] retval); + + /** + * Notifies chrome that there is a focus change involving an editable + * object (input, textarea, document, contentEditable. etc.) + * + * contentCache Cache of content + * notification Whole data of the notification + * preference Native widget preference for IME updates + */ + nested(inside_cpow) sync NotifyIMEFocus(ContentCache contentCache, + IMENotification notification) + returns (nsIMEUpdatePreference preference); + + /** + * Notifies chrome that there has been a change in text content + * One call can encompass both a delete and an insert operation + * Only called when NotifyIMEFocus returns PR_TRUE for mWantUpdates + * + * contentCache Cache of content + * notification Whole data of the notification + */ + nested(inside_cpow) async NotifyIMETextChange(ContentCache contentCache, + IMENotification notification); + + /** + * Notifies chrome that there is a IME compostion rect updated + * + * contentCache Cache of content + */ + nested(inside_cpow) async NotifyIMECompositionUpdate(ContentCache contentCache, + IMENotification notification); + + /** + * Notifies chrome that there has been a change in selection + * Only called when NotifyIMEFocus returns PR_TRUE for mWantUpdates + * + * contentCache Cache of content + * notification Whole data of the notification + */ + nested(inside_cpow) async NotifyIMESelection(ContentCache contentCache, + IMENotification notification); + + /** + * Notifies chrome of updating its content cache. + * This is useful if content is modified but we don't need to notify IME. + * + * contentCache Cache of content + */ + nested(inside_cpow) async UpdateContentCache(ContentCache contentCache); + + /** + * Notifies IME of mouse button event on a character in focused editor. + * + * Returns true if the mouse button event is consumd by IME. + */ + nested(inside_cpow) sync NotifyIMEMouseButtonEvent(IMENotification notification) + returns (bool consumedByIME); + + /** + * Notifies chrome to position change + * + * contentCache Cache of content + */ + nested(inside_cpow) async NotifyIMEPositionChange(ContentCache contentCache, + IMENotification notification); + + /** + * Requests chrome to commit or cancel composition of IME. + * + * cancel Set true if composition should be cancelled. + * + * isCommitted Returns true if the request causes composition + * being committed synchronously. + * committedString Returns committed string. The may be non-empty + * string even if cancel is true because IME may + * try to restore selected string which was + * replaced with the composition. + */ + nested(inside_cpow) sync RequestIMEToCommitComposition(bool cancel) + returns (bool isCommitted, nsString committedString); + + /** + * OnEventNeedingAckHandled() is called after a child process dispatches a + * composition event or a selection event which is sent from the parent + * process. + * + * message The message value of the handled event. + */ + nested(inside_cpow) async OnEventNeedingAckHandled(EventMessage message); + + /** + * Tells chrome to start plugin IME. If this results in a string getting + * committed, the result is in aCommitted (otherwise aCommitted is empty). + * + * aKeyboardEvent The event with which plugin IME is to be started + * panelX and panelY Location in screen coordinates of the IME input panel + * (should be just under the plugin) + * aCommitted The string committed during IME -- otherwise empty + */ + nested(inside_cpow) sync StartPluginIME(WidgetKeyboardEvent aKeyboardEvent, + int32_t panelX, int32_t panelY) + returns (nsString aCommitted); + + /** + * Tells chrome (and specifically the appropriate widget) whether or not + * a plugin (inside the widget) has the keyboard focus. Should be sent + * when the keyboard focus changes too or from a plugin. + * + * aFocused Whether or not a plugin is focused + */ + nested(inside_cpow) async SetPluginFocused(bool aFocused); + + /** + * Set IME candidate window by windowless plugin if plugin has focus. + */ + async SetCandidateWindowForPlugin(CandidateWindowPosition aPosition); + + /** + * Notifies the parent process of native key event data received in a + * plugin process directly. + * + * aKeyEventData The native key event data. The actual type copied into + * NativeEventData depending on the caller. Please check + * PluginInstanceChild. + */ + nested(inside_cpow) async OnWindowedPluginKeyEvent(NativeEventData aKeyEventData); + + /** + * When plugin event isn't consumed, call this + */ + async DefaultProcOfPluginEvent(WidgetPluginEvent aEvent); + + /** + * Request that the parent process move focus to the browser's frame. If + * canRaise is true, the window can be raised if it is inactive. + */ + async RequestFocus(bool canRaise); + + /** + * Indicate, based on the current state, that some commands are enabled and + * some are disabled. + */ + async EnableDisableCommands(nsString action, + nsCString[] enabledCommands, + nsCString[] disabledCommands); + + nested(inside_cpow) sync GetInputContext() returns (int32_t IMEEnabled, + int32_t IMEOpen); + + nested(inside_cpow) async SetInputContext(int32_t IMEEnabled, + int32_t IMEOpen, + nsString type, + nsString inputmode, + nsString actionHint, + int32_t cause, + int32_t focusChange); + + sync IsParentWindowMainWidgetVisible() returns (bool visible); + + /** + * Gets the DPI of the screen corresponding to this browser. + */ + sync GetDPI() returns (float value); + + /** + * Gets the default scaling factor of the screen corresponding to this browser. + */ + sync GetDefaultScale() returns (double value); + + /** + * Gets the rounding of coordinates in the widget. + */ + sync GetWidgetRounding() returns (int32_t value); + + /** + * Gets maximum of touch points at current device. + */ + sync GetMaxTouchPoints() returns (uint32_t value); + + /** + * Set the native cursor. + * @param value + * The widget cursor to set. + * @param force + * Invalidate any locally cached cursor settings and force an + * update. + */ + async SetCursor(uint32_t value, bool force); + + /** + * Set the native cursor using a custom image. + * @param cursorData + * Serialized image data. + * @param width + * Width of the image. + * @param height + * Height of the image. + * @param stride + * Stride used in the image data. + * @param format + * Image format, see gfx::SurfaceFormat for possible values. + * @param hotspotX + * Horizontal hotspot of the image, as specified by the css cursor property. + * @param hotspotY + * Vertical hotspot of the image, as specified by the css cursor property. + * @param force + * Invalidate any locally cached cursor settings and force an + * update. + */ + async SetCustomCursor(nsCString cursorData, uint32_t width, uint32_t height, + uint32_t stride, uint8_t format, + uint32_t hotspotX, uint32_t hotspotY, bool force); + + /** + * Used to set the current text of the status tooltip. + * Nowadays this is mainly used for link locations on hover. + */ + async SetStatus(uint32_t type, nsString status); + + /** + * Show/hide a tooltip when the mouse hovers over an element in the content + * document. + */ + async ShowTooltip(uint32_t x, uint32_t y, nsString tooltip, nsString direction); + async HideTooltip(); + + /** + * Create an asynchronous color picker on the parent side, + * but don't open it yet. + */ + async PColorPicker(nsString title, nsString initialColor); + + /** + * Create an asynchronous date picker on the parent side, + * but don't open it yet. + */ + async PDatePicker(nsString title, nsString initialDate); + + async PFilePicker(nsString aTitle, int16_t aMode); + + /** + * Initiates an asynchronous request for one of the special indexedDB + * permissions for the provided principal. + * + * @param principal + * The principal of the request. + * + * NOTE: The principal is untrusted in the parent process. Only + * principals that can live in the content process should + * provided. + */ + async PIndexedDBPermissionRequest(Principal principal); + + /** + * window.open from inside <iframe mozbrowser> is special. When the child + * process calls window.open, it creates a new PBrowser (in its own + * process), then calls BrowserFrameOpenWindow on it. + * + * The parent process gets a chance to accept or reject the window.open + * call, and windowOpened is set to true if we ended up going through with + * the window.open. + * + * @param opener the PBrowser whose content called window.open. + */ + sync BrowserFrameOpenWindow(PBrowser opener, PRenderFrame renderFrame, + nsString aURL, nsString aName, nsString aFeatures) + returns (bool windowOpened, + TextureFactoryIdentifier textureFactoryIdentifier, + uint64_t layersId); + + /** + * Tells the containing widget whether the given input block results in a + * swipe. Should be called in response to a WidgetWheelEvent that has + * mFlags.mCanTriggerSwipe set on it. + */ + async RespondStartSwipeEvent(uint64_t aInputBlockId, bool aStartSwipe); + + /** + * Brings up the auth prompt dialog. + * Called when this is the PBrowserParent for a nested remote iframe. + * aCallbackId corresponds to an nsIAuthPromptCallback that lives in the + * root process. It will be passed back to the root process with either the + * OnAuthAvailable or OnAuthCancelled message. + */ + async AsyncAuthPrompt(nsCString uri, nsString realm, uint64_t aCallbackId); + + /** + * Look up dictionary by selected word for OSX + * + * @param aText The word to look up + * @param aFontRange Text decoration of aText + * @param aIsVertical true if vertical layout + */ + async LookUpDictionary(nsString aText, FontRange[] aFontRangeArray, + bool aIsVertical, LayoutDeviceIntPoint aPoint); + + async __delete__(); + + async ReplyKeyEvent(WidgetKeyboardEvent event); + + async DispatchAfterKeyboardEvent(WidgetKeyboardEvent event); + + sync RequestNativeKeyBindings(WidgetKeyboardEvent event) + returns (MaybeNativeKeyBinding bindings); + + async SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout, + int32_t aNativeKeyCode, + uint32_t aModifierFlags, + nsString aCharacters, + nsString aUnmodifiedCharacters, + uint64_t aObserverId); + async SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint, + uint32_t aNativeMessage, + uint32_t aModifierFlags, + uint64_t aObserverId); + async SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint, + uint64_t aObserverId); + async SynthesizeNativeMouseScrollEvent(LayoutDeviceIntPoint aPoint, + uint32_t aNativeMessage, + double aDeltaX, + double aDeltaY, + double aDeltaZ, + uint32_t aModifierFlags, + uint32_t aAdditionalFlags, + uint64_t aObserverId); + async SynthesizeNativeTouchPoint(uint32_t aPointerId, + TouchPointerState aPointerState, + LayoutDeviceIntPoint aPoint, + double aPointerPressure, + uint32_t aPointerOrientation, + uint64_t aObserverId); + async SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint, + bool aLongTap, + uint64_t aObserverId); + async ClearNativeTouchSequence(uint64_t aObserverId); + + /** + * Returns the number of tabs in the window via the out parameter. + * If the number of tabs can't be determined, returns 0. + * + * @param aValue where to store the tab count + */ + sync GetTabCount() returns (uint32_t value); + + async AccessKeyNotHandled(WidgetKeyboardEvent event); + +child: + async NativeSynthesisResponse(uint64_t aObserverId, nsCString aResponse); + + +parent: + + /** + * Child informs the parent that the graphics objects are ready for + * compositing. This is sent when all pending changes have been + * sent to the compositor and are ready to be shown on the next composite. + * @see PCompositor + * @see RequestNotifyAfterRemotePaint + */ + async RemotePaintIsReady(); + + /** + * Child informs the parent that the layer tree is already available. + */ + async ForcePaintNoOp(uint64_t aLayerObserverEpoch); + + /** + * Sent by the child to the parent to inform it that an update to the + * dimensions has been requested, likely through win.moveTo or resizeTo + */ + async SetDimensions(uint32_t aFlags, int32_t aX, int32_t aY, int32_t aCx, int32_t aCy); + + nested(inside_sync) sync DispatchWheelEvent(WidgetWheelEvent event); + nested(inside_sync) sync DispatchMouseEvent(WidgetMouseEvent event); + nested(inside_sync) sync DispatchKeyboardEvent(WidgetKeyboardEvent event); + + async InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action, + OptionalShmem visualData, + uint32_t stride, uint8_t format, + LayoutDeviceIntRect dragRect); + + async AudioChannelActivityNotification(uint32_t aAudioChannel, + bool aActive); + + // After a compositor reset, it is necessary to reconnect each layers ID to + // the compositor of the widget that will render those layers. Note that + // this is sync so we can ensure that messages to the window compositor + // arrive before the TabChild attempts to use its cross-process compositor + // bridge. + sync EnsureLayersConnected(); + + /** + * Notify parent that one or more entries have been added / removed from + * the child session history. + * + * @param aCount the updated number of entries in child session history + */ + async NotifySessionHistoryChange(uint32_t aCount); + + /** + * When the session history is across multiple root docshells, this function + * is used to notify parent that it needs to navigate to an entry out of + * local index of the child. + * + * @param aGlobalIndex The global index of history entry to navigate to. + */ + async RequestCrossBrowserNavigation(uint32_t aGlobalIndex); + +child: + /** + * Notify the remote browser that it has been Show()n on this + * side, with the given |visibleRect|. This message is expected + * to trigger creation of the remote browser's "widget". + * + * |Show()| and |Move()| take IntSizes rather than Rects because + * content processes always render to a virtual <0, 0> top-left + * point. + */ + async Show(ScreenIntSize size, + ShowInfo info, + TextureFactoryIdentifier textureFactoryIdentifier, + uint64_t layersId, + nullable PRenderFrame renderFrame, + bool parentIsActive, + nsSizeMode sizeMode); + + async LoadURL(nsCString uri, ShowInfo info); + + async UpdateDimensions(CSSRect rect, CSSSize size, + ScreenOrientationInternal orientation, + LayoutDeviceIntPoint clientOffset, + LayoutDeviceIntPoint chromeDisp) compressall; + + async SizeModeChanged(nsSizeMode sizeMode); + + /** + * Sending an activate message moves focus to the child. + */ + async Activate(); + + async Deactivate(); + + async ParentActivated(bool aActivated); + + async SetKeyboardIndicators(UIStateChangeType showAccelerators, + UIStateChangeType showFocusRings); + + /** + * StopIMEStateManagement() is called when the process loses focus and + * should stop managing IME state. + */ + async StopIMEStateManagement(); + + /** + * MenuKeyboardListenerInstalled() is called when menu keyboard listener + * is installed in the parent process. + */ + async MenuKeyboardListenerInstalled(bool aInstalled); + + /** + * @see nsIDOMWindowUtils sendMouseEvent. + */ + async MouseEvent(nsString aType, + float aX, + float aY, + int32_t aButton, + int32_t aClickCount, + int32_t aModifiers, + bool aIgnoreRootScrollFrame); + + /** + * When two consecutive mouse move events would be added to the message queue, + * they are 'compressed' by dumping the oldest one. + */ + async RealMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId) compress; + /** + * Mouse move events with |reason == eSynthesized| are sent via a separate + * message because they do not generate DOM 'mousemove' events, and the + * 'compress' attribute on RealMouseMoveEvent() could result in a + * |reason == eReal| event being dropped in favour of an |eSynthesized| + * event, and thus a DOM 'mousemove' event to be lost. + */ + async SynthMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId); + async RealMouseButtonEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId); + async RealKeyEvent(WidgetKeyboardEvent event, MaybeNativeKeyBinding keyBinding); + async MouseWheelEvent(WidgetWheelEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId); + async RealTouchEvent(WidgetTouchEvent aEvent, + ScrollableLayerGuid aGuid, + uint64_t aInputBlockId, + nsEventStatus aApzResponse); + async HandleTap(TapType aType, LayoutDevicePoint point, Modifiers aModifiers, + ScrollableLayerGuid aGuid, uint64_t aInputBlockId); + async RealTouchMoveEvent(WidgetTouchEvent aEvent, + ScrollableLayerGuid aGuid, + uint64_t aInputBlockId, + nsEventStatus aApzResponse); + async RealDragEvent(WidgetDragEvent aEvent, uint32_t aDragAction, uint32_t aDropEffect); + async PluginEvent(WidgetPluginEvent aEvent); + + /** + * @see nsIDOMWindowUtils sendKeyEvent. + */ + async KeyEvent(nsString aType, + int32_t aKeyCode, + int32_t aCharCode, + int32_t aModifiers, + bool aPreventDefault); + + async CompositionEvent(WidgetCompositionEvent event); + + async SelectionEvent(WidgetSelectionEvent event); + + /** + * Call PasteTransferable via a controller on the content process + * to handle the command content event, "pasteTransferable". + */ + async PasteTransferable(IPCDataTransfer aDataTransfer, + bool aIsPrivateData, + Principal aRequestingPrincipal); + + /** + * Activate event forwarding from client to parent. + */ + async ActivateFrameEvent(nsString aType, bool capture); + + async LoadRemoteScript(nsString aURL, bool aRunInGlobalScope); + + /** + * Create a asynchronous request to render whatever document is + * loaded in the child when this message arrives. When the + * request finishes, PDocumentRenderer:__delete__ is sent back to + * this side to notify completion. + * + * |documentRect| is the area of the remote document to draw, + * transformed by |transform|. The rendered area will have the + * default background color |bgcolor|. |renderFlags| are the + * nsIPresShell::RenderDocument() flags to use on the remote side, + * and if true, |flushLayout| will do just that before rendering + * the document. The rendered image will be of size |renderSize|. + */ + async PDocumentRenderer(nsRect documentRect, Matrix transform, + nsString bgcolor, + uint32_t renderFlags, bool flushLayout, + IntSize renderSize); + + /** + * Sent by the chrome process when it no longer wants this remote + * <browser>. The child side cleans up in response, then + * finalizing its death by sending back __delete__() to the + * parent. + */ + async Destroy(); + + /** + * Update the child side docShell active (resource use) state. + * + * @param aIsActive + * Whether to activate or deactivate the docshell. + * @param aPreserveLayers + * Whether layer trees should be preserved for inactive docshells. + * @param aLayerObserverEpoch + * The layer observer epoch for this activation. This message should be + * ignored if this epoch has already been observed (via ForcePaint). + */ + async SetDocShellIsActive(bool aIsActive, bool aPreserveLayers, uint64_t aLayerObserverEpoch); + + /** + * Notify the child that it shouldn't paint the offscreen displayport. + * This is useful to speed up interactive operations over async + * scrolling performance like resize, tabswitch, pageload. + * + * Each enable call must be matched with a disable call. The child + * will remain in the suppress mode as long as there's + * a single unmatched call. + */ + async SuppressDisplayport(bool aEnabled); + + /** + * Navigate by key (Tab/Shift+Tab/F6/Shift+f6). + */ + async NavigateByKey(bool aForward, bool aForDocumentNavigation); + + /** + * The parent (chrome thread) requests that the child inform it when + * the graphics objects are ready to display. + * @see PCompositor + * @see RemotePaintIsReady + */ + async RequestNotifyAfterRemotePaint(); + + /** + * Tell the child that the UI resolution changed for the containing + * window. + * To avoid some sync messages from child to parent, we also send the dpi + * and default scale with the notification. + * If we don't know the dpi and default scale, we just pass in a negative + * value (-1) but in the majority of the cases this saves us from two + * sync requests from the child to the parent. + */ + async UIResolutionChanged(float dpi, int32_t rounding, double scale); + + /** + * Tell the child that the system theme has changed, and that a repaint + * is necessary. + */ + async ThemeChanged(LookAndFeelInt[] lookAndFeelIntCache); + + /** + * Tell the browser that its frame loader has been swapped + * with another. + */ + async SwappedWithOtherRemoteLoader(IPCTabContext context); + + /** + * A potential accesskey was just pressed. Look for accesskey targets + * using the list of provided charCodes. + * + * @param event keyboard event + * @param isTrusted true if triggered by a trusted key event + * @param modifierMask indicates which accesskey modifiers are pressed + */ + async HandleAccessKey(WidgetKeyboardEvent event, + uint32_t[] charCodes, int32_t modifierMask); + + /** + * Propagate a refresh to the child process + */ + async AudioChannelChangeNotification(uint32_t aAudioChannel, + float aVolume, + bool aMuted); + + /** + * Tells the root child docShell whether or not to use + * global history. This is sent right after the PBrowser + * is bound to a frameloader element. + */ + async SetUseGlobalHistory(bool aUse); + + /** + * HandledWindowedPluginKeyEvent() is always called after posting a native + * key event with OnWindowedPluginKeyEvent(). + * + * @param aKeyEventData The key event which was posted to the parent + * process. + * @param aIsConsumed true if aKeyEventData is consumed in the + * parent process. Otherwise, false. + */ + async HandledWindowedPluginKeyEvent(NativeEventData aKeyEventData, + bool aIsConsumed); + + /** + * Tell the child to print the current page with the given settings. + * + * @param aOuterWindowID the ID of the outer window to print + * @param aPrintData the serialized settings to print with + */ + async Print(uint64_t aOuterWindowID, PrintData aPrintData); + + /** + * Update the child with the tab's current top-level native window handle. + * This is used by a11y objects who must expose their native window. + * + * @param aNewHandle The native window handle of the tab's top-level window. + */ + async UpdateNativeWindowHandle(uintptr_t aNewHandle); + + /** + * Called when the session history of this particular PBrowser has been + * attached to a grouped session history. + * + * @param aOffset The number of entries in the grouped session + * history before this session history object. + */ + async NotifyAttachGroupedSessionHistory(uint32_t aOffset); + + /** + * Notify that the session history associated to this PBrowser has become + * the active history in the grouped session history. + * + * @param aGlobalLength The up-to-date number of entries in the grouped + * session history. + * @param aTargetLocalIndex The target local index to navigate to. + */ + async NotifyPartialSessionHistoryActive(uint32_t aGlobalLength, + uint32_t aTargetLocalIndex); + + /** + * Notify that the session history asssociates to this PBrowser has become + * an inactive history in the grouped session history. + */ + async NotifyPartialSessionHistoryDeactive(); + + /** + * Tell the child that it is a fresh process created for a Large-Allocation + * load. + */ + async SetFreshProcess(); + +/* + * FIXME: write protocol! + +state LIVE: + send LoadURL goto LIVE; +//etc. + send Destroy goto DYING; + +state DYING: + discard send blah; +// etc. + recv __delete__; + */ +}; + +} +} |