palemoon27/dom/ipc/PContent.ipdl

/* -*- 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 PAPZ;
include protocol PBackground;
include protocol PBlob;
include protocol PBluetooth;
include protocol PBrowser;
include protocol PCellBroadcast;
include protocol PCompositorBridge;
include protocol PContentBridge;
include protocol PContentPermissionRequest;
include protocol PCycleCollectWithLogs;
include protocol PCrashReporter;
include protocol PPSMContentDownloader;
include protocol PExternalHelperApp;
include protocol PHandlerService;
include protocol PDeviceStorageRequest;
include protocol PFileDescriptorSet;
include protocol PFMRadio;
include protocol PHal;
include protocol PHeapSnapshotTempFileHelper;
include protocol PIcc;
include protocol PProcessHangMonitor;
include protocol PImageBridge;
include protocol PMedia;
include protocol PMemoryReportRequest;
include protocol PMobileConnection;
include protocol PNecko;
// FIXME This is pretty ridiculous, but we have to keep the order of the
//       following 4 includes, or the parser is confused about PGMPContent
//       bridging PContent and PGMP. As soon as it registers the bridge between
//       PContent and PPluginModule it seems to think that PContent's parent and
//       child live in the same process!
include protocol PGMPContent;
include protocol PGMPService;
include protocol PPluginModule;
include protocol PGMP;
include protocol PPrinting;
include protocol POfflineCacheUpdate;
include protocol PRenderFrame;
include protocol PScreenManager;
include protocol PSharedBufferManager;
include protocol PSms;
include protocol PSpeechSynthesis;
include protocol PStorage;
include protocol PTelephony;
include protocol PTestShell;
include protocol PVoicemail;
include protocol PJavaScript;
include protocol PRemoteSpellcheckEngine;
include protocol PWebrtcGlobal;
include protocol PPresentation;
include protocol PVRManager;
include DOMTypes;
include JavaScriptTypes;
include InputStreamParams;
include PTabContext;
include URIParams;
include PluginTypes;
include ProtocolTypes;
include PBackgroundSharedTypes;
include PContentPermission;
include BrowserConfiguration;
include GraphicsMessages;
include ProfilerTypes;

// Workaround to prevent error if PContentChild.cpp & PContentBridgeParent.cpp
// are put into different UnifiedProtocolsXX.cpp files.
// XXX Remove this once bug 1069073 is fixed
include "mozilla/dom/PContentBridgeParent.h";

include "mozilla/dom/quota/SerializationHelpers.h";

using GeoPosition from "nsGeoPositionIPCSerialiser.h";
using AlertNotificationType from "mozilla/AlertNotificationIPCSerializer.h";

using struct ChromePackage from "mozilla/chrome/RegistryMessageUtils.h";
using struct SubstitutionMapping from "mozilla/chrome/RegistryMessageUtils.h";
using struct OverrideMapping from "mozilla/chrome/RegistryMessageUtils.h";
using base::ChildPrivileges from "base/process_util.h";
using base::ProcessId from "base/process.h";
using struct IPC::Permission from "mozilla/net/NeckoMessageUtils.h";
using class IPC::Principal from "mozilla/dom/PermissionMessageUtils.h";
using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
using mozilla::dom::NativeThreadId from "mozilla/dom/TabMessageUtils.h";
using mozilla::dom::quota::PersistenceType from "mozilla/dom/quota/PersistenceType.h";
using mozilla::hal::ProcessPriority from "mozilla/HalTypes.h";
using mozilla::gfx::IntSize from "mozilla/gfx/2D.h";
using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
using mozilla::dom::ContentParentId from "mozilla/dom/ipc/IdType.h";
using struct LookAndFeelInt from "mozilla/widget/WidgetMessageUtils.h";
using class mozilla::dom::ipc::StructuredCloneData from "ipc/IPCMessageUtils.h";
using mozilla::DataStorageType from "ipc/DataStorageIPCUtils.h";
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";

union ChromeRegistryItem
{
    ChromePackage;
    OverrideMapping;
    SubstitutionMapping;
};

namespace mozilla {
namespace dom {

struct FontListEntry {
    nsString  familyName;
    nsString  faceName;
    nsCString filepath;
    uint16_t  weight;
    int16_t   stretch;
    uint8_t   italic;
    uint8_t   index;
    bool      isHidden;
};

struct DeviceStorageFreeSpaceParams
{
  nsString type;
  nsString storageName;
};

struct DeviceStorageUsedSpaceParams
{
  nsString type;
  nsString storageName;
};

struct DeviceStorageAvailableParams
{
  nsString type;
  nsString storageName;
};

struct DeviceStorageStatusParams
{
  nsString type;
  nsString storageName;
};

struct DeviceStorageFormatParams
{
  nsString type;
  nsString storageName;
};

struct DeviceStorageMountParams
{
  nsString type;
  nsString storageName;
};

struct DeviceStorageUnmountParams
{
  nsString type;
  nsString storageName;
};

struct DeviceStorageAddParams
{
  nsString type;
  nsString storageName;
  nsString relpath;
  PBlob blob;
};

struct DeviceStorageAppendParams
{
  nsString type;
  nsString storageName;
  nsString relpath;
  PBlob blob;
};

struct DeviceStorageCreateFdParams
{
  nsString type;
  nsString storageName;
  nsString relpath;
};

struct DeviceStorageGetParams
{
  nsString type;
  nsString storageName;
  nsString rootDir;
  nsString relpath;
};

struct DeviceStorageDeleteParams
{
  nsString type;
  nsString storageName;
  nsString relpath;
};

struct DeviceStorageEnumerationParams
{
  nsString type;
  nsString storageName;
  nsString rootdir;
  uint64_t since;
};

union DeviceStorageParams
{
  DeviceStorageAddParams;
  DeviceStorageAppendParams;
  DeviceStorageCreateFdParams;
  DeviceStorageGetParams;
  DeviceStorageDeleteParams;
  DeviceStorageEnumerationParams;
  DeviceStorageFreeSpaceParams;
  DeviceStorageUsedSpaceParams;
  DeviceStorageAvailableParams;
  DeviceStorageStatusParams;
  DeviceStorageFormatParams;
  DeviceStorageMountParams;
  DeviceStorageUnmountParams;
};

struct DeviceStorageLocationInfo {
  nsString music;
  nsString pictures;
  nsString videos;
  nsString sdcard;
  nsString apps;
  nsString crashes;
};

struct FMRadioRequestEnableParams
{
  double frequency;
};

struct FMRadioRequestDisableParams
{

};

struct FMRadioRequestSetFrequencyParams
{
  double frequency;
};

struct FMRadioRequestSeekParams
{
  bool upward;
};

struct FMRadioRequestCancelSeekParams
{

};

union FMRadioRequestParams
{
  FMRadioRequestEnableParams;
  FMRadioRequestDisableParams;
  FMRadioRequestSetFrequencyParams;
  FMRadioRequestSeekParams;
  FMRadioRequestCancelSeekParams;
};

union PrefValue {
  nsCString;
  int32_t;
  bool;
};

union MaybePrefValue {
  PrefValue;
  null_t;
};

struct PrefSetting {
  nsCString name;
  MaybePrefValue defaultValue;
  MaybePrefValue userValue;
};

struct DataStorageItem {
  nsCString key;
  nsCString value;
  DataStorageType type;
};

// Note: Any changes to this structure should also be changed in
// FileSystemUpdate below.
struct VolumeInfo {
  nsString name;
  nsString mountPoint;
  int32_t volState;
  int32_t mountGeneration;
  bool isMediaPresent;
  bool isSharing;
  bool isFormatting;
  bool isFake;
  bool isUnmounting;
  bool isRemovable;
  bool isHotSwappable;
};

struct ClipboardCapabilities {
  bool supportsSelectionClipboard;
  bool supportsFindClipboard;
};

union MaybeFileDesc {
    FileDescriptor;
    void_t;
};

union FileDescOrError {
    FileDescriptor;
    nsresult;
};

union OptionalContentId
{
  ContentParentId;
  void_t;
};

struct DomainPolicyClone
{
    bool        active;
    URIParams[] blacklist;
    URIParams[] whitelist;
    URIParams[] superBlacklist;
    URIParams[] superWhitelist;
};

struct GamepadAdded {
    nsString id;
    uint32_t index;
    uint32_t mapping;
    uint32_t num_buttons;
    uint32_t num_axes;
};

struct GamepadRemoved {
    uint32_t index;
};

struct GamepadAxisInformation {
    uint32_t index;
    uint32_t axis;
    double value;
};

struct GamepadButtonInformation {
    uint32_t index;
    uint32_t button;
    bool pressed;
    double value;
};

union GamepadChangeEvent {
    GamepadAdded;
    GamepadRemoved;
    GamepadAxisInformation;
    GamepadButtonInformation;
};

struct FrameScriptInfo
{
    nsString url;
    bool runInGlobalScope;
};

struct AndroidSystemInfo
{
    nsString device;
    nsString manufacturer;
    nsString release_version;
    nsString hardware;
    uint32_t sdk_version;
    bool     isTablet;
};

prio(normal upto urgent) sync protocol PContent
{
    parent spawns PPluginModule;

    parent opens PCompositorBridge;
    parent opens PProcessHangMonitor;
    parent opens PSharedBufferManager;
    parent opens PImageBridge;
    parent opens PGMPService;
    parent opens PVRManager;
    child opens PBackground;

    manages PAPZ;
    manages PBlob;
    manages PBluetooth;
    manages PBrowser;
    manages PCellBroadcast;
    manages PContentPermissionRequest;
    manages PCrashReporter;
    manages PCycleCollectWithLogs;
    manages PDeviceStorageRequest;
    manages PPSMContentDownloader;
    manages PExternalHelperApp;
    manages PFileDescriptorSet;
    manages PFMRadio;
    manages PHal;
    manages PHandlerService;
    manages PHeapSnapshotTempFileHelper;
    manages PIcc;
    manages PMedia;
    manages PMemoryReportRequest;
    manages PMobileConnection;
    manages PNecko;
    manages POfflineCacheUpdate;
    manages PPrinting;
    manages PScreenManager;
    manages PSms;
    manages PSpeechSynthesis;
    manages PStorage;
    manages PTelephony;
    manages PTestShell;
    manages PVoicemail;
    manages PJavaScript;
    manages PRemoteSpellcheckEngine;
    manages PWebrtcGlobal;
    manages PPresentation;

both:
    // Depending on exactly how the new browser is being created, it might be
    // created from either the child or parent process!
    //
    // The child creates the PBrowser as part of
    // TabChild::BrowserFrameProvideWindow (which happens when the child's
    // content calls window.open()), and the parent creates the PBrowser as part
    // of ContentParent::CreateBrowserOrApp.
    //
    // When the parent constructs a PBrowser, the child trusts the app token and
    // other attributes it receives from the parent.  In that case, the
    // context should be FrameIPCTabContext.
    //
    // When the child constructs a PBrowser, the parent doesn't trust the app
    // token it receives from the child.  In this case, context must have type
    // PopupIPCTabContext.  The browser created using a PopupIPCTabContext has
    // the opener PBrowser's app-id and containing-app-id.  The parent checks
    // that if the opener is a browser element, the context is also for a
    // browser element.
    //
    // This allows the parent to prevent a malicious child from escalating its
    // privileges by requesting a PBrowser corresponding to a highly-privileged
    // app; the child can only request privileges for an app which the child has
    // access to (in the form of a TabChild).
    //
    // Keep the last 3 attributes in sync with GetProcessAttributes!
    async PBrowser(TabId tabId, IPCTabContext context, uint32_t chromeFlags,
                   ContentParentId cpId, bool isForApp, bool isForBrowser);

    async PBlob(BlobConstructorParams params);

    async PFileDescriptorSet(FileDescriptor fd);

child:
    /**
     * Enable system-level sandboxing features, if available.  Can
     * usually only be performed zero or one times.  The child may
     * abnormally exit if this fails; the details are OS-specific.
     */
    async SetProcessSandbox(MaybeFileDesc aBroker);

    async PMemoryReportRequest(uint32_t generation, bool anonymize,
                               bool minimizeMemoryUsage, MaybeFileDesc DMDFile);

    async SpeakerManagerNotify();

    /**
     * Communication between the PuppetBidiKeyboard and the actual
     * BidiKeyboard hosted by the parent
     */
    async BidiKeyboardNotify(bool isLangRTL);

    /**
     * Dump this process's GC and CC logs to the provided files.
     *
     * For documentation on the other args, see dumpGCAndCCLogsToFile in
     * nsIMemoryInfoDumper.idl
     */
    async PCycleCollectWithLogs(bool dumpAllTraces,
                                FileDescriptor gcLog,
                                FileDescriptor ccLog);

    async PTestShell();

    async PAPZ(TabId tabId);

    async RegisterChrome(ChromePackage[] packages, SubstitutionMapping[] substitutions,
                         OverrideMapping[] overrides, nsCString locale, bool reset);
    async RegisterChromeItem(ChromeRegistryItem item);

    async SetOffline(bool offline);
    async SetConnectivity(bool connectivity);

    async NotifyVisited(URIParams uri);

    async SystemMemoryAvailable(uint64_t getterId, uint32_t memoryAvailable);

    async PreferenceUpdate(PrefSetting pref);

    async DataStoragePut(nsString aFilename, DataStorageItem aItem);
    async DataStorageRemove(nsString aFilename, nsCString aKey, DataStorageType aType);
    async DataStorageClear(nsString aFilename);

    async NotifyAlertsObserver(nsCString topic, nsString data);

    async GeolocationUpdate(GeoPosition somewhere);

    async GeolocationError(uint16_t errorCode);

    async UpdateDictionaryList(nsString[] dictionaries);

    // nsIPermissionManager messages
    async AddPermission(Permission permission);

    async Volumes(VolumeInfo[] volumes);

    async FlushMemory(nsString reason);

    async GarbageCollect();
    async CycleCollect();

    /**
     * Start accessibility engine in content process.
     */
    async ActivateA11y();

    async AppInfo(nsCString version, nsCString buildID, nsCString name, nsCString UAName,
                  nsCString ID, nsCString vendor);
    async AppInit();

    // Notify child that last-pb-context-exited notification was observed
    async LastPrivateDocShellDestroyed();

    async FilePathUpdate(nsString storageType, nsString storageName, nsString filepath,
                         nsCString reasons);

    // Note: Any changes to this structure should also be changed in
    // VolumeInfo above.
    async FileSystemUpdate(nsString fsName, nsString mountPoint, int32_t fsState,
                           int32_t mountGeneration, bool isMediaPresent,
                           bool isSharing, bool isFormatting, bool isFake,
                           bool isUnmounting, bool isRemovable, bool isHotSwappable);

    // Notify volume is removed.
    async VolumeRemoved(nsString fsName);

    async NotifyProcessPriorityChanged(ProcessPriority priority);
    async MinimizeMemoryUsage();

    /**
     * Used to manage nsIStyleSheetService across processes.
     */
    async LoadAndRegisterSheet(URIParams uri, uint32_t type);
    async UnregisterSheet(URIParams uri, uint32_t type);

    async NotifyPhoneStateChange(nsString newState);

    /**
     * Notify idle observers in the child
     */
    async NotifyIdleObserver(uint64_t observerId, nsCString topic, nsString str);

    /**
     * Notify windows in the child to apply a new app style.
     */
    async OnAppThemeChanged();

    /**
     * Called during plugin initialization to map a plugin id to a child process
     * id.
     */
    async AssociatePluginId(uint32_t aPluginId, ProcessId aProcessId);

    /**
     * This call is used by async plugin initialization to notify the
     * PluginModuleContentParent that the PluginModuleChromeParent's async
     * init has completed.
     */
    async LoadPluginResult(uint32_t aPluginId, bool aResult);

    /**
     * Control the Gecko Profiler in the child process.
     */
    async StartProfiler(ProfilerInitParams params);
    async StopProfiler();
    async PauseProfiler(bool aPause);

    async GatherProfile();

    async InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action);

    async EndDragSession(bool aDoneDrag, bool aUserCancelled);

    async DomainSetChanged(uint32_t aSetType, uint32_t aChangeType, OptionalURIParams aDomain);

    /**
     * Notify the child to shutdown. The child will in turn call FinishShutdown
     * and let the parent close the channel.
     */
    async Shutdown();

    async LoadProcessScript(nsString url);

    /**
     * Requests a full native update of a native plugin child window. This is
     * a Windows specific call.
     */
    async UpdateWindow(uintptr_t aChildId);

    /**
     * Send gamepad status update to child.
     */
    async GamepadUpdate(GamepadChangeEvent aGamepadEvent);

    /**
     * Notify the child that presentation receiver has been launched with the
     * correspondent iframe.
     */
    async NotifyPresentationReceiverLaunched(PBrowser aIframe, nsString aSessionId);

    /**
     * Notify the child that the info about a presentation receiver needs to be
     * cleaned up.
     */
    async NotifyPresentationReceiverCleanUp(nsString aSessionId);

    /**
     * Notify the child that the Gecko Media Plugins installed changed.
     */
    async NotifyGMPsChanged();

    /**
     * Send a `push` event without data to a service worker in the child.
     */
    async Push(nsCString scope, Principal principal, nsString messageId);

    /**
     * Send a `push` event with data to a service worker in the child.
     */
    async PushWithData(nsCString scope, Principal principal,
                       nsString messageId, uint8_t[] data);

    /**
     * Send a `pushsubscriptionchange` event to a service worker in the child.
     */
    async PushSubscriptionChange(nsCString scope, Principal principal);

    /**
     * Send a Push error message to all service worker clients in the child.
     */
    async PushError(nsCString scope, nsString message, uint32_t flags);

    /**
     * Windows specific: associate this content process with the browsers
     * audio session.
     */
    async SetAudioSessionData(nsID aID,
                              nsString aDisplayName,
                              nsString aIconPath);
parent:
    /**
     * Tell the content process some attributes of itself.  This is
     * among the first information queried by content processes after
     * startup.  (The message is sync to allow the content process to
     * control when it receives the information.)
     *
     * |id| is a unique ID among all subprocesses.  When |isForApp &&
     * isForBrowser|, we're loading <browser> for an app.  When
     * |isForBrowser|, we're loading <browser>.  When |!isForApp &&
     * !isForBrowser|, we're probably loading <xul:browser remote>.
     *
     * Keep the return values in sync with PBrowser()!
     */
    sync GetProcessAttributes()
        returns (ContentParentId cpId, bool isForApp, bool isForBrowser);
    sync GetXPCOMProcessAttributes()
        returns (bool isOffline, bool isConnected, bool isLangRTL, nsString[] dictionaries,
                 ClipboardCapabilities clipboardCaps,
                 DomainPolicyClone domainPolicy,
                 StructuredCloneData initialData);

    sync CreateChildProcess(IPCTabContext context,
                            ProcessPriority priority,
                            TabId openerTabId)
        returns (ContentParentId cpId, bool isForApp, bool isForBrowser, TabId tabId);
    sync BridgeToChildProcess(ContentParentId cpId);

    async CreateGMPService();
    sync GetGMPPluginVersionForAPI(nsCString api, nsCString[] tags)
        returns (bool hasPlugin, nsCString version);
    sync IsGMPPresentOnDisk(nsString keySystem, nsCString version)
        returns (bool isPresent, nsCString message);

    /**
     * This call connects the content process to a plugin process. While this
     * call runs, a new PluginModuleParent will be created in the ContentChild
     * via bridging. The corresponding PluginModuleChild will live in the plugin
     * process.
     */
    sync LoadPlugin(uint32_t aPluginId) returns (nsresult aResult, uint32_t aRunID);

    /**
     * This call is used by asynchronous plugin instantiation to notify the
     * content parent that it is now safe to initiate the plugin bridge for
     * the specified plugin id. When this call returns, the requested bridge
     * connection has been made.
     */
    sync ConnectPluginBridge(uint32_t aPluginId) returns (nsresult rv);

    /**
     * Return the current blocklist state for a particular plugin.
     */
    sync GetBlocklistState(uint32_t aPluginId) returns (uint32_t aState);

    /**
     * This call returns the set of plugins loaded in the chrome
     * process. However, in many cases this set will not have changed since the
     * last FindPlugins message. Consequently, the chrome process increments an
     * epoch number every time the set of plugins changes. The content process
     * sends up the last epoch it observed. If the epochs are the same, the
     * chrome process returns no plugins. Otherwise it returns a complete list.
     *
     * |pluginEpoch| is the epoch last observed by the content
     * process. |newPluginEpoch| is the current epoch in the chrome process. If
     * |pluginEpoch == newPluginEpoch|, then |plugins| will be left empty.
     */
    sync FindPlugins(uint32_t pluginEpoch) returns (nsresult aResult, PluginTag[] plugins, uint32_t newPluginEpoch);

    async PJavaScript();

    async PRemoteSpellcheckEngine();
    async PDeviceStorageRequest(DeviceStorageParams params);

    sync PCrashReporter(NativeThreadId tid, uint32_t processType);

    /**
     * Is this token compatible with the provided version?
     *
     * |version| The offered version to test
     * Returns |True| if the offered version is compatible
     */
    sync NSSU2FTokenIsCompatibleVersion(nsString version)
        returns (bool result);

    /**
     * Return whether the provided KeyHandle belongs to this Token
     *
     * |keyHandle| Key Handle to evaluate.
     * Returns |True| if the Key Handle is ours.
     */
    sync NSSU2FTokenIsRegistered(uint8_t[] keyHandle)
        returns (bool isValidKeyHandle);

    /**
     * Generates a public/private keypair for the provided application
     * and challenge, returning the pubkey, challenge response, and
     * key handle in the registration data.
     *
     * |application| The FIDO Application data to associate with the key.
     * |challenge| The Challenge to satisfy in the response.
     * |registration| An array containing the pubkey, challenge response,
     *                     and key handle.
     */
    sync NSSU2FTokenRegister(uint8_t[] application, uint8_t[] challenge)
        returns (uint8_t[] registration);

    /**
     * Creates a signature over the "param" arguments using the private key
     * provided in the key handle argument.
     *
     * |application| The FIDO Application data to associate with the key.
     * |challenge| The Challenge to satisfy in the response.
     * |keyHandle| The Key Handle opaque object to use.
     * |signature| The resulting signature.
     */
    sync NSSU2FTokenSign(uint8_t[] application, uint8_t[] challenge,
                         uint8_t[] keyHandle)
        returns (uint8_t[] signature);

    async GetSystemMemory(uint64_t getterId);

    sync IsSecureURI(uint32_t type, URIParams uri, uint32_t flags)
        returns (bool isSecureURI);

    async AccumulateMixedContentHSTS(URIParams uri, bool active);

    sync GetLookAndFeelCache()
        returns (LookAndFeelInt[] lookAndFeelIntCache);

    prio(urgent) async PHal();

    async PHeapSnapshotTempFileHelper();

    async PIcc(uint32_t serviceId);

    async PMobileConnection(uint32_t clientId);

    async PNecko();

    async PPrinting();

    prio(high) sync PScreenManager()
        returns (uint32_t numberOfScreens,
                 float systemDefaultScale,
                 bool success);

    async PCellBroadcast();

    async PSms();

    async PSpeechSynthesis();

    prio(urgent) async PStorage();

    async PTelephony();

    async PVoicemail();

    async PMedia();

    async PBluetooth();

    async PFMRadio();

    async PWebrtcGlobal();

    async PPresentation();

    // Services remoting

    async StartVisitedQuery(URIParams uri);
    async VisitURI(URIParams uri, OptionalURIParams referrer, uint32_t flags);
    async SetURITitle(URIParams uri, nsString title);

    async LoadURIExternal(URIParams uri, PBrowser windowContext);

    // PrefService message
    sync ReadPrefsArray() returns (PrefSetting[] prefs);

    sync ReadFontList() returns (FontListEntry[] retValue);

    sync ReadDataStorageArray(nsString aFilename)
      returns (DataStorageItem[] retValue);

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

    prio(high) sync RpcMessage(nsString aMessage, ClonedMessageData aData,
                               CpowEntry[] aCpows, Principal aPrincipal)
      returns (StructuredCloneData[] retval);

    async ShowAlert(AlertNotificationType alert);

    async CloseAlert(nsString name, Principal principal);

    async DisableNotifications(Principal principal);

    async OpenNotificationSettings(Principal principal);

    async PPSMContentDownloader(uint32_t aCertType);

    async PExternalHelperApp(OptionalURIParams uri,
                             nsCString aMimeContentType,
                             nsCString aContentDisposition,
                             uint32_t aContentDispositionHint,
                             nsString aContentDispositionFilename,
                             bool aForceSave,
                             int64_t aContentLength,
                             OptionalURIParams aReferrer,
                             nullable PBrowser aBrowser);

    async PHandlerService();

    async AddGeolocationListener(Principal principal, bool highAccuracy);
    async RemoveGeolocationListener();
    async SetGeolocationHigherAccuracy(bool enable);

    async ConsoleMessage(nsString message);
    async ScriptError(nsString message, nsString sourceName, nsString sourceLine,
                      uint32_t lineNumber, uint32_t colNumber, uint32_t flags,
                      nsCString category);

    // nsIPermissionManager messages
    sync ReadPermissions() returns (Permission[] permissions);

    // Places the items within dataTransfer on the clipboard.
    async SetClipboard(IPCDataTransfer aDataTransfer,
                       bool aIsPrivateData,
                       int32_t aWhichClipboard);

    // Given a list of supported types, returns the clipboard data for the
    // first type that matches.
    sync GetClipboard(nsCString[] aTypes, int32_t aWhichClipboard)
        returns (IPCDataTransfer dataTransfer);

    // Clears the clipboard.
    async EmptyClipboard(int32_t aWhichClipboard);

    // Returns true if data of one of the specified types is on the clipboard.
    sync ClipboardHasType(nsCString[] aTypes, int32_t aWhichClipboard)
        returns (bool hasType);

    sync GetSystemColors(uint32_t colorsCount)
        returns (uint32_t[] colors);

    sync GetIconForExtension(nsCString aFileExt, uint32_t aIconSize)
        returns (uint8_t[] bits);

    sync GetShowPasswordSetting()
        returns (bool showPassword);

    // Notify the parent of the presence or absence of private docshells
    async PrivateDocShellsExist(bool aExist);

    // Tell the parent that the child has gone idle for the first time
    async FirstIdle();

    async AudioChannelServiceStatus(bool aActiveTelephonyChannel,
                                    bool aContentOrNormalChannel,
                                    bool aAnyActiveChannel);

    async AudioChannelChangeDefVolChannel(int32_t aChannel, bool aHidden);

    async FilePathUpdateNotify(nsString aType,
                               nsString aStorageName,
                               nsString aFilepath,
                               nsCString aReason);

    // Notify the parent that the child has finished handling a system message.
    async SystemMessageHandled();

    // called by the child (test code only) to propagate volume changes to the parent
    async CreateFakeVolume(nsString fsName, nsString mountPoint);
    async SetFakeVolumeState(nsString fsName, int32_t fsState);
    async RemoveFakeVolume(nsString fsName);

    sync KeywordToURI(nsCString keyword)
        returns (nsString providerName, OptionalInputStreamParams postData, OptionalURIParams uri);

    sync NotifyKeywordSearchLoading(nsString providerName, nsString keyword);

    async CopyFavicon(URIParams oldURI, URIParams newURI, bool isPrivate);

    // Tell the compositor to allocate a layer tree id for nested remote mozbrowsers.
    sync AllocateLayerTreeId(ContentParentId cpId, TabId tabId)
        returns (uint64_t id);
    async DeallocateLayerTreeId(uint64_t id);

    sync SpeakerManagerForceSpeaker(bool aEnable);

    sync SpeakerManagerGetSpeakerStatus()
        returns (bool value);

    /**
     * Notifies the parent about a recording device is starting or shutdown.
     * @param recordingStatus starting or shutdown
     * @param pageURL URL that request that changing the recording status
     * @param isAudio recording start with microphone
     * @param isVideo recording start with camera
     */
    async RecordingDeviceEvents(nsString recordingStatus,
                                nsString pageURL,
                                bool isAudio,
                                bool isVideo);

    sync GetGraphicsFeatureStatus(int32_t aFeature) returns (int32_t aStatus, nsCString aFailureCode,
                                                             bool aSuccess);

    // Graphics errors
    async GraphicsError(nsCString aError);

    // Driver crash guards. aGuardType must be a member of CrashGuardType.
    sync BeginDriverCrashGuard(uint32_t aGuardType) returns (bool crashDetected);
    sync EndDriverCrashGuard(uint32_t aGuardType);

    async AddIdleObserver(uint64_t observerId, uint32_t idleTimeInS);
    async RemoveIdleObserver(uint64_t observerId, uint32_t idleTimeInS);

    /**
     * This message is only used on X11 platforms.
     *
     * Send a dup of the plugin process's X socket to the parent
     * process.  In theory, this scheme keeps the plugin's X resources
     * around until after both the plugin process shuts down *and* the
     * parent process closes the dup fd.  This is used to prevent the
     * parent process from crashing on X errors if, e.g., the plugin
     * crashes *just before* a repaint and the parent process tries to
     * use the newly-invalid surface.
     */
    async BackUpXResources(FileDescriptor aXSocketFd);

    sync OpenAnonymousTemporaryFile() returns (FileDescOrError aFD);

    /**
     * Keygen requires us to call it after a <keygen> element is parsed and
     * before one is submitted. This is urgent because an extension might use
     * a CPOW to synchronously submit a keygen element.
     */
    prio(urgent) sync KeygenProcessValue(nsString oldValue,
                                         nsString challenge,
                                         nsString keytype,
                                         nsString keyparams)
        returns (nsString newValue);

    /**
     * Called to provide the options for <keygen> elements.
     */
    sync KeygenProvideContent()
        returns (nsString aAttribute, nsString[] aContent);

    // Use only for testing!
    sync GetFileReferences(PersistenceType persistenceType,
                           nsCString origin,
                           nsString databaseName,
                           int64_t fileId)
      returns (int32_t refCnt, int32_t dBRefCnt, int32_t sliceRefCnt,
               bool result);

    // Use only for testing!
    async FlushPendingFileDeletions();

    /**
     * Tell the chrome process there is an creation of PBrowser.
     * return a system-wise unique Id.
     */
    sync AllocateTabId(TabId openerTabId, IPCTabContext context, ContentParentId cpId)
        returns (TabId tabId);
    async DeallocateTabId(TabId tabId,
                          ContentParentId cpId,
                          bool aMarkedDestroying);

    /**
     * Tell the chrome process there is a destruction of PBrowser(Tab)
     */
    async NotifyTabDestroying(TabId tabId,
                              ContentParentId cpId);
    /**
     * 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 loadingPrincipal
     *   Principal 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).
     * @param tabId
     *   To identify which tab owns the app.
     */
    async POfflineCacheUpdate(URIParams manifestURI, URIParams documentURI,
                              PrincipalInfo loadingPrincipal, 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.
     */
    async SetOfflinePermission(Principal principal);

    /**
     * Notifies the parent to continue shutting down after the child performs
     * its shutdown tasks.
     */
    async FinishShutdown();

    async UpdateDropEffect(uint32_t aDragAction, uint32_t aDropEffect);

    /**
     * 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.
     * @param tabId
     *   To identify which tab issues this request.
     *
     * NOTE: The principal is untrusted in the parent process. Only
     *       principals that can live in the content process should
     *       provided.
     */
    async PContentPermissionRequest(PermissionRequest[] aRequests, Principal aPrincipal,
                                    TabId tabId);

    /**
     * Send ServiceWorkerRegistrationData to child process.
     */
    sync GetBrowserConfiguration(nsCString aUri)
        returns (BrowserConfiguration aConfig);

    /*
     * Tells the parent to start the gamepad listening service if it hasn't already.
     */
    async GamepadListenerAdded();

    /**
     * Tells the parent to stop the gamepad listening service if it hasn't already.
     */
    async GamepadListenerRemoved();

    async Profile(nsCString aProfile);

    /**
     * Request graphics initialization information from the parent.
     */
    sync GetGraphicsDeviceInitData()
        returns (DeviceInitData aData);

    sync CreateWindow(nullable PBrowser aThisTab,
                      PBrowser aNewTab,
                      PRenderFrame aRenderFrame,
                      uint32_t aChromeFlags,
                      bool aCalledFromJS,
                      bool aPositionSpecified,
                      bool aSizeSpecified,
                      nsString aName,
                      nsCString aFeatures,
                      nsCString aBaseURI,
                      OriginAttributes aOpenerOriginAttributes,
                      float aFullZoom)
      returns (nsresult rv,
               bool windowOpened,
               FrameScriptInfo[] frameScripts,
               nsCString urlToLoad,
               TextureFactoryIdentifier textureFactoryIdentifier,
               uint64_t layersId);

    sync GetDeviceStorageLocation(nsString type)
        returns (nsString path);

    sync GetDeviceStorageLocations()
	returns (DeviceStorageLocationInfo info);

    sync GetAndroidSystemInfo()
        returns (AndroidSystemInfo info);

    /**
     * Tells the parent to ungrab the pointer on the default display.
     *
     * This is for GTK platforms where we have to ensure the pointer ungrab happens in the
     * chrome process as that's the process that receives the pointer event.
     */
    sync UngrabPointer(uint32_t time);

    /**
     * Notify `push-message` observers without data in the parent.
     */
    async NotifyPushObservers(nsCString scope, nsString messageId);

    /**
     * Notify `push-message` observers with data in the parent.
     */
    async NotifyPushObserversWithData(nsCString scope, nsString messageId,
                                      uint8_t[] data);

    /**
     * Notify `push-subscription-change` observers in the parent.
     */
    async NotifyPushSubscriptionChangeObservers(nsCString scope);

    /**
     * Notify `push-subscription-lost` observers in the parent.
     */
    async NotifyPushSubscriptionLostObservers(nsCString scope, uint16_t reason);

both:
     async AsyncMessage(nsString aMessage, CpowEntry[] aCpows,
                        Principal aPrincipal, ClonedMessageData aData);
};

}
}