The Tor Browser / file revision

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

 {

   NativeKeyBinding;

   void_t;

 };

 intr protocol PBrowser

 {

     manager PContent;

     manages PColorPicker;

     manages PDocumentRenderer;

     manages PContentPermissionRequest;

     manages PFilePicker;

     manages PRenderFrame;

     manages POfflineCacheUpdate;

     manages PIndexedDB;

 both:

     AsyncMessage(nsString aMessage, ClonedMessageData aData, CpowEntry[] aCpows,

                  Principal aPrincipal);

 parent:

     /**

      * When child sends this message, parent should move focus to

      * the next or previous focusable element.

      */

     MoveFocus(bool forward);

     Event(RemoteDOMEvent aEvent);

     intr CreateWindow() returns (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);

     SetCursor(uint32_t value);

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

     HideTooltip();

     /**

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

     sync InitRenderFrame(PRenderFrame aFrame)

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

     /**

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

     __delete__();

     ReplyKeyEvent(WidgetKeyboardEvent event);

     sync RequestNativeKeyBindings(WidgetKeyboardEvent event)

         returns (MaybeNativeKeyBinding bindings);

 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.

      */

     Show(nsIntSize size);

     LoadURL(nsCString uri);

     CacheFileDescriptor(nsString path, FileDescriptor fd);

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

     UpdateFrame(FrameMetrics frame);

     /**

      * Acknowledge the receipt of a scroll offset update from the content

      * process. This is used to manage concurrent scroll updates from many

      * sources.

      */

     AcknowledgeScrollUpdate(ViewID aScrollId, uint32_t aScrollGeneration);

     /**

      * Requests handling of a double tap. |point| is in CSS pixels, relative to

      * the scroll offset. This message is expected to round-trip back to

      * ZoomToRect() with a rect indicating where we should zoom to.

      */

     HandleDoubleTap(CSSPoint point, ScrollableLayerGuid aGuid);

     /**

      * Requests handling of a single tap. |point| is in CSS pixels, relative to

      * the scroll offset. This message is expected to send a "mousedown" and

      * "mouseup" series of events at this point.

      */

     HandleSingleTap(CSSPoint point, ScrollableLayerGuid aGuid);

     /**

      * Requests handling of a long tap. |point| is in CSS pixels, relative to

      * the scroll offset. This message is expected to send a "contextmenu"

      * events at this point.

      */

     HandleLongTap(CSSPoint point, ScrollableLayerGuid aGuid);

     /**

      * Requests handling of releasing a long tap. |aPoint| is in CSS pixels,

      * relative to the current scroll offset. In the case the "contextmenu"

      * event generated by the preceding HandleLongTap call was not handled,

      * this message is expected to generate a "mousedown" and "mouseup"

      * series of events

      */

     HandleLongTapUp(CSSPoint point, ScrollableLayerGuid aGuid);

     /**

      * Notifies the child about various APZ state changes.

      * See GeckoContentController::NotifyAPZStateChange() for details.

      */

     NotifyAPZStateChange(ViewID aViewId, APZStateChange aChange, int aArg);

     /**

      * Sending an activate message moves focus to the child.

      */

     Activate();

     Deactivate();

     /**

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

      */

     Destroy();

     /**

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

 /*

  * FIXME: write protocol!

 state LIVE:

     send LoadURL goto LIVE;

 //etc.

     send Destroy goto DYING;

 state DYING:

     discard send blah;

 // etc.

     recv __delete__;

  */

 };

 }

 }