The Tor Browser: dom/ipc/PContent.ipdl@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */

     2 /* vim: set sw=4 ts=8 et tw=80 ft=cpp : */

     3 /* This Source Code Form is subject to the terms of the Mozilla Public

     4  * License, v. 2.0. If a copy of the MPL was not distributed with this

     5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     7 include protocol PAsmJSCacheEntry;

     8 include protocol PBackground;

     9 include protocol PBlob;

    10 include protocol PBluetooth;

    11 include protocol PBrowser;

    12 include protocol PCompositor;

    13 include protocol PCrashReporter;

    14 include protocol PExternalHelperApp;

    15 include protocol PDeviceStorageRequest;

    16 include protocol PFileDescriptorSet;

    17 include protocol PFMRadio;

    18 include protocol PFileSystemRequest;

    19 include protocol PHal;

    20 include protocol PImageBridge;

    21 include protocol PIndexedDB;

    22 include protocol PMemoryReportRequest;

    23 include protocol PNecko;

    24 include protocol PSms;

    25 include protocol PSpeechSynthesis;

    26 include protocol PStorage;

    27 include protocol PTelephony;

    28 include protocol PTestShell;

    29 include protocol PJavaScript;

    30 include DOMTypes;

    31 include JavaScriptTypes;

    32 include InputStreamParams;

    33 include PTabContext;

    34 include URIParams;

    35 include ProtocolTypes;

    37 using GeoPosition from "nsGeoPositionIPCSerialiser.h";

    39 using struct ChromePackage from "mozilla/chrome/RegistryMessageUtils.h";

    40 using struct ResourceMapping from "mozilla/chrome/RegistryMessageUtils.h";

    41 using struct OverrideMapping from "mozilla/chrome/RegistryMessageUtils.h";

    42 using base::ChildPrivileges from "base/process_util.h";

    43 using struct IPC::Permission from "mozilla/net/NeckoMessageUtils.h";

    44 using class IPC::Principal from "mozilla/dom/PermissionMessageUtils.h";

    45 using struct mozilla::null_t from "ipc/IPCMessageUtils.h";

    46 using struct mozilla::void_t from "ipc/IPCMessageUtils.h";

    47 using mozilla::dom::asmjscache::OpenMode from "mozilla/dom/asmjscache/AsmJSCache.h";

    48 using mozilla::dom::asmjscache::WriteParams from "mozilla/dom/asmjscache/AsmJSCache.h";

    49 using mozilla::dom::AudioChannel from "mozilla/dom/AudioChannelBinding.h";

    50 using mozilla::dom::AudioChannelState from "AudioChannelCommon.h";

    51 using mozilla::dom::NativeThreadId from "mozilla/dom/TabMessageUtils.h";

    52 using mozilla::hal::ProcessPriority from "mozilla/HalTypes.h";

    53 using gfxIntSize from "nsSize.h";

    55 namespace mozilla {

    56 namespace dom {

    58 struct FontListEntry {

    59     nsString  familyName;

    60     nsString  faceName;

    61     nsCString filepath;

    62     uint16_t  weight;

    63     int16_t   stretch;

    64     uint8_t   italic;

    65     uint8_t   index;

    66 };

    68 struct DeviceStorageFreeSpaceParams

    69 {

    70   nsString type;

    71   nsString storageName;

    72 };

    74 struct DeviceStorageUsedSpaceParams

    75 {

    76   nsString type;

    77   nsString storageName;

    78 };

    80 struct DeviceStorageAvailableParams

    81 {

    82   nsString type;

    83   nsString storageName;

    84 };

    86 struct DeviceStorageStatusParams

    87 {

    88   nsString type;

    89   nsString storageName;

    90 };

    92 struct DeviceStorageFormatParams

    93 {

    94   nsString type;

    95   nsString storageName;

    96 };

    98 struct DeviceStorageMountParams

    99 {

   100   nsString type;

   101   nsString storageName;

   102 };

   104 struct DeviceStorageUnmountParams

   105 {

   106   nsString type;

   107   nsString storageName;

   108 };

   110 struct DeviceStorageAddParams

   111 {

   112   nsString type;

   113   nsString storageName;

   114   nsString relpath;

   115   PBlob blob;

   116 };

   118 struct DeviceStorageCreateFdParams

   119 {

   120   nsString type;

   121   nsString storageName;

   122   nsString relpath;

   123 };

   125 struct DeviceStorageGetParams

   126 {

   127   nsString type;

   128   nsString storageName;

   129   nsString rootDir;

   130   nsString relpath;

   131 };

   133 struct DeviceStorageDeleteParams

   134 {

   135   nsString type;

   136   nsString storageName;

   137   nsString relpath;

   138 };

   140 struct DeviceStorageEnumerationParams

   141 {

   142   nsString type;

   143   nsString storageName;

   144   nsString rootdir;

   145   uint64_t since;

   146 };

   148 union DeviceStorageParams

   149 {

   150   DeviceStorageAddParams;

   151   DeviceStorageCreateFdParams;

   152   DeviceStorageGetParams;

   153   DeviceStorageDeleteParams;

   154   DeviceStorageEnumerationParams;

   155   DeviceStorageFreeSpaceParams;

   156   DeviceStorageUsedSpaceParams;

   157   DeviceStorageAvailableParams;

   158   DeviceStorageStatusParams;

   159   DeviceStorageFormatParams;

   160   DeviceStorageMountParams;

   161   DeviceStorageUnmountParams;

   162 };

   164 struct FMRadioRequestEnableParams

   165 {

   166   double frequency;

   167 };

   169 struct FMRadioRequestDisableParams

   170 {

   172 };

   174 struct FMRadioRequestSetFrequencyParams

   175 {

   176   double frequency;

   177 };

   179 struct FMRadioRequestSeekParams

   180 {

   181   bool upward;

   182 };

   184 struct FMRadioRequestCancelSeekParams

   185 {

   187 };

   189 union FMRadioRequestParams

   190 {

   191   FMRadioRequestEnableParams;

   192   FMRadioRequestDisableParams;

   193   FMRadioRequestSetFrequencyParams;

   194   FMRadioRequestSeekParams;

   195   FMRadioRequestCancelSeekParams;

   196 };

   198 struct FileSystemCreateDirectoryParams

   199 {

   200   nsString filesystem;

   201   nsString realPath;

   202 };

   204 union FileSystemFileDataValue

   205 {

   206   uint8_t[];

   207   PBlob;

   208 };

   210 struct FileSystemCreateFileParams

   211 {

   212   nsString filesystem;

   213   nsString realPath;

   214   FileSystemFileDataValue data;

   215   bool replace;

   216 };

   218 struct FileSystemGetFileOrDirectoryParams

   219 {

   220   nsString filesystem;

   221   nsString realPath;

   222 };

   224 union FileSystemPathOrFileValue

   225 {

   226   nsString;

   227   PBlob;

   228 };

   230 struct FileSystemRemoveParams

   231 {

   232   nsString filesystem;

   233   nsString directory;

   234   FileSystemPathOrFileValue target;

   235   bool recursive;

   236 };

   238 union FileSystemParams

   239 {

   240   FileSystemCreateDirectoryParams;

   241   FileSystemCreateFileParams;

   242   FileSystemGetFileOrDirectoryParams;

   243   FileSystemRemoveParams;

   244 };

   246 union PrefValue {

   247   nsCString;

   248   int32_t;

   249   bool;

   250 };

   252 union MaybePrefValue {

   253   PrefValue;

   254   null_t;

   255 };

   257 struct PrefSetting {

   258   nsCString name;

   259   MaybePrefValue defaultValue;

   260   MaybePrefValue userValue;

   261 };

   263 intr protocol PContent

   264 {

   265     parent opens PCompositor;

   266     parent opens PImageBridge;

   267     child opens PBackground;

   269     manages PAsmJSCacheEntry;

   270     manages PBlob;

   271     manages PBluetooth;

   272     manages PBrowser;

   273     manages PCrashReporter;

   274     manages PDeviceStorageRequest;

   275     manages PFileSystemRequest;

   276     manages PExternalHelperApp;

   277     manages PFileDescriptorSet;

   278     manages PFMRadio;

   279     manages PHal;

   280     manages PIndexedDB;

   281     manages PMemoryReportRequest;

   282     manages PNecko;

   283     manages PSms;

   284     manages PSpeechSynthesis;

   285     manages PStorage;

   286     manages PTelephony;

   287     manages PTestShell;

   288     manages PJavaScript;

   290 both:

   291     // Depending on exactly how the new browser is being created, it might be

   292     // created from either the child or parent process!

   293     //

   294     // The child creates the PBrowser as part of

   295     // TabChild::BrowserFrameProvideWindow (which happens when the child's

   296     // content calls window.open()), and the parent creates the PBrowser as part

   297     // of ContentParent::CreateBrowserOrApp.

   298     //

   299     // When the parent constructs a PBrowser, the child trusts the app token it

   300     // receives from the parent.  In that case, context can be any of the

   301     // IPCTabContext subtypes.

   302     //

   303     // When the child constructs a PBrowser, the parent doesn't trust the app

   304     // token it receives from the child.  In this case, context must have type

   305     // PopupIPCTabContext.  The browser created using a PopupIPCTabContext has

   306     // the opener PBrowser's app-id and containing-app-id.  The parent checks

   307     // that if the opener is a browser element, the context is also for a

   308     // browser element.

   309     //

   310     // This allows the parent to prevent a malicious child from escalating its

   311     // privileges by requesting a PBrowser corresponding to a highly-privileged

   312     // app; the child can only request privileges for an app which the child has

   313     // access to (in the form of a TabChild).

   314     async PBrowser(IPCTabContext context, uint32_t chromeFlags);

   316     async PBlob(BlobConstructorParams params);

   318     async PJavaScript();

   320     PFileDescriptorSet(FileDescriptor fd);

   322 child:

   323     /**

   324      * Enable system-level sandboxing features, if available.  Can

   325      * usually only be performed zero or one times.  The child may

   326      * abnormally exit if this fails; the details are OS-specific.

   327      */

   328     async SetProcessSandbox();

   330     PMemoryReportRequest(uint32_t generation, bool minimizeMemoryUsage, nsString DMDDumpIdent);

   332     /**

   333      * Notify the AudioChannelService in the child processes.

   334      */

   335     async AudioChannelNotify();

   337     async SpeakerManagerNotify();

   339     /**

   340      * Dump this process's GC and CC logs.

   341      *

   342      * For documentation on the args, see dumpGCAndCCLogsToFile in

   343      * nsIMemoryInfoDumper.idl

   344      */

   345     async DumpGCAndCCLogsToFile(nsString identifier,

   346                                 bool dumpAllTraces,

   347                                 bool dumpChildProcesses);

   349     PTestShell();

   351     RegisterChrome(ChromePackage[] packages, ResourceMapping[] resources,

   352                    OverrideMapping[] overrides, nsCString locale);

   354     async SetOffline(bool offline);

   356     async NotifyVisited(URIParams uri);

   358     PreferenceUpdate(PrefSetting pref);

   360     NotifyAlertsObserver(nsCString topic, nsString data);

   362     GeolocationUpdate(GeoPosition somewhere);

   364     // nsIPermissionManager messages

   365     AddPermission(Permission permission);

   367     ScreenSizeChanged(gfxIntSize size);

   369     FlushMemory(nsString reason);

   371     GarbageCollect();

   372     CycleCollect();

   374     /**

   375      * Start accessibility engine in content process.

   376      */

   377     ActivateA11y();

   379     AppInfo(nsCString version, nsCString buildID, nsCString name, nsCString UAName);

   381     // Notify child that last-pb-context-exited notification was observed

   382     LastPrivateDocShellDestroyed();

   384     FilePathUpdate(nsString storageType, nsString storageName, nsString filepath,

   385                    nsCString reasons);

   387     FileSystemUpdate(nsString fsName, nsString mountPoint, int32_t fsState,

   388                      int32_t mountGeneration, bool isMediaPresent,

   389                      bool isSharing, bool isFormatting);

   391     // Ask the Nuwa process to create a new child process.

   392     NuwaFork();

   394     NotifyProcessPriorityChanged(ProcessPriority priority);

   395     MinimizeMemoryUsage();

   397     /**

   398      * Used to manage nsIStyleSheetService across processes.

   399      */

   400     async LoadAndRegisterSheet(URIParams uri, uint32_t type);

   401     async UnregisterSheet(URIParams uri, uint32_t type);

   403     NotifyPhoneStateChange(nsString newState);

   405     /**

   406      * Notify idle observers in the child

   407      */

   408     NotifyIdleObserver(uint64_t observerId, nsCString topic, nsString str);

   409 parent:

   410     /**

   411      * Tell the content process some attributes of itself.  This is

   412      * among the first information queried by content processes after

   413      * startup.  (The message is sync to allow the content process to

   414      * control when it receives the information.)

   415      *

   416      * |id| is a unique ID among all subprocesses.  When |isForApp &&

   417      * isForBrowser|, we're loading <browser> for an app.  When

   418      * |isForBrowser|, we're loading <browser>.  When |!isForApp &&

   419      * !isForBrowser|, we're probably loading <xul:browser remote>.

   420      */

   421     sync GetProcessAttributes()

   422         returns (uint64_t id, bool isForApp, bool isForBrowser);

   423     sync GetXPCOMProcessAttributes()

   424         returns (bool isOffline);

   426     PDeviceStorageRequest(DeviceStorageParams params);

   428     PFileSystemRequest(FileSystemParams params);

   430     sync PCrashReporter(NativeThreadId tid, uint32_t processType);

   432     sync GetRandomValues(uint32_t length)

   433         returns (uint8_t[] randomValues);

   435     PHal();

   437     PIndexedDB();

   439     PNecko();

   441     PSms();

   443     PSpeechSynthesis();

   445     PStorage();

   447     PTelephony();

   449     PBluetooth();

   451     PFMRadio();

   453     PAsmJSCacheEntry(OpenMode openMode, WriteParams write, Principal principal);

   455     // Services remoting

   457     async StartVisitedQuery(URIParams uri);

   458     async VisitURI(URIParams uri, OptionalURIParams referrer, uint32_t flags);

   459     async SetURITitle(URIParams uri, nsString title);

   461     async LoadURIExternal(URIParams uri);

   463     // PrefService message

   464     sync ReadPrefsArray() returns (PrefSetting[] prefs);

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

   468     sync SyncMessage(nsString aMessage, ClonedMessageData aData,

   469                      CpowEntry[] aCpows, Principal aPrincipal)

   470       returns (nsString[] retval);

   472     rpc RpcMessage(nsString aMessage, ClonedMessageData aData,

   473                    CpowEntry[] aCpows, Principal aPrincipal)

   474       returns (nsString[] retval);

   476     ShowAlertNotification(nsString imageUrl,

   477                           nsString title,

   478                           nsString text,

   479                           bool textClickable,

   480                           nsString cookie,

   481                           nsString name,

   482                           nsString bidi,

   483                           nsString lang,

   484                           Principal principal);

   486     CloseAlert(nsString name, Principal principal);

   488     PExternalHelperApp(OptionalURIParams uri,

   489                        nsCString aMimeContentType,

   490                        nsCString aContentDisposition,

   491                        uint32_t aContentDispositionHint,

   492                        nsString aContentDispositionFilename,

   493                        bool aForceSave,

   494                        int64_t aContentLength,

   495                        OptionalURIParams aReferrer,

   496                        nullable PBrowser aBrowser);

   498     AddGeolocationListener(Principal principal, bool highAccuracy);

   499     RemoveGeolocationListener();

   500     SetGeolocationHigherAccuracy(bool enable);

   502     ConsoleMessage(nsString message);

   503     ScriptError(nsString message, nsString sourceName, nsString sourceLine,

   504                 uint32_t lineNumber, uint32_t colNumber, uint32_t flags,

   505                 nsCString category);

   507     // nsIPermissionManager messages

   508     sync ReadPermissions() returns (Permission[] permissions);

   510     SetClipboardText(nsString text, bool isPrivateData, int32_t whichClipboard);

   511     sync GetClipboardText(int32_t whichClipboard)

   512         returns (nsString text);

   513     EmptyClipboard(int32_t whichClipboard);

   514     sync ClipboardHasText(int32_t whichClipboard)

   515         returns (bool hasText);

   517     sync GetSystemColors(uint32_t colorsCount)

   518         returns (uint32_t[] colors);

   520     sync GetIconForExtension(nsCString aFileExt, uint32_t aIconSize)

   521         returns (uint8_t[] bits);

   523     sync GetShowPasswordSetting()

   524         returns (bool showPassword);

   526     // Notify the parent of the presence or absence of private docshells

   527     PrivateDocShellsExist(bool aExist);

   529     // Tell the parent that the child has gone idle for the first time

   530     async FirstIdle();

   532     // Get Muted from the main AudioChannelService.

   533     sync AudioChannelGetState(AudioChannel aChannel, bool aElementHidden,

   534                               bool aElementWasHidden)

   535         returns (AudioChannelState value);

   537     sync AudioChannelRegisterType(AudioChannel aChannel, bool aWithVideo);

   538     sync AudioChannelUnregisterType(AudioChannel aChannel,

   539                                     bool aElementHidden,

   540                                     bool aWithVideo);

   542     async AudioChannelChangedNotification();

   543     async AudioChannelChangeDefVolChannel(int32_t aChannel, bool aHidden);

   545     async FilePathUpdateNotify(nsString aType,

   546                                nsString aStorageName,

   547                                nsString aFilepath,

   548                                nsCString aReason);

   549     // get nsIVolumeService to broadcast volume information

   550     async BroadcastVolume(nsString volumeName);

   552     // Notify the parent that the child has finished handling a system message.

   553     async SystemMessageHandled();

   555     NuwaReady();

   557     sync AddNewProcess(uint32_t pid, ProtocolFdMapping[] aFds);

   559     // called by the child (test code only) to propagate volume changes to the parent

   560     async CreateFakeVolume(nsString fsName, nsString mountPoint);

   561     async SetFakeVolumeState(nsString fsName, int32_t fsState);

   563     sync KeywordToURI(nsCString keyword)

   564         returns (OptionalInputStreamParams postData, OptionalURIParams uri);

   566     sync SpeakerManagerForceSpeaker(bool aEnable);

   568     sync SpeakerManagerGetSpeakerStatus()

   569         returns (bool value);

   571     /**

   572      * Notifies the parent about a recording device is starting or shutdown.

   573      * @param recordingStatus starting or shutdown

   574      * @param pageURL URL that request that changing the recording status

   575      * @param isAudio recording start with microphone

   576      * @param isVideo recording start with camera

   577      */

   578     async RecordingDeviceEvents(nsString recordingStatus,

   579                                 nsString pageURL,

   580                                 bool isAudio,

   581                                 bool isVideo);

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

   585     AddIdleObserver(uint64_t observerId, uint32_t idleTimeInS);

   586     RemoveIdleObserver(uint64_t observerId, uint32_t idleTimeInS);

   588     /**

   589      * This message is only used on X11 platforms.

   590      *

   591      * Send a dup of the plugin process's X socket to the parent

   592      * process.  In theory, this scheme keeps the plugin's X resources

   593      * around until after both the plugin process shuts down *and* the

   594      * parent process closes the dup fd.  This is used to prevent the

   595      * parent process from crashing on X errors if, e.g., the plugin

   596      * crashes *just before* a repaint and the parent process tries to

   597      * use the newly-invalid surface.

   598      */

   599     BackUpXResources(FileDescriptor aXSocketFd);

   601 both:

   602      AsyncMessage(nsString aMessage, ClonedMessageData aData,

   603                   CpowEntry[] aCpows, Principal aPrincipal);

   604 };

   606 }

   607 }

The Tor Browser / file revision

dom/ipc/PContent.ipdl@6474c204b198

dom/ipc/PContent.ipdl