2009-09-09 22:00:14 +00:00
|
|
|
/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */
|
2009-08-18 19:05:15 +00:00
|
|
|
/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
|
|
|
|
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
2009-08-25 23:07:22 +00:00
|
|
|
|
2012-08-02 06:02:29 +00:00
|
|
|
include protocol PBlob;
|
2014-02-23 20:19:43 +00:00
|
|
|
include protocol PColorPicker;
|
2010-07-19 18:33:33 +00:00
|
|
|
include protocol PContent;
|
2014-06-11 05:44:13 +00:00
|
|
|
include protocol PContentBridge;
|
2015-05-21 17:04:58 +00:00
|
|
|
include protocol PDocAccessible;
|
2010-04-27 07:12:38 +00:00
|
|
|
include protocol PDocumentRenderer;
|
2014-02-18 00:30:06 +00:00
|
|
|
include protocol PFilePicker;
|
2014-09-26 23:21:57 +00:00
|
|
|
include protocol PIndexedDBPermissionRequest;
|
2010-08-20 23:24:41 +00:00
|
|
|
include protocol PRenderFrame;
|
2014-11-12 20:59:18 +00:00
|
|
|
include protocol PPluginWidget;
|
2012-08-23 19:33:46 +00:00
|
|
|
include DOMTypes;
|
2013-07-10 22:05:39 +00:00
|
|
|
include JavaScriptTypes;
|
2012-08-23 19:33:46 +00:00
|
|
|
include URIParams;
|
2015-04-23 23:41:00 +00:00
|
|
|
include BrowserConfiguration;
|
2009-09-09 22:00:14 +00:00
|
|
|
|
2012-08-02 06:02:29 +00:00
|
|
|
|
2013-10-01 19:25:07 +00:00
|
|
|
using class IPC::Principal from "mozilla/dom/PermissionMessageUtils.h";
|
2014-06-19 00:57:51 +00:00
|
|
|
using class mozilla::gfx::Matrix from "mozilla/gfx/Matrix.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
using struct gfxSize from "gfxPoint.h";
|
|
|
|
using CSSRect from "Units.h";
|
2015-06-08 05:39:28 +00:00
|
|
|
using CSSSize from "Units.h";
|
2015-12-03 05:45:38 +00:00
|
|
|
using mozilla::LayoutDeviceIntRect from "Units.h";
|
2015-04-07 13:00:05 +00:00
|
|
|
using mozilla::LayoutDeviceIntPoint from "Units.h";
|
2015-12-03 05:45:38 +00:00
|
|
|
using mozilla::ScreenIntPoint from "Units.h";
|
2015-03-05 09:13:05 +00:00
|
|
|
using ScreenIntSize from "Units.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
using struct mozilla::layers::FrameMetrics from "FrameMetrics.h";
|
2013-11-13 18:20:31 +00:00
|
|
|
using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h";
|
2014-01-06 18:26:44 +00:00
|
|
|
using struct mozilla::layers::ZoomConstraints from "FrameMetrics.h";
|
2015-06-17 16:32:41 +00:00
|
|
|
using mozilla::layers::MaybeZoomConstraints from "FrameMetrics.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
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";
|
2014-09-11 13:46:17 +00:00
|
|
|
using struct mozilla::widget::IMENotification from "nsIWidget.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
using struct nsIMEUpdatePreference from "nsIWidget.h";
|
2015-03-29 14:59:08 +00:00
|
|
|
using mozilla::gfx::IntSize from "mozilla/gfx/Point.h";
|
2015-04-21 15:04:57 +00:00
|
|
|
using mozilla::gfx::IntPoint from "mozilla/gfx/Point.h";
|
|
|
|
using mozilla::gfx::IntRect from "mozilla/gfx/Rect.h";
|
2015-06-05 09:28:20 +00:00
|
|
|
using class mozilla::ContentCache from "ipc/nsGUIEventIPC.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
using class mozilla::WidgetKeyboardEvent from "ipc/nsGUIEventIPC.h";
|
|
|
|
using class mozilla::WidgetMouseEvent from "ipc/nsGUIEventIPC.h";
|
|
|
|
using class mozilla::WidgetWheelEvent from "ipc/nsGUIEventIPC.h";
|
2015-04-08 18:48:11 +00:00
|
|
|
using class mozilla::WidgetDragEvent from "ipc/nsGUIEventIPC.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
using struct nsRect from "nsRect.h";
|
|
|
|
using class mozilla::WidgetSelectionEvent from "ipc/nsGUIEventIPC.h";
|
|
|
|
using class mozilla::WidgetTouchEvent from "ipc/nsGUIEventIPC.h";
|
2015-12-29 13:57:38 +00:00
|
|
|
using class mozilla::WidgetPluginEvent from "ipc/nsGUIEventIPC.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
using struct mozilla::dom::RemoteDOMEvent from "mozilla/dom/TabMessageUtils.h";
|
2015-08-18 21:55:09 +00:00
|
|
|
using mozilla::dom::ScreenOrientationInternal from "mozilla/dom/ScreenOrientation.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
|
2014-03-12 19:27:45 +00:00
|
|
|
using mozilla::CSSPoint from "Units.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
using mozilla::CSSToScreenScale from "Units.h";
|
2014-03-20 15:46:29 +00:00
|
|
|
using mozilla::CommandInt from "mozilla/EventForwards.h";
|
2015-03-02 21:41:02 +00:00
|
|
|
using mozilla::Modifiers from "mozilla/EventForwards.h";
|
2014-04-15 17:39:20 +00:00
|
|
|
using mozilla::layers::GeckoContentController::APZStateChange from "mozilla/layers/GeckoContentController.h";
|
2015-03-26 07:29:31 +00:00
|
|
|
using mozilla::WritingMode from "mozilla/WritingModes.h";
|
2015-09-28 21:00:25 +00:00
|
|
|
using mozilla::layers::AsyncDragMetrics from "mozilla/layers/AsyncDragMetrics.h";
|
2015-03-19 10:33:33 +00:00
|
|
|
using mozilla::layers::TouchBehaviorFlags from "mozilla/layers/APZUtils.h";
|
2015-04-14 15:36:36 +00:00
|
|
|
using nsIWidget::TouchPointerState from "nsIWidget.h";
|
2015-04-22 14:58:33 +00:00
|
|
|
using struct LookAndFeelInt from "mozilla/widget/WidgetMessageUtils.h";
|
2015-09-10 20:50:58 +00:00
|
|
|
using class mozilla::dom::ipc::StructuredCloneData from "ipc/IPCMessageUtils.h";
|
2015-08-26 12:56:59 +00:00
|
|
|
using mozilla::EventMessage from "mozilla/EventForwards.h";
|
2015-05-14 12:16:00 +00:00
|
|
|
using nsEventStatus from "mozilla/EventForwards.h";
|
2015-08-29 01:12:41 +00:00
|
|
|
using nsSizeMode from "nsIWidgetListener.h";
|
2013-10-01 19:25:07 +00:00
|
|
|
|
2009-08-25 23:07:22 +00:00
|
|
|
namespace mozilla {
|
2009-09-09 22:00:14 +00:00
|
|
|
namespace dom {
|
2009-08-25 23:07:22 +00:00
|
|
|
|
2014-03-20 15:46:29 +00:00
|
|
|
struct NativeKeyBinding
|
|
|
|
{
|
|
|
|
CommandInt[] singleLineCommands;
|
|
|
|
CommandInt[] multiLineCommands;
|
|
|
|
CommandInt[] richTextCommands;
|
|
|
|
};
|
|
|
|
|
|
|
|
union MaybeNativeKeyBinding
|
|
|
|
{
|
|
|
|
NativeKeyBinding;
|
|
|
|
void_t;
|
|
|
|
};
|
|
|
|
|
2014-11-24 19:05:35 +00:00
|
|
|
struct ShowInfo
|
|
|
|
{
|
|
|
|
nsString name;
|
|
|
|
bool fullscreenAllowed;
|
|
|
|
bool isPrivate;
|
2015-10-30 13:24:57 +00:00
|
|
|
bool fakeShowInfo;
|
2014-12-12 17:50:46 +00:00
|
|
|
float dpi;
|
|
|
|
double defaultScale;
|
2014-11-24 19:05:35 +00:00
|
|
|
};
|
|
|
|
|
2015-01-28 19:53:46 +00:00
|
|
|
prio(normal upto urgent) sync protocol PBrowser
|
2009-08-25 23:07:22 +00:00
|
|
|
{
|
2014-06-11 05:44:13 +00:00
|
|
|
manager PContent or PContentBridge;
|
2010-07-19 18:33:33 +00:00
|
|
|
|
2014-02-23 20:19:43 +00:00
|
|
|
manages PColorPicker;
|
2015-05-21 17:04:58 +00:00
|
|
|
manages PDocAccessible;
|
2009-10-29 17:58:31 +00:00
|
|
|
manages PDocumentRenderer;
|
2014-02-18 00:30:06 +00:00
|
|
|
manages PFilePicker;
|
2014-09-26 23:21:57 +00:00
|
|
|
manages PIndexedDBPermissionRequest;
|
2010-08-20 23:24:41 +00:00
|
|
|
manages PRenderFrame;
|
2014-11-12 20:59:18 +00:00
|
|
|
manages PPluginWidget;
|
2010-07-19 18:33:33 +00:00
|
|
|
|
|
|
|
both:
|
2013-11-06 17:21:15 +00:00
|
|
|
AsyncMessage(nsString aMessage, ClonedMessageData aData, CpowEntry[] aCpows,
|
|
|
|
Principal aPrincipal);
|
2009-09-09 22:00:14 +00:00
|
|
|
|
2014-11-16 18:23:22 +00:00
|
|
|
/**
|
|
|
|
* Create a layout frame (encapsulating a remote layer tree) for
|
|
|
|
* the page that is currently loaded in the <browser>.
|
|
|
|
*/
|
|
|
|
PRenderFrame();
|
|
|
|
|
2009-11-05 18:14:22 +00:00
|
|
|
parent:
|
2015-05-21 17:04:58 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
PDocAccessible(nullable PDocAccessible aParentDoc, uint64_t aParentAcc);
|
|
|
|
|
2014-11-12 20:59:18 +00:00
|
|
|
/*
|
|
|
|
* 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();
|
|
|
|
|
2015-01-23 10:10:52 +00:00
|
|
|
/**
|
|
|
|
* Return native data of root widget
|
|
|
|
*/
|
|
|
|
sync GetWidgetNativeData() returns (WindowsHandle value);
|
|
|
|
|
2015-08-12 15:00:26 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2015-07-09 14:48:57 +00:00
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
|
2015-01-23 10:10:52 +00:00
|
|
|
parent:
|
2009-11-05 18:14:22 +00:00
|
|
|
/**
|
|
|
|
* When child sends this message, parent should move focus to
|
2015-07-13 10:07:49 +00:00
|
|
|
* the next or previous focusable element or document.
|
2009-11-05 18:14:22 +00:00
|
|
|
*/
|
2015-07-13 10:07:49 +00:00
|
|
|
MoveFocus(bool forward, bool forDocumentNavigation);
|
2009-11-05 18:14:22 +00:00
|
|
|
|
2010-07-19 18:33:33 +00:00
|
|
|
Event(RemoteDOMEvent aEvent);
|
2010-01-01 01:35:55 +00:00
|
|
|
|
2013-11-06 17:21:15 +00:00
|
|
|
sync SyncMessage(nsString aMessage, ClonedMessageData aData,
|
|
|
|
CpowEntry[] aCpows, Principal aPrincipal)
|
2015-09-10 20:50:58 +00:00
|
|
|
returns (StructuredCloneData[] retval);
|
2010-03-29 20:29:45 +00:00
|
|
|
|
2014-10-08 04:32:45 +00:00
|
|
|
prio(high) sync RpcMessage(nsString aMessage, ClonedMessageData aData,
|
|
|
|
CpowEntry[] aCpows, Principal aPrincipal)
|
2015-09-10 20:50:58 +00:00
|
|
|
returns (StructuredCloneData[] retval);
|
2013-10-01 16:15:06 +00:00
|
|
|
|
2010-09-24 03:28:15 +00:00
|
|
|
/**
|
|
|
|
* Notifies chrome that there is a focus change involving an editable
|
|
|
|
* object (input, textarea, document, contentEditable. etc.)
|
|
|
|
*
|
2015-06-05 09:28:20 +00:00
|
|
|
* contentCache Cache of content
|
2015-07-17 04:30:01 +00:00
|
|
|
* notification Whole data of the notification
|
2010-09-24 03:28:15 +00:00
|
|
|
* preference Native widget preference for IME updates
|
|
|
|
*/
|
2015-07-17 04:30:01 +00:00
|
|
|
prio(urgent) sync NotifyIMEFocus(ContentCache contentCache,
|
|
|
|
IMENotification notification)
|
2015-05-28 04:51:40 +00:00
|
|
|
returns (nsIMEUpdatePreference preference);
|
2010-09-24 03:28:15 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Notifies chrome that there has been a change in text content
|
|
|
|
* One call can encompass both a delete and an insert operation
|
2012-10-25 16:32:24 +00:00
|
|
|
* Only called when NotifyIMEFocus returns PR_TRUE for mWantUpdates
|
2010-09-24 03:28:15 +00:00
|
|
|
*
|
2015-06-05 09:28:20 +00:00
|
|
|
* contentCache Cache of content
|
2015-07-17 04:30:01 +00:00
|
|
|
* notification Whole data of the notification
|
2010-09-24 03:28:15 +00:00
|
|
|
*/
|
2015-06-05 09:28:20 +00:00
|
|
|
prio(urgent) async NotifyIMETextChange(ContentCache contentCache,
|
2015-07-17 04:30:01 +00:00
|
|
|
IMENotification notification);
|
2010-09-24 03:28:15 +00:00
|
|
|
|
2013-11-07 00:11:11 +00:00
|
|
|
/**
|
|
|
|
* Notifies chrome that there is a IME compostion rect updated
|
|
|
|
*
|
2015-06-05 09:28:20 +00:00
|
|
|
* contentCache Cache of content
|
2013-11-07 00:11:11 +00:00
|
|
|
*/
|
2015-07-17 04:30:01 +00:00
|
|
|
prio(urgent) async NotifyIMECompositionUpdate(ContentCache contentCache,
|
|
|
|
IMENotification notification);
|
2013-11-07 00:11:11 +00:00
|
|
|
|
2010-09-24 03:28:15 +00:00
|
|
|
/**
|
|
|
|
* Notifies chrome that there has been a change in selection
|
2012-10-25 16:32:24 +00:00
|
|
|
* Only called when NotifyIMEFocus returns PR_TRUE for mWantUpdates
|
2010-09-24 03:28:15 +00:00
|
|
|
*
|
2015-06-05 09:28:20 +00:00
|
|
|
* contentCache Cache of content
|
2015-07-17 04:30:01 +00:00
|
|
|
* notification Whole data of the notification
|
2010-09-24 03:28:15 +00:00
|
|
|
*/
|
2015-06-05 09:28:20 +00:00
|
|
|
prio(urgent) async NotifyIMESelection(ContentCache contentCache,
|
2015-07-17 04:30:01 +00:00
|
|
|
IMENotification notification);
|
2010-09-24 03:28:15 +00:00
|
|
|
|
|
|
|
/**
|
2015-06-05 09:28:20 +00:00
|
|
|
* Notifies chrome of updating its content cache.
|
|
|
|
* This is useful if content is modified but we don't need to notify IME.
|
2010-09-24 03:28:15 +00:00
|
|
|
*
|
2015-06-05 09:28:20 +00:00
|
|
|
* contentCache Cache of content
|
2010-09-24 03:28:15 +00:00
|
|
|
*/
|
2015-06-05 09:28:20 +00:00
|
|
|
prio(urgent) async UpdateContentCache(ContentCache contentCache);
|
2010-09-24 03:28:15 +00:00
|
|
|
|
2014-09-11 13:46:17 +00:00
|
|
|
/**
|
|
|
|
* Notifies IME of mouse button event on a character in focused editor.
|
|
|
|
*
|
|
|
|
* Returns true if the mouse button event is consumd by IME.
|
|
|
|
*/
|
2014-10-30 22:51:39 +00:00
|
|
|
prio(urgent) sync NotifyIMEMouseButtonEvent(IMENotification notification)
|
2014-09-11 13:46:17 +00:00
|
|
|
returns (bool consumedByIME);
|
|
|
|
|
2014-12-15 09:37:00 +00:00
|
|
|
/**
|
|
|
|
* Notifies chrome to position change
|
|
|
|
*
|
2015-06-05 09:28:20 +00:00
|
|
|
* contentCache Cache of content
|
2014-12-15 09:37:00 +00:00
|
|
|
*/
|
2015-07-17 04:30:01 +00:00
|
|
|
prio(urgent) async NotifyIMEPositionChange(ContentCache contentCache,
|
|
|
|
IMENotification notification);
|
2014-12-15 09:37:00 +00:00
|
|
|
|
2010-09-24 03:28:15 +00:00
|
|
|
/**
|
2015-12-11 06:15:58 +00:00
|
|
|
* Requests chrome to commit or cancel composition of IME.
|
2010-09-24 03:28:15 +00:00
|
|
|
*
|
2015-12-11 06:15:58 +00:00
|
|
|
* cancel Set true if composition should be cancelled.
|
2010-09-24 03:28:15 +00:00
|
|
|
*
|
2015-12-11 06:15:58 +00:00
|
|
|
* 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.
|
2010-09-24 03:28:15 +00:00
|
|
|
*/
|
2015-12-11 06:15:58 +00:00
|
|
|
prio(urgent) sync RequestIMEToCommitComposition(bool cancel)
|
|
|
|
returns (bool isCommitted, nsString committedString);
|
2010-09-24 03:28:15 +00:00
|
|
|
|
2015-07-11 01:53:55 +00:00
|
|
|
/**
|
2015-07-22 05:51:36 +00:00
|
|
|
* OnEventNeedingAckHandled() is called after a child process dispatches a
|
2015-07-11 01:53:55 +00:00
|
|
|
* composition event or a selection event which is sent from the parent
|
|
|
|
* process.
|
2015-07-11 01:53:56 +00:00
|
|
|
*
|
2015-07-22 05:51:36 +00:00
|
|
|
* message The message value of the handled event.
|
2015-07-11 01:53:55 +00:00
|
|
|
*/
|
2015-08-26 12:56:59 +00:00
|
|
|
prio(urgent) async OnEventNeedingAckHandled(EventMessage message);
|
2015-07-11 01:53:55 +00:00
|
|
|
|
2015-02-20 16:37:02 +00:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
prio(urgent) 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
|
|
|
|
*/
|
|
|
|
prio(urgent) async SetPluginFocused(bool aFocused);
|
|
|
|
|
2015-12-29 13:57:38 +00:00
|
|
|
/**
|
|
|
|
* Set IME candidate window by windowless plugin if plugin has focus.
|
|
|
|
*/
|
|
|
|
async SetCandidateWindowForPlugin(int32_t aX, int32_t aY);
|
|
|
|
|
2013-09-20 22:07:51 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2014-12-09 15:48:27 +00:00
|
|
|
/**
|
|
|
|
* Indicate, based on the current state, that some commands are enabled and
|
|
|
|
* some are disabled.
|
|
|
|
*/
|
|
|
|
EnableDisableCommands(nsString action,
|
|
|
|
nsCString[] enabledCommands,
|
|
|
|
nsCString[] disabledCommands);
|
|
|
|
|
2014-10-30 22:51:39 +00:00
|
|
|
prio(urgent) sync GetInputContext() returns (int32_t IMEEnabled,
|
2015-12-11 06:15:57 +00:00
|
|
|
int32_t IMEOpen);
|
2014-10-30 22:51:39 +00:00
|
|
|
|
2015-01-20 22:01:24 +00:00
|
|
|
prio(urgent) async SetInputContext(int32_t IMEEnabled,
|
|
|
|
int32_t IMEOpen,
|
|
|
|
nsString type,
|
|
|
|
nsString inputmode,
|
|
|
|
nsString actionHint,
|
|
|
|
int32_t cause,
|
|
|
|
int32_t focusChange);
|
2010-09-24 03:28:15 +00:00
|
|
|
|
2014-04-04 21:50:42 +00:00
|
|
|
sync IsParentWindowMainWidgetVisible() returns (bool visible);
|
|
|
|
|
2010-12-03 01:24:04 +00:00
|
|
|
/**
|
|
|
|
* Gets the DPI of the screen corresponding to this browser.
|
|
|
|
*/
|
|
|
|
sync GetDPI() returns (float value);
|
|
|
|
|
2013-05-01 23:06:19 +00:00
|
|
|
/**
|
|
|
|
* Gets the default scaling factor of the screen corresponding to this browser.
|
|
|
|
*/
|
|
|
|
sync GetDefaultScale() returns (double value);
|
|
|
|
|
2015-05-08 01:29:00 +00:00
|
|
|
/**
|
|
|
|
* Gets maximum of touch points at current device.
|
|
|
|
*/
|
|
|
|
sync GetMaxTouchPoints() returns (uint32_t value);
|
|
|
|
|
2014-05-28 01:12:29 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2015-05-20 01:28:57 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
SetCustomCursor(nsCString cursorData, uint32_t width, uint32_t height,
|
|
|
|
uint32_t stride, uint8_t format,
|
|
|
|
uint32_t hotspotX, uint32_t hotspotY, bool force);
|
|
|
|
|
2013-07-25 19:45:31 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2014-01-22 20:27:23 +00:00
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
|
2014-02-23 20:19:43 +00:00
|
|
|
/**
|
|
|
|
* Create an asynchronous color picker on the parent side,
|
|
|
|
* but don't open it yet.
|
|
|
|
*/
|
|
|
|
PColorPicker(nsString title, nsString initialColor);
|
|
|
|
|
2014-02-18 00:30:06 +00:00
|
|
|
PFilePicker(nsString aTitle, int16_t aMode);
|
|
|
|
|
2014-09-26 23:21:57 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
PIndexedDBPermissionRequest(Principal principal);
|
|
|
|
|
2012-06-12 22:01:25 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2012-08-09 04:39:02 +00:00
|
|
|
/**
|
|
|
|
* Instructs the TabParent to forward a request to zoom to a rect given in
|
|
|
|
* CSS pixels. This rect is relative to the document.
|
|
|
|
*/
|
2013-11-13 18:20:30 +00:00
|
|
|
ZoomToRect(uint32_t aPresShellId, ViewID aViewId, CSSRect aRect);
|
2012-08-09 04:39:02 +00:00
|
|
|
|
2012-08-22 04:37:06 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2014-12-09 10:35:12 +00:00
|
|
|
ContentReceivedInputBlock(ScrollableLayerGuid aGuid, uint64_t aInputBlockId, bool aPreventDefault);
|
2012-08-22 04:37:06 +00:00
|
|
|
|
2014-11-22 02:36:25 +00:00
|
|
|
/**
|
|
|
|
* Notifies the APZ code of the results of the gecko hit-test for a
|
|
|
|
* particular input block. Each target corresponds to one touch point in the
|
|
|
|
* touch event.
|
|
|
|
*/
|
|
|
|
SetTargetAPZC(uint64_t aInputBlockId, ScrollableLayerGuid[] aTargets);
|
|
|
|
|
2012-09-29 02:18:18 +00:00
|
|
|
/**
|
2015-03-19 10:33:33 +00:00
|
|
|
* Notifies the APZ code of the allowed touch-behaviours for a particular
|
|
|
|
* input block. Each item in the aFlags array corresponds to one touch point
|
|
|
|
* in the touch event.
|
|
|
|
*/
|
|
|
|
SetAllowedTouchBehavior(uint64_t aInputBlockId, TouchBehaviorFlags[] aFlags);
|
|
|
|
|
|
|
|
/**
|
2013-11-14 17:35:41 +00:00
|
|
|
* 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.
|
2012-09-29 02:18:18 +00:00
|
|
|
*/
|
2015-06-17 16:32:41 +00:00
|
|
|
UpdateZoomConstraints(uint32_t aPresShellId, ViewID aViewId,
|
|
|
|
MaybeZoomConstraints aConstraints);
|
2012-09-29 02:18:18 +00:00
|
|
|
|
2015-08-28 05:10:48 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
RespondStartSwipeEvent(uint64_t aInputBlockId, bool aStartSwipe);
|
|
|
|
|
2014-06-11 05:44:36 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2010-08-05 22:11:23 +00:00
|
|
|
__delete__();
|
|
|
|
|
2014-03-18 15:16:47 +00:00
|
|
|
ReplyKeyEvent(WidgetKeyboardEvent event);
|
|
|
|
|
2014-11-03 07:05:38 +00:00
|
|
|
DispatchAfterKeyboardEvent(WidgetKeyboardEvent event);
|
|
|
|
|
2014-04-21 20:40:09 +00:00
|
|
|
sync RequestNativeKeyBindings(WidgetKeyboardEvent event)
|
|
|
|
returns (MaybeNativeKeyBinding bindings);
|
|
|
|
|
2015-04-14 15:36:36 +00:00
|
|
|
SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
|
|
|
|
int32_t aNativeKeyCode,
|
|
|
|
uint32_t aModifierFlags,
|
|
|
|
nsString aCharacters,
|
|
|
|
nsString aUnmodifiedCharacters,
|
|
|
|
uint64_t aObserverId);
|
|
|
|
SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
|
|
|
|
uint32_t aNativeMessage,
|
|
|
|
uint32_t aModifierFlags,
|
|
|
|
uint64_t aObserverId);
|
|
|
|
SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
|
|
|
|
uint64_t aObserverId);
|
|
|
|
SynthesizeNativeMouseScrollEvent(LayoutDeviceIntPoint aPoint,
|
|
|
|
uint32_t aNativeMessage,
|
|
|
|
double aDeltaX,
|
|
|
|
double aDeltaY,
|
|
|
|
double aDeltaZ,
|
|
|
|
uint32_t aModifierFlags,
|
|
|
|
uint32_t aAdditionalFlags,
|
|
|
|
uint64_t aObserverId);
|
|
|
|
SynthesizeNativeTouchPoint(uint32_t aPointerId,
|
|
|
|
TouchPointerState aPointerState,
|
2015-12-03 05:45:38 +00:00
|
|
|
ScreenIntPoint aPointerScreenPoint,
|
2015-04-14 15:36:36 +00:00
|
|
|
double aPointerPressure,
|
|
|
|
uint32_t aPointerOrientation,
|
|
|
|
uint64_t aObserverId);
|
2015-12-03 05:45:38 +00:00
|
|
|
SynthesizeNativeTouchTap(ScreenIntPoint aPointerScreenPoint,
|
2015-04-14 15:36:36 +00:00
|
|
|
bool aLongTap,
|
|
|
|
uint64_t aObserverId);
|
|
|
|
ClearNativeTouchSequence(uint64_t aObserverId);
|
|
|
|
child:
|
|
|
|
NativeSynthesisResponse(uint64_t aObserverId, nsCString aResponse);
|
|
|
|
|
2015-08-06 14:44:16 +00:00
|
|
|
|
2015-04-14 15:36:36 +00:00
|
|
|
parent:
|
|
|
|
|
2014-05-23 18:19:00 +00:00
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
|
2014-11-16 18:23:22 +00:00
|
|
|
sync GetRenderFrameInfo(PRenderFrame aRenderFrame)
|
2015-02-26 13:47:01 +00:00
|
|
|
returns (TextureFactoryIdentifier textureFactoryIdentifier,
|
2015-05-18 05:42:05 +00:00
|
|
|
uint64_t layersId);
|
2014-11-16 18:23:22 +00:00
|
|
|
|
2015-01-13 00:41:53 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2015-03-24 22:00:52 +00:00
|
|
|
prio(high) sync DispatchWheelEvent(WidgetWheelEvent event);
|
|
|
|
prio(high) sync DispatchMouseEvent(WidgetMouseEvent event);
|
|
|
|
prio(high) sync DispatchKeyboardEvent(WidgetKeyboardEvent event);
|
2015-03-06 22:26:59 +00:00
|
|
|
|
2015-09-28 21:00:25 +00:00
|
|
|
// Start an APZ drag on a scrollbar
|
|
|
|
async StartScrollbarDrag(AsyncDragMetrics aDragMetrics);
|
|
|
|
|
2015-04-08 18:48:11 +00:00
|
|
|
InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action,
|
|
|
|
nsCString visualData, uint32_t width, uint32_t height,
|
|
|
|
uint32_t stride, uint8_t format, int32_t dragAreaX, int32_t dragAreaY);
|
2015-07-10 16:38:44 +00:00
|
|
|
|
|
|
|
async AudioChannelActivityNotification(uint32_t aAudioChannel,
|
|
|
|
bool aActive);
|
|
|
|
|
2009-09-09 22:00:14 +00:00
|
|
|
child:
|
2010-08-20 23:24:40 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2015-03-05 09:13:05 +00:00
|
|
|
Show(ScreenIntSize size,
|
2014-11-24 19:05:35 +00:00
|
|
|
ShowInfo info,
|
2014-11-16 18:23:22 +00:00
|
|
|
TextureFactoryIdentifier textureFactoryIdentifier,
|
|
|
|
uint64_t layersId,
|
2015-02-06 16:26:29 +00:00
|
|
|
nullable PRenderFrame renderFrame,
|
2015-05-18 05:42:05 +00:00
|
|
|
bool parentIsActive);
|
2009-10-28 20:41:46 +00:00
|
|
|
|
2015-10-30 13:24:57 +00:00
|
|
|
LoadURL(nsCString uri, BrowserConfiguration config, ShowInfo info);
|
2009-09-09 22:00:14 +00:00
|
|
|
|
2015-12-03 23:04:28 +00:00
|
|
|
OpenURI(URIParams uri, uint32_t flags);
|
|
|
|
|
2013-02-15 22:27:21 +00:00
|
|
|
CacheFileDescriptor(nsString path, FileDescriptor fd);
|
|
|
|
|
2015-08-29 01:12:41 +00:00
|
|
|
UpdateDimensions(CSSRect rect, CSSSize size, nsSizeMode sizeMode,
|
2015-08-18 21:55:09 +00:00
|
|
|
ScreenOrientationInternal orientation,
|
2015-05-05 23:20:42 +00:00
|
|
|
LayoutDeviceIntPoint chromeDisp) compressall;
|
2009-10-29 17:58:31 +00:00
|
|
|
|
2014-03-20 21:34:41 +00:00
|
|
|
UpdateFrame(FrameMetrics frame);
|
2012-08-09 04:39:02 +00:00
|
|
|
|
2014-07-16 12:33:50 +00:00
|
|
|
// 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.
|
2015-02-19 23:53:30 +00:00
|
|
|
RequestFlingSnap(ViewID aScrollID, CSSPoint aDestination);
|
2014-02-05 22:43:20 +00:00
|
|
|
AcknowledgeScrollUpdate(ViewID aScrollId, uint32_t aScrollGeneration);
|
2015-03-02 21:41:02 +00:00
|
|
|
HandleDoubleTap(CSSPoint aPoint, Modifiers aModifiers, ScrollableLayerGuid aGuid);
|
|
|
|
HandleSingleTap(CSSPoint aPoint, Modifiers aModifiers, ScrollableLayerGuid aGuid);
|
|
|
|
HandleLongTap(CSSPoint point, Modifiers aModifiers, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
|
2014-04-15 17:39:20 +00:00
|
|
|
NotifyAPZStateChange(ViewID aViewId, APZStateChange aChange, int aArg);
|
2015-06-19 12:25:41 +00:00
|
|
|
NotifyFlushComplete();
|
2013-12-10 03:14:55 +00:00
|
|
|
|
2014-07-16 12:33:50 +00:00
|
|
|
|
2009-11-05 18:14:22 +00:00
|
|
|
/**
|
|
|
|
* Sending an activate message moves focus to the child.
|
|
|
|
*/
|
2010-07-19 18:33:33 +00:00
|
|
|
Activate();
|
2010-03-19 06:52:18 +00:00
|
|
|
|
2011-06-18 00:08:32 +00:00
|
|
|
Deactivate();
|
|
|
|
|
2014-11-27 13:28:26 +00:00
|
|
|
ParentActivated(bool aActivated);
|
|
|
|
|
2015-07-01 13:19:11 +00:00
|
|
|
/**
|
|
|
|
* StopIMEStateManagement() is called when the process loses focus and
|
|
|
|
* should stop managing IME state.
|
|
|
|
*/
|
|
|
|
StopIMEStateManagement();
|
|
|
|
|
2015-07-01 13:19:11 +00:00
|
|
|
/**
|
|
|
|
* MenuKeyboardListenerInstalled() is called when menu keyboard listener
|
|
|
|
* is installed in the parent process.
|
|
|
|
*/
|
|
|
|
MenuKeyboardListenerInstalled(bool aInstalled);
|
|
|
|
|
2009-11-17 14:22:23 +00:00
|
|
|
/**
|
2010-07-19 18:33:33 +00:00
|
|
|
* @see nsIDOMWindowUtils sendMouseEvent.
|
|
|
|
*/
|
|
|
|
MouseEvent(nsString aType,
|
|
|
|
float aX,
|
|
|
|
float aY,
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t aButton,
|
|
|
|
int32_t aClickCount,
|
|
|
|
int32_t aModifiers,
|
2010-07-19 18:33:33 +00:00
|
|
|
bool aIgnoreRootScrollFrame);
|
|
|
|
|
2015-02-13 23:34:04 +00:00
|
|
|
/**
|
|
|
|
* When two consecutive mouse move events would be added to the message queue,
|
|
|
|
* they are 'compressed' by dumping the oldest one.
|
|
|
|
*/
|
2015-09-28 18:44:37 +00:00
|
|
|
RealMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId) compress;
|
2015-07-27 22:35:51 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2015-09-28 18:44:37 +00:00
|
|
|
SynthMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
|
|
|
|
RealMouseButtonEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
|
2014-03-20 15:46:29 +00:00
|
|
|
RealKeyEvent(WidgetKeyboardEvent event, MaybeNativeKeyBinding keyBinding);
|
2014-12-09 10:40:26 +00:00
|
|
|
MouseWheelEvent(WidgetWheelEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
|
2015-05-14 12:16:00 +00:00
|
|
|
RealTouchEvent(WidgetTouchEvent aEvent,
|
|
|
|
ScrollableLayerGuid aGuid,
|
|
|
|
uint64_t aInputBlockId,
|
|
|
|
nsEventStatus aApzResponse);
|
|
|
|
RealTouchMoveEvent(WidgetTouchEvent aEvent,
|
|
|
|
ScrollableLayerGuid aGuid,
|
|
|
|
uint64_t aInputBlockId,
|
|
|
|
nsEventStatus aApzResponse);
|
2015-04-08 18:48:11 +00:00
|
|
|
RealDragEvent(WidgetDragEvent aEvent, uint32_t aDragAction, uint32_t aDropEffect);
|
2015-12-29 13:57:38 +00:00
|
|
|
PluginEvent(WidgetPluginEvent aEvent);
|
2011-06-22 00:32:43 +00:00
|
|
|
|
2010-07-19 18:33:33 +00:00
|
|
|
/**
|
|
|
|
* @see nsIDOMWindowUtils sendKeyEvent.
|
2009-11-17 14:22:23 +00:00
|
|
|
*/
|
2010-07-19 18:33:33 +00:00
|
|
|
KeyEvent(nsString aType,
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t aKeyCode,
|
|
|
|
int32_t aCharCode,
|
|
|
|
int32_t aModifiers,
|
2010-07-19 18:33:33 +00:00
|
|
|
bool aPreventDefault);
|
2009-11-17 14:22:23 +00:00
|
|
|
|
2015-03-22 07:42:26 +00:00
|
|
|
/**
|
|
|
|
* APZ notification for mouse scroll testing events.
|
|
|
|
*/
|
|
|
|
MouseScrollTestEvent(ViewID aScrollId, nsString aEvent);
|
|
|
|
|
2013-10-01 07:23:00 +00:00
|
|
|
CompositionEvent(WidgetCompositionEvent event);
|
2010-08-17 08:07:42 +00:00
|
|
|
|
2013-10-01 07:23:01 +00:00
|
|
|
SelectionEvent(WidgetSelectionEvent event);
|
2010-08-17 08:07:42 +00:00
|
|
|
|
2010-07-19 18:33:33 +00:00
|
|
|
/**
|
|
|
|
* Activate event forwarding from client to parent.
|
|
|
|
*/
|
|
|
|
ActivateFrameEvent(nsString aType, bool capture);
|
2010-02-20 17:05:20 +00:00
|
|
|
|
2013-11-24 05:32:45 +00:00
|
|
|
LoadRemoteScript(nsString aURL, bool aRunInGlobalScope);
|
2010-02-20 17:05:20 +00:00
|
|
|
|
2010-10-26 22:20:53 +00:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*
|
2010-10-26 22:20:53 +00:00
|
|
|
* |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
|
2010-10-26 22:20:53 +00:00
|
|
|
* the document. The rendered image will be of size |renderSize|.
|
2010-10-26 22:20:53 +00:00
|
|
|
*/
|
2013-12-26 18:06:53 +00:00
|
|
|
PDocumentRenderer(nsRect documentRect, Matrix transform,
|
2010-10-26 22:20:53 +00:00
|
|
|
nsString bgcolor,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t renderFlags, bool flushLayout,
|
2015-03-29 14:59:08 +00:00
|
|
|
IntSize renderSize);
|
2010-03-24 10:47:18 +00:00
|
|
|
|
2010-08-05 22:11:23 +00:00
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
|
2013-08-13 07:56:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Tell the child side if it has to update it's touchable region
|
|
|
|
* to the parent.
|
|
|
|
*/
|
|
|
|
SetUpdateHitRegion(bool aEnabled);
|
|
|
|
|
2014-02-20 11:26:13 +00:00
|
|
|
/**
|
2015-09-04 13:42:01 +00:00
|
|
|
* Update the child side docShell active (resource use) state.
|
2014-02-20 11:26:13 +00:00
|
|
|
*/
|
2015-11-10 02:38:21 +00:00
|
|
|
SetDocShellIsActive(bool aIsActive, bool aIsHidden);
|
2014-02-20 11:26:13 +00:00
|
|
|
|
2015-08-19 21:08:41 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2015-07-13 10:07:49 +00:00
|
|
|
/**
|
2015-07-23 14:04:15 +00:00
|
|
|
* Navigate by key (Tab/Shift+Tab/F6/Shift+f6).
|
2015-07-13 10:07:49 +00:00
|
|
|
*/
|
2015-07-23 14:04:15 +00:00
|
|
|
NavigateByKey(bool aForward, bool aForDocumentNavigation);
|
2015-07-13 10:07:49 +00:00
|
|
|
|
2014-05-23 18:19:00 +00:00
|
|
|
/**
|
|
|
|
* The parent (chrome thread) requests that the child inform it when
|
|
|
|
* the graphics objects are ready to display.
|
|
|
|
* @see PCompositor
|
|
|
|
* @see RemotePaintIsReady
|
|
|
|
*/
|
|
|
|
async RequestNotifyAfterRemotePaint();
|
|
|
|
|
2014-05-23 14:36:50 +00:00
|
|
|
/**
|
|
|
|
* Tell the child that the UI resolution changed for the containing
|
|
|
|
* window.
|
2015-08-13 14:42:19 +00:00
|
|
|
* 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.
|
2014-05-23 14:36:50 +00:00
|
|
|
*/
|
2015-08-13 14:42:19 +00:00
|
|
|
UIResolutionChanged(float dpi, double scale);
|
2014-05-23 14:36:50 +00:00
|
|
|
|
2015-04-22 14:58:33 +00:00
|
|
|
/**
|
|
|
|
* Tell the child that the system theme has changed, and that a repaint
|
|
|
|
* is necessary.
|
|
|
|
*/
|
|
|
|
ThemeChanged(LookAndFeelInt[] lookAndFeelIntCache);
|
|
|
|
|
2014-08-22 23:17:18 +00:00
|
|
|
/**
|
|
|
|
* Tell the child of an app's offline status
|
|
|
|
*/
|
|
|
|
AppOfflineStatus(uint32_t id, bool offline);
|
|
|
|
|
2015-05-07 15:43:40 +00:00
|
|
|
/**
|
|
|
|
* Tell the browser that its frame loader has been swapped
|
|
|
|
* with another.
|
|
|
|
*/
|
|
|
|
SwappedWithOtherRemoteLoader();
|
|
|
|
|
2015-09-18 12:19:13 +00:00
|
|
|
/**
|
|
|
|
* A potential accesskey was just pressed. Look for accesskey targets
|
|
|
|
* using the list of provided charCodes.
|
|
|
|
*
|
|
|
|
* @param charCode array of potential character codes
|
|
|
|
* @param isTrusted true if triggered by a trusted key event
|
|
|
|
* @param modifierMask indicates which accesskey modifiers are pressed
|
|
|
|
*/
|
|
|
|
HandleAccessKey(uint32_t[] charCodes, bool isTrusted, int32_t modifierMask);
|
|
|
|
|
2015-12-11 16:17:33 +00:00
|
|
|
/**
|
|
|
|
* Propagate a refresh to the child process
|
|
|
|
*/
|
|
|
|
AudioChannelChangeNotification(uint32_t aAudioChannel,
|
|
|
|
float aVolume,
|
|
|
|
bool aMuted);
|
|
|
|
|
2010-08-05 22:11:23 +00:00
|
|
|
/*
|
|
|
|
* FIXME: write protocol!
|
|
|
|
|
|
|
|
state LIVE:
|
|
|
|
send LoadURL goto LIVE;
|
|
|
|
//etc.
|
|
|
|
send Destroy goto DYING;
|
|
|
|
|
|
|
|
state DYING:
|
|
|
|
discard send blah;
|
|
|
|
// etc.
|
|
|
|
recv __delete__;
|
|
|
|
*/
|
2009-08-25 23:07:22 +00:00
|
|
|
};
|
|
|
|
|
2009-09-09 22:00:14 +00:00
|
|
|
}
|
2012-07-30 14:58:26 +00:00
|
|
|
}
|