dom/ipc/PBrowser.ipdl
author Masayuki Nakano <masayuki@d-toybox.com>
Tue, 11 Apr 2017 21:24:55 +0900
changeset 403003 8d081bf9b8399146949f67da496c287c67cd3317
parent 402545 4b455ab566a205ad6f37eadd1f3400ac01203ec1
child 404601 1024114af6819f88f0d3383158fd4bcf7b8a30fb
permissions -rw-r--r--
Bug 1296220 Rename nsIMEUpdatePreference to mozilla::widget::IMEUpdatePreference r=m_kato MozReview-Commit-ID: 2rIXTlwA6my

/* -*- 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 PDocAccessible;
include protocol PDocumentRenderer;
include protocol PFilePicker;
include protocol PIndexedDBPermissionRequest;
include protocol PRenderFrame;
include protocol PPluginWidget;
include protocol PRemotePrintJob;
include protocol PChildToParentStream;
include protocol PParentToChildStream;
include protocol PFileDescriptorSet;
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::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 "mozilla/widget/IMEData.h";
using struct mozilla::widget::IMENotificationRequests from "mozilla/widget/IMEData.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::layers::CompositorOptions from "mozilla/layers/CompositorOptions.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 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
     *  requests     Requests of notification for IME of the native widget
     */
    nested(inside_cpow) sync NotifyIMEFocus(ContentCache contentCache,
                                            IMENotification notification)
      returns (IMENotificationRequests requests);

    /**
     * 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);

    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,
               CompositorOptions compositorOptions);

    /**
     * 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);

    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() returns (CompositorOptions compositorOptions);

    /**
     * Notify the parent that the session history state has been updated.
     *
     * @param aCount
     *        The updated number of entries in child session history
     * @param aLocalIndex
     *        The local session history index which is loaded.
     */
    async SHistoryUpdate(uint32_t aCount, uint32_t aLocalIndex, bool aTruncate);

    /**
     * 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,
               bool parentIsActive,
               nsSizeMode sizeMode);

    async InitRendering(TextureFactoryIdentifier textureFactoryIdentifier,
                        uint64_t layersId,
                        CompositorOptions compositorOptions,
                        bool layersConnected,
                        nullable PRenderFrame renderFrame);

    async LoadURL(nsCString uri, ShowInfo info);

    async UpdateDimensions(CSSRect rect, CSSSize size,
                           ScreenOrientationInternal orientation,
                           LayoutDeviceIntPoint clientOffset,
                           LayoutDeviceIntPoint chromeDisp) compressall;

    async SizeModeChanged(nsSizeMode sizeMode);

    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 NotifyAttachGroupedSHistory(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 NotifyPartialSHistoryActive(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 NotifyPartialSHistoryDeactive();

    /**
     * Tell the TabChild that it should expect a Large-Allocation load to occur.
     * Loads which occur until this flag is cleared will not leave the process.
     */
    async AwaitLargeAlloc();

/*
 * FIXME: write protocol!

state LIVE:
    send LoadURL goto LIVE;
//etc.
    send Destroy goto DYING;

state DYING:
    discard send blah;
// etc.
    recv __delete__;
 */
};

}
}