author Wes Kocher <>
Tue, 26 Aug 2014 16:34:46 -0700
changeset 223312 fd51c8a61561f9fb627f2e516c3e3bfbb6bde08a
parent 222920 1ed271ffb59cabf5349ed5f08a5799aff60a34ab
child 228080 8b6a2d4be6c0f74427fb07c1550cbdaf85000fc0
permissions -rw-r--r--
Backed out changeset 1ed271ffb59c (bug 786419) bug causing bug 786419 a=backout

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

include protocol PBlob;
include protocol PColorPicker;
include protocol PContent;
include protocol PContentBridge;
include protocol PDocumentRenderer;
include protocol PContentPermissionRequest;
include protocol PFilePicker;
include protocol PRenderFrame;
include protocol POfflineCacheUpdate;
include protocol PIndexedDB;
include DOMTypes;
include JavaScriptTypes;
include URIParams;
include PContentPermission;

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 struct mozilla::layers::FrameMetrics from "FrameMetrics.h";
using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h";
using struct mozilla::layers::ZoomConstraints from "FrameMetrics.h";
using FrameMetrics::ViewID from "FrameMetrics.h";
using mozilla::layout::ScrollingBehavior from "mozilla/layout/RenderFrameUtils.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 nsIMEUpdatePreference from "nsIWidget.h";
using struct nsIntPoint from "nsPoint.h";
using struct nsIntRect from "nsRect.h";
using struct nsIntSize from "nsSize.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 struct nsRect from "nsRect.h";
using class mozilla::WidgetSelectionEvent from "ipc/nsGUIEventIPC.h";
using class mozilla::WidgetTextEvent from "ipc/nsGUIEventIPC.h";
using class mozilla::WidgetTouchEvent from "ipc/nsGUIEventIPC.h";
using struct mozilla::dom::RemoteDOMEvent from "mozilla/dom/TabMessageUtils.h";
using mozilla::dom::ScreenOrientation from "mozilla/dom/ScreenOrientation.h";
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
using mozilla::CSSPoint from "Units.h";
using mozilla::CSSToScreenScale from "Units.h";
using mozilla::CommandInt from "mozilla/EventForwards.h";
using mozilla::layers::GeckoContentController::APZStateChange from "mozilla/layers/GeckoContentController.h";

namespace mozilla {
namespace dom {

struct NativeKeyBinding
  CommandInt[] singleLineCommands;
  CommandInt[] multiLineCommands;
  CommandInt[] richTextCommands;

union MaybeNativeKeyBinding

intr protocol PBrowser
    manager PContent or PContentBridge;

    manages PColorPicker;
    manages PDocumentRenderer;
    manages PContentPermissionRequest;
    manages PFilePicker;
    manages PRenderFrame;
    manages POfflineCacheUpdate;
    manages PIndexedDB;

    AsyncMessage(nsString aMessage, ClonedMessageData aData, CpowEntry[] aCpows,
                 Principal aPrincipal);

     * When child sends this message, parent should move focus to
     * the next or previous focusable element.
    MoveFocus(bool forward);

    Event(RemoteDOMEvent aEvent);

    intr CreateWindow(uint32_t aChromeFlags,
                      bool aCalledFromJS,
                      bool aPositionSpecified,
                      bool aSizeSpecified,
                      nsString aURI,
                      nsString aName,
                      nsString aFeatures,
                      nsString aBaseURI)
      returns (bool windowIsNew, PBrowser window);

    sync SyncMessage(nsString aMessage, ClonedMessageData aData,
                     CpowEntry[] aCpows, Principal aPrincipal)
      returns (nsString[] retval);

    rpc RpcMessage(nsString aMessage, ClonedMessageData aData,
                   CpowEntry[] aCpows, Principal aPrincipal)
      returns (nsString[] retval);

     * The IME sequence number (seqno) parameter is used to make sure
     * that a notification is discarded if it arrives at the chrome process
     * too late. If the notification is late and we accept it, we will have
     * an out-of-date view of the content process, which means events that we
     * dispatch based on this out-of-date view will be wrong also.
     * (see Bug 599550 and Bug 591047 comments 44, 50, and 54)
     * Chrome increments seqno and includes it in each IME event sent to
     * content, and content sends its current seqno back to chrome with each
     * notification. A notification is up-to-date only if the content
     * seqno is the same as the current chrome seqno, meaning no additional
     * event was sent to content before the notification was received
     * On blur, chrome returns the current seqno to content, and content
     * uses it to discard subsequent events until the content seqno and
     * chrome seqno-on-blur match again. These events, meant for the blurred
     * textfield, are discarded to prevent events going to the wrong target

     * Notifies chrome that there is a focus change involving an editable
     * object (input, textarea, document, contentEditable. etc.)
     *  focus        PR_TRUE if editable object is receiving focus
     *               PR_FALSE if losing focus
     *  preference   Native widget preference for IME updates
     *  seqno        Current seqno value on the chrome side
    sync NotifyIMEFocus(bool focus)
      returns (nsIMEUpdatePreference preference, uint32_t seqno);

     * 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
     *  offset       Starting offset of the change
     *  end          Ending offset of the range deleted
     *  newEnd       New ending offset after insertion
     *  causedByComposition true if the change is caused by composition
     *  for insertion, offset == end
     *  for deletion, offset == newEnd
    NotifyIMETextChange(uint32_t offset, uint32_t end, uint32_t newEnd,
                        bool causedByComposition);

     * Notifies chrome that there is a IME compostion rect updated
     *  offset       The starting offset of this rect
     *  rect         The rect of first character of selected IME composition
     *  caretRect    The rect of IME caret
    NotifyIMESelectedCompositionRect(uint32_t offset, nsIntRect rect, nsIntRect caretRect);

     * Notifies chrome that there has been a change in selection
     * Only called when NotifyIMEFocus returns PR_TRUE for mWantUpdates
     *  seqno        Current seqno value on the content side
     *  anchor       Offset where the selection started
     *  focus        Offset where the caret is
     *  causedByComposition true if the change is caused by composition
    NotifyIMESelection(uint32_t seqno, uint32_t anchor, uint32_t focus,
                       bool causedByComposition);

     * Notifies chrome to refresh its text cache 
     *  text         The entire content of the text field
    NotifyIMETextHint(nsString text);

     * Instructs chrome to end any pending composition
     *  cancel       PR_TRUE if composition should be cancelled
     *  composition  Text to commit before ending the composition
     *  if cancel is PR_TRUE,
     *    widget should return empty string for composition
     *  if cancel is PR_FALSE,
     *    widget should return the current composition text
    sync EndIMEComposition(bool cancel) returns (nsString composition);

     * 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.
    RequestFocus(bool canRaise);

    sync GetInputContext() returns (int32_t IMEEnabled, int32_t IMEOpen,
                                    intptr_t NativeIMEContext);

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

     * Return native data of root widget
    sync GetWidgetNativeData() returns (WindowsHandle value);

     * Set the native cursor.
     * @param value
     *   The widget cursor to set.
     * @param force
     *   Invalidate any locally cached cursor settings and force an
     *   update.
    SetCursor(uint32_t value, bool force);

    SetBackgroundColor(nscolor color);

     * Used to set the current text of the status tooltip.
     * Nowadays this is mainly used for link locations on hover.
    SetStatus(uint32_t type, nsString status);

     * Show/hide a tooltip when the mouse hovers over an element in the content
     * document.
    ShowTooltip(uint32_t x, uint32_t y, nsString tooltip);

     * Create an asynchronous color picker on the parent side,
     * but don't open it yet.
    PColorPicker(nsString title, nsString initialColor);

     * Initiates an asynchronous request for permission for the
     * provided principal.
     * @param aRequests
     *   The array of permissions to request.
     * @param aPrincipal
     *   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.
    PContentPermissionRequest(PermissionRequest[] aRequests, Principal aPrincipal);

    PFilePicker(nsString aTitle, int16_t aMode);

     * Create a layout frame (encapsulating a remote layer tree) for
     * the page that is currently loaded in the <browser>.
    sync PRenderFrame()
        returns (ScrollingBehavior scrolling,
                 TextureFactoryIdentifier textureFactoryIdentifier, uint64_t layersId,
                 bool success);

     * Starts an offline application cache update.
     * @param manifestURI
     *   URI of the manifest to fetch, the application cache group ID
     * @param documentURI
     *   URI of the document that referred the manifest
     * @param stickDocument
     *   True if the update was initiated by a document load that referred
     *   a manifest.
     *   False if the update was initiated by applicationCache.update() call.
     *   Tells the update to carry the documentURI to a potential separate 
     *   update of implicit (master) items.
     *   Why this argument? If the document was not found in an offline cache 
     *   before load and refers a manifest and this manifest itself has not 
     *   been changed since the last fetch, we will not do the application 
     *   cache group update. But we must cache the document (identified by the
     *   documentURI). This argument will ensure that a previously uncached 
     *   document will get cached and that we don't re-cache a document that 
     *   has already been cached (stickDocument=false).
    POfflineCacheUpdate(URIParams manifestURI, URIParams documentURI,
                        bool stickDocument);

     * Sets "offline-app" permission for the principal.  Called when we hit
     * a web app with the manifest attribute in <html> and
     * offline-apps.allow_by_default is set to true.
    SetOfflinePermission(Principal principal);

    sync PIndexedDB(nsCString group, nsCString asciiOrigin)
        returns (bool allowed);

     * from inside <iframe mozbrowser> is special.  When the child
     * process calls, 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
     * call, and windowOpened is set to true if we ended up going through with
     * the
     * @param opener the PBrowser whose content called
    sync BrowserFrameOpenWindow(PBrowser opener, nsString aURL,
                                nsString aName, nsString aFeatures)
      returns (bool windowOpened);

     * Instructs the TabParent to forward a request to zoom to a rect given in
     * CSS pixels. This rect is relative to the document.
    ZoomToRect(uint32_t aPresShellId, ViewID aViewId, CSSRect aRect);

     * We know for sure that content has either preventDefaulted or not
     * preventDefaulted. This applies to an entire batch of touch events. It is
     * expected that, if there are any DOM touch listeners, touch events will be
     * batched and only processed for panning and zooming if content does not
     * preventDefault.
    ContentReceivedTouch(ScrollableLayerGuid aGuid, bool aPreventDefault);

     * Updates the zoom constraints for a scrollable frame in this tab.
     * The zoom controller code lives on the parent side and so this allows it to
     * have up-to-date zoom constraints.
    UpdateZoomConstraints(uint32_t aPresShellId, ViewID aViewId, bool aIsRoot,
                          ZoomConstraints aConstraints);

     * 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.
    AsyncAuthPrompt(nsCString uri, nsString realm, uint64_t aCallbackId);


    ReplyKeyEvent(WidgetKeyboardEvent event);

    sync RequestNativeKeyBindings(WidgetKeyboardEvent event)
        returns (MaybeNativeKeyBinding bindings);

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

     * 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.
    Show(nsIntSize size);

    LoadURL(nsCString uri);

    CacheFileDescriptor(nsString path, FileDescriptor fd);

    UpdateDimensions(nsIntRect rect, nsIntSize size, ScreenOrientation orientation) compress;

    UpdateFrame(FrameMetrics frame);

    // The following methods correspond to functions on the GeckoContentController
    // interface in gfx/layers/apz/public/GeckoContentController.h. Refer to documentation
    // in that file for these functions.
    AcknowledgeScrollUpdate(ViewID aScrollId, uint32_t aScrollGeneration);
    HandleDoubleTap(CSSPoint point, ScrollableLayerGuid aGuid);
    HandleSingleTap(CSSPoint point, ScrollableLayerGuid aGuid);
    HandleLongTap(CSSPoint point, ScrollableLayerGuid aGuid);
    HandleLongTapUp(CSSPoint point, ScrollableLayerGuid aGuid);
    NotifyAPZStateChange(ViewID aViewId, APZStateChange aChange, int aArg);

     * Sending an activate message moves focus to the child.


     * @see nsIDOMWindowUtils sendMouseEvent.
    MouseEvent(nsString aType,
               float aX,
               float aY,
               int32_t aButton,
               int32_t aClickCount,
               int32_t aModifiers,
               bool aIgnoreRootScrollFrame);

    RealMouseEvent(WidgetMouseEvent event);
    RealKeyEvent(WidgetKeyboardEvent event, MaybeNativeKeyBinding keyBinding);
    MouseWheelEvent(WidgetWheelEvent event);
    RealTouchEvent(WidgetTouchEvent aEvent, ScrollableLayerGuid aGuid);
    // We use a separate message for touchmove events only to apply
    // compression to them.
    RealTouchMoveEvent(WidgetTouchEvent aEvent, ScrollableLayerGuid aGuid) compress;

     * @see nsIDOMWindowUtils sendKeyEvent.
    KeyEvent(nsString aType,
             int32_t aKeyCode,
             int32_t aCharCode,
             int32_t aModifiers,
             bool aPreventDefault);

    CompositionEvent(WidgetCompositionEvent event);

    TextEvent(WidgetTextEvent event);

    SelectionEvent(WidgetSelectionEvent event);

     * Activate event forwarding from client to parent.
    ActivateFrameEvent(nsString aType, bool capture);

    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|.
    PDocumentRenderer(nsRect documentRect, Matrix transform,
                      nsString bgcolor,
                      uint32_t renderFlags, bool flushLayout,
                      nsIntSize 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.

     * Tell the child side if it has to update it's touchable region
     * to the parent.
    SetUpdateHitRegion(bool aEnabled);

     * Tell the child to update its docShell's active state.
    SetIsDocShellActive(bool aIsActive);

     * 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.

 * FIXME: write protocol!

state LIVE:
    send LoadURL goto LIVE;
    send Destroy goto DYING;

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