1019 lines
35 KiB
C++
1019 lines
35 KiB
C++
/* -*- 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 PBackground;
|
|
include protocol PBlob;
|
|
include protocol PBrowser;
|
|
include protocol PCompositorBridge;
|
|
include protocol PContentBridge;
|
|
include protocol PContentPermissionRequest;
|
|
include protocol PCycleCollectWithLogs;
|
|
include protocol PPSMContentDownloader;
|
|
include protocol PExternalHelperApp;
|
|
include protocol PHandlerService;
|
|
include protocol PFileDescriptorSet;
|
|
include protocol PHal;
|
|
include protocol PHeapSnapshotTempFileHelper;
|
|
include protocol PProcessHangMonitor;
|
|
include protocol PImageBridge;
|
|
include protocol PMedia;
|
|
include protocol PMemoryReportRequest;
|
|
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 PSendStream;
|
|
include protocol POfflineCacheUpdate;
|
|
include protocol PRenderFrame;
|
|
include protocol PScreenManager;
|
|
include protocol PSpeechSynthesis;
|
|
include protocol PStorage;
|
|
include protocol PTestShell;
|
|
include protocol PJavaScript;
|
|
include protocol PRemoteSpellcheckEngine;
|
|
include protocol PWebBrowserPersistDocument;
|
|
include protocol PWebrtcGlobal;
|
|
include protocol PVideoDecoderManager;
|
|
include protocol PFlyWebPublishedServer;
|
|
include DOMTypes;
|
|
include JavaScriptTypes;
|
|
include InputStreamParams;
|
|
include PTabContext;
|
|
include URIParams;
|
|
include PluginTypes;
|
|
include ProtocolTypes;
|
|
include PBackgroundSharedTypes;
|
|
include PContentPermission;
|
|
include ServiceWorkerConfiguration;
|
|
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";
|
|
|
|
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::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 mozilla::LayoutDeviceIntPoint from "Units.h";
|
|
using struct LookAndFeelInt from "mozilla/widget/WidgetMessageUtils.h";
|
|
using class mozilla::dom::MessagePort from "mozilla/dom/MessagePort.h";
|
|
using class mozilla::dom::ipc::StructuredCloneData from "mozilla/dom/ipc/StructuredCloneData.h";
|
|
using mozilla::DataStorageType from "ipc/DataStorageIPCUtils.h";
|
|
using mozilla::DocShellOriginAttributes from "mozilla/ipc/BackgroundUtils.h";
|
|
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
|
|
using struct mozilla::dom::FlyWebPublishOptions from "mozilla/dom/FlyWebPublishOptionsIPCSerializer.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;
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
struct DomainPolicyClone
|
|
{
|
|
bool active;
|
|
URIParams[] blacklist;
|
|
URIParams[] whitelist;
|
|
URIParams[] superBlacklist;
|
|
URIParams[] superWhitelist;
|
|
};
|
|
|
|
|
|
|
|
struct FrameScriptInfo
|
|
{
|
|
nsString url;
|
|
bool runInGlobalScope;
|
|
};
|
|
|
|
struct AndroidSystemInfo
|
|
{
|
|
nsString device;
|
|
nsString manufacturer;
|
|
nsString release_version;
|
|
nsString hardware;
|
|
uint32_t sdk_version;
|
|
bool isTablet;
|
|
};
|
|
|
|
struct GetFilesResponseSuccess
|
|
{
|
|
PBlob[] blobs;
|
|
};
|
|
|
|
struct GetFilesResponseFailure
|
|
{
|
|
nsresult errorCode;
|
|
};
|
|
|
|
union GetFilesResponseResult
|
|
{
|
|
GetFilesResponseSuccess;
|
|
GetFilesResponseFailure;
|
|
};
|
|
|
|
struct BlobURLRegistrationData
|
|
{
|
|
nsCString url;
|
|
PBlob blob;
|
|
Principal principal;
|
|
};
|
|
|
|
struct GMPAPITags
|
|
{
|
|
nsCString api;
|
|
nsCString[] tags;
|
|
};
|
|
|
|
struct GMPCapabilityData
|
|
{
|
|
nsCString name;
|
|
nsCString version;
|
|
GMPAPITags[] capabilities;
|
|
};
|
|
|
|
nested(upto inside_cpow) sync protocol PContent
|
|
{
|
|
parent spawns PPluginModule;
|
|
|
|
parent opens PProcessHangMonitor;
|
|
parent opens PGMPService;
|
|
child opens PBackground;
|
|
|
|
manages PBlob;
|
|
manages PBrowser;
|
|
manages PContentPermissionRequest;
|
|
manages PCycleCollectWithLogs;
|
|
manages PPSMContentDownloader;
|
|
manages PExternalHelperApp;
|
|
manages PFileDescriptorSet;
|
|
manages PHal;
|
|
manages PHandlerService;
|
|
manages PHeapSnapshotTempFileHelper;
|
|
manages PMedia;
|
|
manages PMemoryReportRequest;
|
|
manages PNecko;
|
|
manages POfflineCacheUpdate;
|
|
manages PPrinting;
|
|
manages PSendStream;
|
|
manages PScreenManager;
|
|
manages PSpeechSynthesis;
|
|
manages PStorage;
|
|
manages PTestShell;
|
|
manages PJavaScript;
|
|
manages PRemoteSpellcheckEngine;
|
|
manages PWebBrowserPersistDocument;
|
|
manages PWebrtcGlobal;
|
|
manages PFlyWebPublishedServer;
|
|
|
|
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);
|
|
|
|
// For parent->child, aBrowser must be non-null; aOuterWindowID can
|
|
// be 0 to indicate the browser's current root document, or nonzero
|
|
// to persist a subdocument. For child->parent, arguments are
|
|
// ignored and should be null/zero.
|
|
async PWebBrowserPersistDocument(nullable PBrowser aBrowser,
|
|
uint64_t aOuterWindowID);
|
|
|
|
child:
|
|
// Give the content process its endpoints to the compositor.
|
|
async InitRendering(
|
|
Endpoint<PCompositorBridgeChild> compositor,
|
|
Endpoint<PImageBridgeChild> imageBridge,
|
|
Endpoint<PVideoDecoderManagerChild> video);
|
|
|
|
// Re-create the rendering stack using the given endpoints. This is sent
|
|
// after the compositor process has crashed. The new endpoints may be to a
|
|
// newly launched GPU process, or the compositor thread of the UI process.
|
|
async ReinitRendering(
|
|
Endpoint<PCompositorBridgeChild> compositor,
|
|
Endpoint<PImageBridgeChild> bridge,
|
|
Endpoint<PVideoDecoderManagerChild> video);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* Sent to notify that aTabId has been allocated aLayersId
|
|
*/
|
|
async NotifyLayerAllocated(TabId aTabId, uint64_t aLayersId);
|
|
|
|
async SpeakerManagerNotify();
|
|
|
|
/**
|
|
* Communication between the PuppetBidiKeyboard and the actual
|
|
* BidiKeyboard hosted by the parent
|
|
*/
|
|
async BidiKeyboardNotify(bool isLangRTL, bool haveBidiKeyboards);
|
|
|
|
/**
|
|
* 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 RegisterChrome(ChromePackage[] packages, SubstitutionMapping[] substitutions,
|
|
OverrideMapping[] overrides, nsCString locale, bool reset);
|
|
async RegisterChromeItem(ChromeRegistryItem item);
|
|
|
|
async ClearImageCache(bool privateLoader, bool chrome);
|
|
|
|
async SetOffline(bool offline);
|
|
async SetConnectivity(bool connectivity);
|
|
|
|
async NotifyVisited(URIParams uri);
|
|
|
|
async PreferenceUpdate(PrefSetting pref);
|
|
async VarUpdate(GfxVarUpdate var);
|
|
|
|
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.
|
|
* @param aMsaaID is an a11y-specific unique id for the content process
|
|
* that is generated by the chrome process. Only used on
|
|
* Windows; pass 0 on other platforms.
|
|
*/
|
|
async ActivateA11y(uint32_t aMsaaID);
|
|
|
|
/**
|
|
* Shutdown accessibility engine in content process (if not in use).
|
|
*/
|
|
async ShutdownA11y();
|
|
|
|
async AppInfo(nsCString version, nsCString buildID, nsCString name, nsCString UAName,
|
|
nsCString ID, nsCString vendor);
|
|
async AppInit();
|
|
|
|
/**
|
|
* Send ServiceWorkerRegistrationData to child process.
|
|
*/
|
|
async InitServiceWorkers(ServiceWorkerConfiguration aConfig);
|
|
|
|
/**
|
|
* Send BlobURLRegistrationData to child process.
|
|
*/
|
|
async InitBlobURLs(BlobURLRegistrationData[] registrations);
|
|
|
|
// Notify child that last-pb-context-exited notification was observed
|
|
async LastPrivateDocShellDestroyed();
|
|
|
|
// 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);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
async InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action);
|
|
|
|
async EndDragSession(bool aDoneDrag, bool aUserCancelled,
|
|
LayoutDeviceIntPoint aDragEndPoint);
|
|
|
|
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);
|
|
|
|
/**
|
|
* Notify the child that cache is emptied.
|
|
*/
|
|
async NotifyEmptyHTTPCache();
|
|
|
|
/**
|
|
* 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, Principal principal, nsString message,
|
|
uint32_t flags);
|
|
|
|
/**
|
|
* Windows specific: associate this content process with the browsers
|
|
* audio session.
|
|
*/
|
|
async SetAudioSessionData(nsID aID,
|
|
nsString aDisplayName,
|
|
nsString aIconPath);
|
|
|
|
async GetFilesResponse(nsID aID, GetFilesResponseResult aResult);
|
|
|
|
async BlobURLRegistration(nsCString aURI, PBlob aBlob,
|
|
Principal aPrincipal);
|
|
|
|
async BlobURLUnregistration(nsCString aURI);
|
|
|
|
|
|
async GMPsChanged(GMPCapabilityData[] capabilities);
|
|
|
|
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,
|
|
bool haveBidiKeyboards, nsString[] dictionaries,
|
|
ClipboardCapabilities clipboardCaps,
|
|
DomainPolicyClone domainPolicy,
|
|
StructuredCloneData initialData,
|
|
OptionalURIParams userContentSheetURL);
|
|
|
|
sync CreateChildProcess(IPCTabContext context,
|
|
ProcessPriority priority,
|
|
TabId openerTabId)
|
|
returns (ContentParentId cpId, bool isForApp, bool isForBrowser, TabId tabId);
|
|
sync BridgeToChildProcess(ContentParentId cpId);
|
|
|
|
async CreateGMPService();
|
|
|
|
/**
|
|
* 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();
|
|
|
|
/**
|
|
* 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);
|
|
|
|
sync IsSecureURI(uint32_t type, URIParams uri, uint32_t flags)
|
|
returns (bool isSecureURI);
|
|
|
|
sync GetLookAndFeelCache()
|
|
returns (LookAndFeelInt[] lookAndFeelIntCache);
|
|
|
|
nested(inside_cpow) async PHal();
|
|
|
|
async PHeapSnapshotTempFileHelper();
|
|
|
|
async PNecko();
|
|
|
|
async PPrinting();
|
|
|
|
async PSendStream();
|
|
|
|
nested(inside_sync) sync PScreenManager()
|
|
returns (uint32_t numberOfScreens,
|
|
float systemDefaultScale,
|
|
bool success);
|
|
|
|
async PSpeechSynthesis();
|
|
|
|
nested(inside_cpow) async PStorage();
|
|
|
|
async PMedia();
|
|
|
|
async PWebrtcGlobal();
|
|
|
|
async PFlyWebPublishedServer(nsString name, FlyWebPublishOptions params);
|
|
|
|
// 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);
|
|
async ExtProtocolChannelConnectParent(uint32_t registrarId);
|
|
|
|
// PrefService message
|
|
sync ReadPrefsArray() returns (PrefSetting[] prefs) verify;
|
|
sync GetGfxVars() returns (GfxVarUpdate[] vars);
|
|
|
|
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);
|
|
|
|
nested(inside_sync) 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,
|
|
bool aWasFileChannel,
|
|
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,
|
|
Principal aRequestingPrincipal,
|
|
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);
|
|
|
|
// 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, Principal aLoadingPrincipal, 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.
|
|
*/
|
|
nested(inside_cpow) 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);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* Request graphics initialization information from the parent.
|
|
*/
|
|
sync GetGraphicsDeviceInitData()
|
|
returns (ContentDeviceData aData);
|
|
|
|
sync CreateWindow(nullable PBrowser aThisTab,
|
|
PBrowser aNewTab,
|
|
PRenderFrame aRenderFrame,
|
|
uint32_t aChromeFlags,
|
|
bool aCalledFromJS,
|
|
bool aPositionSpecified,
|
|
bool aSizeSpecified,
|
|
nsCString aFeatures,
|
|
nsCString aBaseURI,
|
|
DocShellOriginAttributes aOpenerOriginAttributes,
|
|
float aFullZoom)
|
|
returns (nsresult rv,
|
|
bool windowOpened,
|
|
FrameScriptInfo[] frameScripts,
|
|
nsCString urlToLoad,
|
|
TextureFactoryIdentifier textureFactoryIdentifier,
|
|
uint64_t layersId);
|
|
|
|
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);
|
|
|
|
sync RemovePermission(Principal principal, nsCString permissionType) returns (nsresult rv);
|
|
|
|
/**
|
|
* Tell the parent that a decoder's' benchmark has been completed.
|
|
* The result can then be stored in permanent storage.
|
|
*/
|
|
async NotifyBenchmarkResult(nsString aCodecName, uint32_t aDecodeFPS);
|
|
|
|
/**
|
|
* Notify `push-message` observers without data in the parent.
|
|
*/
|
|
async NotifyPushObservers(nsCString scope, Principal principal,
|
|
nsString messageId);
|
|
|
|
/**
|
|
* Notify `push-message` observers with data in the parent.
|
|
*/
|
|
async NotifyPushObserversWithData(nsCString scope, Principal principal,
|
|
nsString messageId, uint8_t[] data);
|
|
|
|
/**
|
|
* Notify `push-subscription-change` observers in the parent.
|
|
*/
|
|
async NotifyPushSubscriptionChangeObservers(nsCString scope,
|
|
Principal principal);
|
|
|
|
/**
|
|
* Tell the parent process that the child process is low on memory. This
|
|
* allows the parent process to save a memory report that can potentially be
|
|
* sent with a crash report from the content process.
|
|
*/
|
|
async NotifyLowMemory();
|
|
|
|
async GetFilesRequest(nsID aID, nsString aDirectory, bool aRecursiveFlag);
|
|
async DeleteGetFilesRequest(nsID aID);
|
|
|
|
async StoreAndBroadcastBlobURLRegistration(nsCString url, PBlob blob,
|
|
Principal principal);
|
|
|
|
async UnstoreAndBroadcastBlobURLUnregistration(nsCString url);
|
|
|
|
sync GetA11yContentId() returns (uint32_t aContentId);
|
|
|
|
both:
|
|
async AsyncMessage(nsString aMessage, CpowEntry[] aCpows,
|
|
Principal aPrincipal, ClonedMessageData aData);
|
|
|
|
/**
|
|
* Notify `push-subscription-modified` observers in the parent and child.
|
|
*/
|
|
async NotifyPushSubscriptionModifiedObservers(nsCString scope,
|
|
Principal principal);
|
|
};
|
|
|
|
}
|
|
}
|