--- a/accessible/ipc/PDocAccessible.ipdl
+++ b/accessible/ipc/PDocAccessible.ipdl
@@ -43,38 +43,38 @@ struct RelationTargets
uint64_t[] Targets;
};
prio(normal upto high) sync protocol PDocAccessible
{
manager PBrowser;
parent:
- Shutdown();
+ async Shutdown();
/*
* Notify the parent process the document in the child process is firing an
* event.
*/
- Event(uint64_t aID, uint32_t type);
- ShowEvent(ShowEventData data);
- HideEvent(uint64_t aRootID);
- StateChangeEvent(uint64_t aID, uint64_t aState, bool aEnabled);
- CaretMoveEvent(uint64_t aID, int32_t aOffset);
- TextChangeEvent(uint64_t aID, nsString aStr, int32_t aStart, uint32_t aLen,
- bool aIsInsert, bool aFromUser);
+ async Event(uint64_t aID, uint32_t type);
+ async ShowEvent(ShowEventData data);
+ async HideEvent(uint64_t aRootID);
+ async StateChangeEvent(uint64_t aID, uint64_t aState, bool aEnabled);
+ async CaretMoveEvent(uint64_t aID, int32_t aOffset);
+ async TextChangeEvent(uint64_t aID, nsString aStr, int32_t aStart, uint32_t aLen,
+ bool aIsInsert, bool aFromUser);
/*
* Tell the parent document to bind the existing document as a new child
* document.
*/
- BindChildDoc(PDocAccessible aChildDoc, uint64_t aID);
+ async BindChildDoc(PDocAccessible aChildDoc, uint64_t aID);
child:
- __delete__();
+ async __delete__();
// Accessible
prio(high) sync State(uint64_t aID) returns(uint64_t states);
prio(high) sync NativeState(uint64_t aID) returns(uint64_t states);
prio(high) sync Name(uint64_t aID) returns(nsString name);
prio(high) sync Value(uint64_t aID) returns(nsString value);
prio(high) sync Help(uint64_t aID) returns(nsString help);
prio(high) sync Description(uint64_t aID) returns(nsString desc);
@@ -127,23 +127,23 @@ child:
prio(high) sync SetSelectionBoundsAt(uint64_t aID, int32_t aSelectionNum,
int32_t aStartOffset, int32_t aEndOffset)
returns(bool aSucceeded);
prio(high) sync AddToSelection(uint64_t aID, int32_t aStartOffset, int32_t aEndOffset)
returns(bool aSucceeded);
prio(high) sync RemoveFromSelection(uint64_t aID, int32_t aSelectionNum)
returns(bool aSucceeded);
- ScrollSubstringTo(uint64_t aID, int32_t aStartOffset, int32_t aEndOffset,
- uint32_t aScrollType);
- ScrollSubstringToPoint(uint64_t aID,
- int32_t aStartOffset,
- int32_t aEndOffset,
- uint32_t aCoordinateType,
- int32_t aX, int32_t aY);
+ async ScrollSubstringTo(uint64_t aID, int32_t aStartOffset, int32_t aEndOffset,
+ uint32_t aScrollType);
+ async ScrollSubstringToPoint(uint64_t aID,
+ int32_t aStartOffset,
+ int32_t aEndOffset,
+ uint32_t aCoordinateType,
+ int32_t aX, int32_t aY);
prio(high) sync Text(uint64_t aID) returns(nsString aText);
prio(high) sync ReplaceText(uint64_t aID, nsString aText);
prio(high) sync InsertText(uint64_t aID, nsString aText, int32_t aPosition)
returns(bool aValid);
prio(high) sync CopyText(uint64_t aID, int32_t aStartPos, int32_t aEndPos)
returns(bool aValid);
prio(high) sync CutText(uint64_t aID, int32_t aStartPos, int32_t aEndPos)
--- a/devtools/shared/heapsnapshot/PHeapSnapshotTempFileHelper.ipdl
+++ b/devtools/shared/heapsnapshot/PHeapSnapshotTempFileHelper.ipdl
@@ -23,13 +23,13 @@ union OpenHeapSnapshotTempFileResponse
sync protocol PHeapSnapshotTempFileHelper
{
manager PContent;
parent:
sync OpenHeapSnapshotTempFile() returns (OpenHeapSnapshotTempFileResponse response);
- __delete__();
+ async __delete__();
};
} // namespace devtools
} // namespace mozilla
--- a/dom/asmjscache/PAsmJSCacheEntry.ipdl
+++ b/dom/asmjscache/PAsmJSCacheEntry.ipdl
@@ -14,25 +14,25 @@ namespace asmjscache {
protocol PAsmJSCacheEntry
{
manager PBackground;
// When the cache is opened to read, the parent process sends over the
// origin's Metadata so the child process can select the cache entry to open
// (based on hash) and notify the parent (via SelectCacheFileToRead).
child:
- OnOpenMetadataForRead(Metadata metadata);
+ async OnOpenMetadataForRead(Metadata metadata);
parent:
- SelectCacheFileToRead(uint32_t moduleIndex);
- CacheMiss();
+ async SelectCacheFileToRead(uint32_t moduleIndex);
+ async CacheMiss();
child:
// Once the cache file has been opened, the child is notified and sent an
// open file descriptor.
- OnOpenCacheFile(int64_t fileSize, FileDescriptor fileDesc);
+ async OnOpenCacheFile(int64_t fileSize, FileDescriptor fileDesc);
both:
- __delete__(AsmJSCacheResult result);
+ async __delete__(AsmJSCacheResult result);
};
} // namespace asmjscache
} // namespace dom
} // namespace mozilla
--- a/dom/bluetooth/ipc/PBluetooth.ipdl
+++ b/dom/bluetooth/ipc/PBluetooth.ipdl
@@ -540,63 +540,63 @@ protocol PBluetooth
* 3. NotificationsStopped (Parent -> Child)
* 4. __delete__() (Child -> Parent)
*/
child:
/**
* Sent when a settings change has enabled or disabled the bluetooth firmware.
*/
- Enabled(bool enabled);
+ async Enabled(bool enabled);
/**
* Sent when a bluetooth signal is broadcasted to child processes.
*/
- Notify(BluetoothSignal signal);
+ async Notify(BluetoothSignal signal);
/**
* Sent when the parent process is about to be shut down. See shutdown note
* above.
*/
- BeginShutdown();
+ async BeginShutdown();
/**
* Sent to inform the child process that it will no longer receive any
* messages from the parent. See shutdown note above.
*/
- NotificationsStopped();
+ async NotificationsStopped();
parent:
/**
* Sent when the child no longer needs to use bluetooth. See shutdown note
* above.
*/
- __delete__();
+ async __delete__();
/**
* Sent when the child needs to receive signals related to the given node.
*/
- RegisterSignalHandler(nsString node);
+ async RegisterSignalHandler(nsString node);
/**
* Sent when the child no longer needs to receive signals related to the given
* node.
*/
- UnregisterSignalHandler(nsString node);
+ async UnregisterSignalHandler(nsString node);
/**
* Sent when the child no longer needs to receive any messages from the
* parent. See shutdown note above.
*/
- StopNotifying();
+ async StopNotifying();
/**
* Sent when the child makes an asynchronous request to the parent.
*/
- PBluetoothRequest(Request request);
+ async PBluetoothRequest(Request request);
/**
* FIXME: Bug 547703.
*
* This is the state machine we want:
*
* start state NOTIFYING:
* send Enabled goto NOTIFYING;
--- a/dom/bluetooth/ipc/PBluetoothRequest.ipdl
+++ b/dom/bluetooth/ipc/PBluetoothRequest.ipdl
@@ -15,14 +15,14 @@ namespace bluetooth {
protocol PBluetoothRequest
{
manager PBluetooth;
child:
/**
* Sent when the asynchronous request has completed.
*/
- __delete__(BluetoothReply response);
+ async __delete__(BluetoothReply response);
};
} // namespace bluetooth
} // namespace dom
} // namespace mozilla
--- a/dom/broadcastchannel/PBroadcastChannel.ipdl
+++ b/dom/broadcastchannel/PBroadcastChannel.ipdl
@@ -12,18 +12,18 @@ namespace mozilla {
namespace dom {
// This protocol is used for the BroadcastChannel API
protocol PBroadcastChannel
{
manager PBackground;
parent:
- PostMessage(ClonedMessageData message);
- Close();
+ async PostMessage(ClonedMessageData message);
+ async Close();
child:
- Notify(ClonedMessageData message);
- __delete__();
+ async Notify(ClonedMessageData message);
+ async __delete__();
};
} // namespace dom
} // namespace mozilla
--- a/dom/cache/PCache.ipdl
+++ b/dom/cache/PCache.ipdl
@@ -17,19 +17,19 @@ namespace cache {
protocol PCache
{
manager PBackground;
manages PCacheOp;
manages PCachePushStream;
parent:
- PCacheOp(CacheOpArgs aOpArgs);
- PCachePushStream();
- Teardown();
+ async PCacheOp(CacheOpArgs aOpArgs);
+ async PCachePushStream();
+ async Teardown();
child:
- __delete__();
+ async __delete__();
};
} // namespace cache
} // namespace dom
} // namespace mozilla
--- a/dom/cache/PCacheOp.ipdl
+++ b/dom/cache/PCacheOp.ipdl
@@ -16,14 +16,14 @@ namespace mozilla {
namespace dom {
namespace cache {
protocol PCacheOp
{
manager PCache or PCacheStorage;
child:
- __delete__(ErrorResult aRv, CacheOpResult aResult);
+ async __delete__(ErrorResult aRv, CacheOpResult aResult);
};
} // namespace cache
} // namespace dom
} // namespace mozilla
--- a/dom/cache/PCachePushStream.ipdl
+++ b/dom/cache/PCachePushStream.ipdl
@@ -8,21 +8,21 @@ namespace mozilla {
namespace dom {
namespace cache {
protocol PCachePushStream
{
manager PCache;
parent:
- Buffer(nsCString aBuffer);
- Close(nsresult aRv);
+ async Buffer(nsCString aBuffer);
+ async Close(nsresult aRv);
child:
// Stream is always destroyed from the parent side. This occurs if the
// parent encounters an error while writing to its pipe or if the child
// signals the stream should close by SendClose().
- __delete__();
+ async __delete__();
};
} // namespace cache
} // namespace dom
} // namespace mozilla
--- a/dom/cache/PCacheStorage.ipdl
+++ b/dom/cache/PCacheStorage.ipdl
@@ -17,18 +17,18 @@ namespace dom {
namespace cache {
protocol PCacheStorage
{
manager PBackground;
manages PCacheOp;
parent:
- PCacheOp(CacheOpArgs aOpArgs);
- Teardown();
+ async PCacheOp(CacheOpArgs aOpArgs);
+ async Teardown();
child:
- __delete__();
+ async __delete__();
};
} // namespace cache
} // namespace dom
} // namespace mozilla
--- a/dom/cache/PCacheStreamControl.ipdl
+++ b/dom/cache/PCacheStreamControl.ipdl
@@ -10,19 +10,19 @@ namespace mozilla {
namespace dom {
namespace cache {
protocol PCacheStreamControl
{
manager PBackground;
parent:
- NoteClosed(nsID aStreamId);
+ async NoteClosed(nsID aStreamId);
child:
- Close(nsID aStreamId);
- CloseAll();
- __delete__();
+ async Close(nsID aStreamId);
+ async CloseAll();
+ async __delete__();
};
} // namespace cache
} // namespace dom
} // namespace mozilla
--- a/dom/cellbroadcast/ipc/PCellBroadcast.ipdl
+++ b/dom/cellbroadcast/ipc/PCellBroadcast.ipdl
@@ -9,33 +9,33 @@ include protocol PContent;
namespace mozilla {
namespace dom {
namespace cellbroadcast {
sync protocol PCellBroadcast {
manager PContent;
child:
- NotifyReceivedMessage(uint32_t aServiceId,
- uint32_t aGsmGeographicalScope,
- uint16_t aMessageCode,
- uint16_t aMessageId,
- nsString aLanguage,
- nsString aBody,
- uint32_t aMessageClass,
- uint64_t aTimestamp,
- uint32_t aCdmaServiceCategory,
- bool aHasEtwsInfo,
- uint32_t aEtwsWarningType,
- bool aEtwsEmergencyUserAlert,
- bool aEtwsPopup);
+ async NotifyReceivedMessage(uint32_t aServiceId,
+ uint32_t aGsmGeographicalScope,
+ uint16_t aMessageCode,
+ uint16_t aMessageId,
+ nsString aLanguage,
+ nsString aBody,
+ uint32_t aMessageClass,
+ uint64_t aTimestamp,
+ uint32_t aCdmaServiceCategory,
+ bool aHasEtwsInfo,
+ uint32_t aEtwsWarningType,
+ bool aEtwsEmergencyUserAlert,
+ bool aEtwsPopup);
parent:
/**
* Sent when the child no longer needs to use cellbroadcast.
*/
- __delete__();
+ async __delete__();
};
} // namespace mobilemessage
} // namespace dom
-} // namespace cellbroadcast
\ No newline at end of file
+} // namespace cellbroadcast
--- a/dom/devicestorage/PDeviceStorageRequest.ipdl
+++ b/dom/devicestorage/PDeviceStorageRequest.ipdl
@@ -80,14 +80,14 @@ union DeviceStorageResponseValue
FormatStorageResponse;
MountStorageResponse;
UnmountStorageResponse;
};
sync protocol PDeviceStorageRequest {
manager PContent;
child:
- __delete__(DeviceStorageResponseValue response);
+ async __delete__(DeviceStorageResponseValue response);
};
} // namespace devicestorage
} // namespace dom
} // namespace mozilla
--- a/dom/filehandle/PBackgroundFileHandle.ipdl
+++ b/dom/filehandle/PBackgroundFileHandle.ipdl
@@ -69,23 +69,23 @@ union FileRequestParams
protocol PBackgroundFileHandle
{
manager PBackgroundMutableFile;
manages PBackgroundFileRequest;
parent:
- DeleteMe();
+ async DeleteMe();
- Finish();
- Abort();
+ async Finish();
+ async Abort();
- PBackgroundFileRequest(FileRequestParams params);
+ async PBackgroundFileRequest(FileRequestParams params);
child:
- __delete__();
+ async __delete__();
- Complete(bool aborted);
+ async Complete(bool aborted);
};
} // namespace dom
} // namespace mozilla
--- a/dom/filehandle/PBackgroundFileRequest.ipdl
+++ b/dom/filehandle/PBackgroundFileRequest.ipdl
@@ -68,16 +68,16 @@ union FileRequestResponse
FileRequestGetFileResponse;
};
protocol PBackgroundFileRequest
{
manager PBackgroundFileHandle;
child:
- __delete__(FileRequestResponse response);
+ async __delete__(FileRequestResponse response);
- Progress(uint64_t progress,
- uint64_t progressMax);
+ async Progress(uint64_t progress,
+ uint64_t progressMax);
};
} // namespace dom
} // namespace mozilla
--- a/dom/filehandle/PBackgroundMutableFile.ipdl
+++ b/dom/filehandle/PBackgroundMutableFile.ipdl
@@ -15,22 +15,22 @@ namespace dom {
sync protocol PBackgroundMutableFile
{
manager PBackgroundIDBDatabase;
manages PBackgroundFileHandle;
parent:
- DeleteMe();
+ async DeleteMe();
- PBackgroundFileHandle(FileMode mode);
+ async PBackgroundFileHandle(FileMode mode);
// Use only for testing!
sync GetFileId()
returns (int64_t fileId);
child:
- __delete__();
+ async __delete__();
};
} // namespace dom
} // namespace mozilla
--- a/dom/filesystem/PFileSystemRequest.ipdl
+++ b/dom/filesystem/PFileSystemRequest.ipdl
@@ -44,13 +44,13 @@ union FileSystemResponseValue
FileSystemErrorResponse;
};
sync protocol PFileSystemRequest
{
manager PContent;
child:
- __delete__(FileSystemResponseValue response);
+ async __delete__(FileSystemResponseValue response);
};
} // namespace dom
} // namespace mozilla
--- a/dom/fmradio/ipc/PFMRadio.ipdl
+++ b/dom/fmradio/ipc/PFMRadio.ipdl
@@ -66,47 +66,47 @@ sync protocol PFMRadio
{
manager PContent;
manages PFMRadioRequest;
child:
/**
* Sent when the frequency is changed.
*/
- NotifyFrequencyChanged(double frequency);
+ async NotifyFrequencyChanged(double frequency);
/**
* Sent when the power state of FM radio HW is changed.
*/
- NotifyEnabledChanged(bool enabled, double frequency);
+ async NotifyEnabledChanged(bool enabled, double frequency);
/**
* Sent when RDS is enabled or disabled.
*/
- NotifyRDSEnabledChanged(bool enabled);
+ async NotifyRDSEnabledChanged(bool enabled);
/**
* Sent when we have a new PI code.
*/
- NotifyPIChanged(bool valid, uint16_t code);
+ async NotifyPIChanged(bool valid, uint16_t code);
/**
* Sent when we have a new PTY
*/
- NotifyPTYChanged(bool valid, uint8_t pty);
+ async NotifyPTYChanged(bool valid, uint8_t pty);
/**
* Sent when we have a new PS name.
*/
- NotifyPSChanged(nsString psname);
+ async NotifyPSChanged(nsString psname);
/**
* Sent when we have new radiotext.
*/
- NotifyRadiotextChanged(nsString radiotext);
+ async NotifyRadiotextChanged(nsString radiotext);
/**
* Sent when a full RDS group is received.
*/
- NotifyNewRDSGroup(uint64_t data);
+ async NotifyNewRDSGroup(uint64_t data);
- __delete__();
+ async __delete__();
parent:
/**
* Get the current status infomation of FM radio HW synchronously.
* Sent when the singleton object of FMRadioChild is initialized.
*/
sync GetStatusInfo() returns (StatusInfo info);
@@ -114,24 +114,24 @@ parent:
* Send request to parent process to operate the FM radio HW.
*
* We don't have separate Enable/SetFrequency/etc. methods instead here,
* because we can leverage the IPC messaging mechanism to manage the mapping
* of the asynchronous request and the DOMRequest we returned to the caller
* on web content, otherwise, we have to do the mapping stuff manually which
* is more error prone.
*/
- PFMRadioRequest(FMRadioRequestArgs requestType);
+ async PFMRadioRequest(FMRadioRequestArgs requestType);
/**
* Enable/Disable audio
*/
- EnableAudio(bool audioEnabled);
+ async EnableAudio(bool audioEnabled);
/**
* Set RDS group mask
*/
- SetRDSGroupMask(uint32_t groupMask);
+ async SetRDSGroupMask(uint32_t groupMask);
};
} // namespace dom
} // namespace mozilla
--- a/dom/fmradio/ipc/PFMRadioRequest.ipdl
+++ b/dom/fmradio/ipc/PFMRadioRequest.ipdl
@@ -30,14 +30,14 @@ union FMRadioResponseType
* When the request completed, the result, i.e. FMRadioResponseType, will be
* sent back to child from parent in the `__delete__` message.
*/
async protocol PFMRadioRequest
{
manager PFMRadio;
child:
- __delete__(FMRadioResponseType response);
+ async __delete__(FMRadioResponseType response);
};
} // namespace dom
} // namespace mozilla
--- a/dom/icc/ipc/PIcc.ipdl
+++ b/dom/icc/ipc/PIcc.ipdl
@@ -89,74 +89,74 @@ sync protocol PIcc
{
manager PContent;
manages PIccRequest;
child:
/**
* Notify CardStateChanged with updated CardState.
*/
- NotifyCardStateChanged(uint32_t aCardState);
+ async NotifyCardStateChanged(uint32_t aCardState);
/**
* Notify IccInfoChanged with updated IccInfo.
*/
- NotifyIccInfoChanged(OptionalIccInfoData aInfoData);
+ async NotifyIccInfoChanged(OptionalIccInfoData aInfoData);
/**
* Notify STK proactive command issue by selected UICC.
*
* @param aStkProactiveCmd
* a MozStkCommand instance serialized in JSON.
*/
- NotifyStkCommand(nsString aStkProactiveCmd);
+ async NotifyStkCommand(nsString aStkProactiveCmd);
/**
* Notify that STK session is ended by selected UICC.
*/
- NotifyStkSessionEnd();
+ async NotifyStkSessionEnd();
parent:
/**
* Sent when the child no longer needs to use PIcc.
*/
- __delete__();
+ async __delete__();
/**
* Sent when the child makes an asynchronous request to the parent.
*/
- PIccRequest(IccRequest aRequest);
+ async PIccRequest(IccRequest aRequest);
/**
* Send STK response to the selected UICC.
*
* @param aCommand
* a MozStkCommand instance serialized in JSON.
* @param aResponse
* a MozStkResponse instance serialized in JSON.
*/
- StkResponse(nsString aCommand, nsString aResponse);
+ async StkResponse(nsString aCommand, nsString aResponse);
/**
* Send STK Menu Selection to the selected UICC.
*/
- StkMenuSelection(uint16_t aItemIdentifier, bool aHelpRequested);
+ async StkMenuSelection(uint16_t aItemIdentifier, bool aHelpRequested);
/**
* Send STK Timer Expiration to the selected UICC.
*/
- StkTimerExpiration(uint16_t aTimerId, uint32_t aTimerValue);
+ async StkTimerExpiration(uint16_t aTimerId, uint32_t aTimerValue);
/**
* Send STK Event Download to the selected UICC.
*
* @param aEvent
* a MozStkXxxEvent instance serialized in JSON.
*/
- StkEventDownload(nsString aEvent);
+ async StkEventDownload(nsString aEvent);
/**
* Sync call to initialize the updated IccInfo/CardState.
*/
sync Init()
returns (OptionalIccInfoData aInfoData, uint32_t aCardState);
};
--- a/dom/icc/ipc/PIccRequest.ipdl
+++ b/dom/icc/ipc/PIccRequest.ipdl
@@ -60,14 +60,14 @@ union IccReply
protocol PIccRequest
{
manager PIcc;
child:
/**
* Sent when the asynchronous request has completed.
*/
- __delete__(IccReply response);
+ async __delete__(IccReply response);
};
} // namespace icc
} // namespace dom
} // namespace mozilla
\ No newline at end of file
--- a/dom/indexedDB/PBackgroundIDBCursor.ipdl
+++ b/dom/indexedDB/PBackgroundIDBCursor.ipdl
@@ -73,21 +73,21 @@ union CursorResponse
IndexKeyCursorResponse;
};
protocol PBackgroundIDBCursor
{
manager PBackgroundIDBTransaction or PBackgroundIDBVersionChangeTransaction;
parent:
- DeleteMe();
+ async DeleteMe();
- Continue(CursorRequestParams params, Key key);
+ async Continue(CursorRequestParams params, Key key);
child:
- __delete__();
+ async __delete__();
- Response(CursorResponse response);
+ async Response(CursorResponse response);
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PBackgroundIDBDatabase.ipdl
+++ b/dom/indexedDB/PBackgroundIDBDatabase.ipdl
@@ -48,38 +48,38 @@ sync protocol PBackgroundIDBDatabase
manages PBackgroundIDBDatabaseFile;
manages PBackgroundIDBDatabaseRequest;
manages PBackgroundIDBTransaction;
manages PBackgroundIDBVersionChangeTransaction;
manages PBackgroundMutableFile;
parent:
- DeleteMe();
+ async DeleteMe();
- Blocked();
+ async Blocked();
- Close();
+ async Close();
- PBackgroundIDBDatabaseFile(PBlob blob);
+ async PBackgroundIDBDatabaseFile(PBlob blob);
- PBackgroundIDBDatabaseRequest(DatabaseRequestParams params);
+ async PBackgroundIDBDatabaseRequest(DatabaseRequestParams params);
- PBackgroundIDBTransaction(nsString[] objectStoreNames, Mode mode);
+ async PBackgroundIDBTransaction(nsString[] objectStoreNames, Mode mode);
child:
- __delete__();
+ async __delete__();
- VersionChange(uint64_t oldVersion, NullableVersion newVersion);
+ async VersionChange(uint64_t oldVersion, NullableVersion newVersion);
- Invalidate();
+ async Invalidate();
- PBackgroundIDBVersionChangeTransaction(uint64_t currentVersion,
- uint64_t requestedVersion,
- int64_t nextObjectStoreId,
- int64_t nextIndexId);
+ async PBackgroundIDBVersionChangeTransaction(uint64_t currentVersion,
+ uint64_t requestedVersion,
+ int64_t nextObjectStoreId,
+ int64_t nextIndexId);
- PBackgroundMutableFile(nsString name, nsString type);
+ async PBackgroundMutableFile(nsString name, nsString type);
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PBackgroundIDBDatabaseFile.ipdl
+++ b/dom/indexedDB/PBackgroundIDBDatabaseFile.ipdl
@@ -8,14 +8,14 @@ namespace mozilla {
namespace dom {
namespace indexedDB {
protocol PBackgroundIDBDatabaseFile
{
manager PBackgroundIDBDatabase;
parent:
- __delete__();
+ async __delete__();
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PBackgroundIDBDatabaseRequest.ipdl
+++ b/dom/indexedDB/PBackgroundIDBDatabaseRequest.ipdl
@@ -20,14 +20,14 @@ union DatabaseRequestResponse
CreateFileRequestResponse;
};
protocol PBackgroundIDBDatabaseRequest
{
manager PBackgroundIDBDatabase;
child:
- __delete__(DatabaseRequestResponse response);
+ async __delete__(DatabaseRequestResponse response);
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PBackgroundIDBFactory.ipdl
+++ b/dom/indexedDB/PBackgroundIDBFactory.ipdl
@@ -44,24 +44,24 @@ union FactoryRequestParams
sync protocol PBackgroundIDBFactory
{
manager PBackground;
manages PBackgroundIDBDatabase;
manages PBackgroundIDBFactoryRequest;
parent:
- DeleteMe();
+ async DeleteMe();
- PBackgroundIDBFactoryRequest(FactoryRequestParams params);
+ async PBackgroundIDBFactoryRequest(FactoryRequestParams params);
- IncrementLoggingRequestSerialNumber();
+ async IncrementLoggingRequestSerialNumber();
child:
- __delete__();
+ async __delete__();
- PBackgroundIDBDatabase(DatabaseSpec spec,
- PBackgroundIDBFactoryRequest request);
+ async PBackgroundIDBDatabase(DatabaseSpec spec,
+ PBackgroundIDBFactoryRequest request);
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PBackgroundIDBFactoryRequest.ipdl
+++ b/dom/indexedDB/PBackgroundIDBFactoryRequest.ipdl
@@ -28,21 +28,21 @@ union FactoryRequestResponse
DeleteDatabaseRequestResponse;
};
protocol PBackgroundIDBFactoryRequest
{
manager PBackgroundIDBFactory;
child:
- __delete__(FactoryRequestResponse response);
+ async __delete__(FactoryRequestResponse response);
- PermissionChallenge(PrincipalInfo principalInfo);
+ async PermissionChallenge(PrincipalInfo principalInfo);
- Blocked(uint64_t currentVersion);
+ async Blocked(uint64_t currentVersion);
parent:
- PermissionRetry();
+ async PermissionRetry();
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PBackgroundIDBRequest.ipdl
+++ b/dom/indexedDB/PBackgroundIDBRequest.ipdl
@@ -100,14 +100,14 @@ union RequestResponse
IndexCountResponse;
};
protocol PBackgroundIDBRequest
{
manager PBackgroundIDBTransaction or PBackgroundIDBVersionChangeTransaction;
child:
- __delete__(RequestResponse response);
+ async __delete__(RequestResponse response);
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PBackgroundIDBTransaction.ipdl
+++ b/dom/indexedDB/PBackgroundIDBTransaction.ipdl
@@ -17,26 +17,26 @@ namespace indexedDB {
protocol PBackgroundIDBTransaction
{
manager PBackgroundIDBDatabase;
manages PBackgroundIDBCursor;
manages PBackgroundIDBRequest;
parent:
- DeleteMe();
+ async DeleteMe();
- Commit();
- Abort(nsresult resultCode);
+ async Commit();
+ async Abort(nsresult resultCode);
- PBackgroundIDBCursor(OpenCursorParams params);
+ async PBackgroundIDBCursor(OpenCursorParams params);
- PBackgroundIDBRequest(RequestParams params);
+ async PBackgroundIDBRequest(RequestParams params);
child:
- __delete__();
+ async __delete__();
- Complete(nsresult result);
+ async Complete(nsresult result);
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PBackgroundIDBVersionChangeTransaction.ipdl
+++ b/dom/indexedDB/PBackgroundIDBVersionChangeTransaction.ipdl
@@ -18,34 +18,34 @@ namespace indexedDB {
protocol PBackgroundIDBVersionChangeTransaction
{
manager PBackgroundIDBDatabase;
manages PBackgroundIDBCursor;
manages PBackgroundIDBRequest;
parent:
- DeleteMe();
+ async DeleteMe();
- Commit();
- Abort(nsresult resultCode);
+ async Commit();
+ async Abort(nsresult resultCode);
- CreateObjectStore(ObjectStoreMetadata metadata);
- DeleteObjectStore(int64_t objectStoreId);
+ async CreateObjectStore(ObjectStoreMetadata metadata);
+ async DeleteObjectStore(int64_t objectStoreId);
- CreateIndex(int64_t objectStoreId,
- IndexMetadata metadata);
- DeleteIndex(int64_t objectStoreId,
- int64_t indexId);
+ async CreateIndex(int64_t objectStoreId,
+ IndexMetadata metadata);
+ async DeleteIndex(int64_t objectStoreId,
+ int64_t indexId);
- PBackgroundIDBCursor(OpenCursorParams params);
+ async PBackgroundIDBCursor(OpenCursorParams params);
- PBackgroundIDBRequest(RequestParams params);
+ async PBackgroundIDBRequest(RequestParams params);
child:
- __delete__();
+ async __delete__();
- Complete(nsresult result);
+ async Complete(nsresult result);
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PBackgroundIndexedDBUtils.ipdl
+++ b/dom/indexedDB/PBackgroundIndexedDBUtils.ipdl
@@ -13,25 +13,25 @@ namespace mozilla {
namespace dom {
namespace indexedDB {
sync protocol PBackgroundIndexedDBUtils
{
manager PBackground;
parent:
- DeleteMe();
+ async DeleteMe();
// 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);
child:
- __delete__();
+ async __delete__();
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/indexedDB/PIndexedDBPermissionRequest.ipdl
+++ b/dom/indexedDB/PIndexedDBPermissionRequest.ipdl
@@ -14,14 +14,14 @@ protocol PIndexedDBPermissionRequest
child:
/**
* Called when the user makes a choice or the permission request times out.
*
* @param permission
* The permission result (see nsIPermissionManager.idl for valid values).
*/
- __delete__(uint32_t permission);
+ async __delete__(uint32_t permission);
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/PBlob.ipdl
+++ b/dom/ipc/PBlob.ipdl
@@ -21,22 +21,22 @@ union ResolveMysteryParams
};
sync protocol PBlob
{
manager PBackground or PContent or PContentBridge;
manages PBlobStream;
both:
- __delete__();
+ async __delete__();
parent:
- PBlobStream(uint64_t begin, uint64_t length);
+ async PBlobStream(uint64_t begin, uint64_t length);
- ResolveMystery(ResolveMysteryParams params);
+ async ResolveMystery(ResolveMysteryParams params);
sync BlobStreamSync(uint64_t begin, uint64_t length)
returns (InputStreamParams params, OptionalFileDescriptorSet fds);
sync WaitForSliceCreation();
// Use only for testing!
sync GetFileId()
@@ -44,13 +44,13 @@ parent:
// Use only for testing!
sync GetFilePath()
returns (nsString filePath);
child:
// This method must be called by the parent when the PBlobParent is fully
// created in order to release the known blob.
- CreatedFromKnownBlob();
+ async CreatedFromKnownBlob();
};
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/PBlobStream.ipdl
+++ b/dom/ipc/PBlobStream.ipdl
@@ -9,13 +9,13 @@ include InputStreamParams;
namespace mozilla {
namespace dom {
protocol PBlobStream
{
manager PBlob;
child:
- __delete__(InputStreamParams params, OptionalFileDescriptorSet fds);
+ async __delete__(InputStreamParams params, OptionalFileDescriptorSet fds);
};
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/PBrowser.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -105,33 +105,33 @@ prio(normal upto urgent) sync protocol P
manages PDocAccessible;
manages PDocumentRenderer;
manages PFilePicker;
manages PIndexedDBPermissionRequest;
manages PRenderFrame;
manages PPluginWidget;
both:
- AsyncMessage(nsString aMessage, ClonedMessageData aData, CpowEntry[] aCpows,
- Principal aPrincipal);
+ async AsyncMessage(nsString aMessage, ClonedMessageData aData, CpowEntry[] aCpows,
+ Principal aPrincipal);
/**
* Create a layout frame (encapsulating a remote layer tree) for
* the page that is currently loaded in the <browser>.
*/
- PRenderFrame();
+ async PRenderFrame();
parent:
/**
* Tell the parent process a new accessible document has been created.
* aParentDoc is the accessible document it was created in if any, and
* aParentAcc is the id of the accessible in that document the new document
* is a child of.
*/
- PDocAccessible(nullable PDocAccessible aParentDoc, uint64_t aParentAcc);
+ async PDocAccessible(nullable PDocAccessible aParentDoc, uint64_t aParentAcc);
/*
* Creates a new remoted nsIWidget connection for windowed plugins
* in e10s mode. This is always initiated from the child in response
* to windowed plugin creation.
*/
sync PPluginWidget();
@@ -153,19 +153,19 @@ parent:
*/
sync DispatchFocusToTopLevelWindow();
parent:
/**
* When child sends this message, parent should move focus to
* the next or previous focusable element or document.
*/
- MoveFocus(bool forward, bool forDocumentNavigation);
+ async MoveFocus(bool forward, bool forDocumentNavigation);
- Event(RemoteDOMEvent aEvent);
+ async Event(RemoteDOMEvent aEvent);
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);
@@ -290,25 +290,25 @@ parent:
* When plugin event isn't consumed, call this
*/
async DefaultProcOfPluginEvent(WidgetPluginEvent aEvent);
/**
* Request that the parent process move focus to the browser's frame. If
* canRaise is true, the window can be raised if it is inactive.
*/
- RequestFocus(bool canRaise);
+ async RequestFocus(bool canRaise);
/**
* Indicate, based on the current state, that some commands are enabled and
* some are disabled.
*/
- EnableDisableCommands(nsString action,
- nsCString[] enabledCommands,
- nsCString[] disabledCommands);
+ async EnableDisableCommands(nsString action,
+ nsCString[] enabledCommands,
+ nsCString[] disabledCommands);
prio(urgent) sync GetInputContext() returns (int32_t IMEEnabled,
int32_t IMEOpen);
prio(urgent) async SetInputContext(int32_t IMEEnabled,
int32_t IMEOpen,
nsString type,
nsString inputmode,
@@ -336,17 +336,17 @@ parent:
/**
* Set the native cursor.
* @param value
* The widget cursor to set.
* @param force
* Invalidate any locally cached cursor settings and force an
* update.
*/
- SetCursor(uint32_t value, bool force);
+ async SetCursor(uint32_t value, bool force);
/**
* Set the native cursor using a custom image.
* @param cursorData
* Serialized image data.
* @param width
* Width of the image.
* @param height
@@ -358,53 +358,53 @@ parent:
* @param hotspotX
* Horizontal hotspot of the image, as specified by the css cursor property.
* @param hotspotY
* Vertical hotspot of the image, as specified by the css cursor property.
* @param force
* Invalidate any locally cached cursor settings and force an
* update.
*/
- SetCustomCursor(nsCString cursorData, uint32_t width, uint32_t height,
- uint32_t stride, uint8_t format,
- uint32_t hotspotX, uint32_t hotspotY, bool force);
+ async SetCustomCursor(nsCString cursorData, uint32_t width, uint32_t height,
+ uint32_t stride, uint8_t format,
+ uint32_t hotspotX, uint32_t hotspotY, bool force);
/**
* Used to set the current text of the status tooltip.
* Nowadays this is mainly used for link locations on hover.
*/
- SetStatus(uint32_t type, nsString status);
+ async SetStatus(uint32_t type, nsString status);
/**
* Show/hide a tooltip when the mouse hovers over an element in the content
* document.
*/
- ShowTooltip(uint32_t x, uint32_t y, nsString tooltip);
- HideTooltip();
+ async ShowTooltip(uint32_t x, uint32_t y, nsString tooltip);
+ async HideTooltip();
/**
* Create an asynchronous color picker on the parent side,
* but don't open it yet.
*/
- PColorPicker(nsString title, nsString initialColor);
+ async PColorPicker(nsString title, nsString initialColor);
- PFilePicker(nsString aTitle, int16_t aMode);
+ async PFilePicker(nsString aTitle, int16_t aMode);
/**
* Initiates an asynchronous request for one of the special indexedDB
* permissions for the provided principal.
*
* @param principal
* The principal of the request.
*
* NOTE: The principal is untrusted in the parent process. Only
* principals that can live in the content process should
* provided.
*/
- PIndexedDBPermissionRequest(Principal principal);
+ async PIndexedDBPermissionRequest(Principal principal);
/**
* window.open from inside <iframe mozbrowser> is special. When the child
* process calls window.open, it creates a new PBrowser (in its own
* process), then calls BrowserFrameOpenWindow on it.
*
* The parent process gets a chance to accept or reject the window.open
* call, and windowOpened is set to true if we ended up going through with
@@ -415,106 +415,106 @@ parent:
sync BrowserFrameOpenWindow(PBrowser opener, nsString aURL,
nsString aName, nsString aFeatures)
returns (bool windowOpened);
/**
* Instructs the TabParent to forward a request to zoom to a rect given in
* CSS pixels. This rect is relative to the document.
*/
- ZoomToRect(uint32_t aPresShellId, ViewID aViewId, CSSRect aRect, uint32_t aFlags);
+ async ZoomToRect(uint32_t aPresShellId, ViewID aViewId, CSSRect aRect, uint32_t aFlags);
/**
* We know for sure that content has either preventDefaulted or not
* preventDefaulted. This applies to an entire batch of touch events. It is
* expected that, if there are any DOM touch listeners, touch events will be
* batched and only processed for panning and zooming if content does not
* preventDefault.
*/
- ContentReceivedInputBlock(ScrollableLayerGuid aGuid, uint64_t aInputBlockId, bool aPreventDefault);
+ async ContentReceivedInputBlock(ScrollableLayerGuid aGuid, uint64_t aInputBlockId, bool aPreventDefault);
/**
* Notifies the APZ code of the results of the gecko hit-test for a
* particular input block. Each target corresponds to one touch point in the
* touch event.
*/
- SetTargetAPZC(uint64_t aInputBlockId, ScrollableLayerGuid[] aTargets);
+ async SetTargetAPZC(uint64_t aInputBlockId, ScrollableLayerGuid[] aTargets);
/**
* Notifies the APZ code of the allowed touch-behaviours for a particular
* input block. Each item in the aFlags array corresponds to one touch point
* in the touch event.
*/
- SetAllowedTouchBehavior(uint64_t aInputBlockId, TouchBehaviorFlags[] aFlags);
+ async SetAllowedTouchBehavior(uint64_t aInputBlockId, TouchBehaviorFlags[] aFlags);
/**
* Updates the zoom constraints for a scrollable frame in this tab.
* The zoom controller code lives on the parent side and so this allows it to
* have up-to-date zoom constraints.
*/
- UpdateZoomConstraints(uint32_t aPresShellId, ViewID aViewId,
- MaybeZoomConstraints aConstraints);
+ async UpdateZoomConstraints(uint32_t aPresShellId, ViewID aViewId,
+ MaybeZoomConstraints aConstraints);
/**
* Tells the containing widget whether the given input block results in a
* swipe. Should be called in response to a WidgetWheelEvent that has
* mFlags.mCanTriggerSwipe set on it.
*/
- RespondStartSwipeEvent(uint64_t aInputBlockId, bool aStartSwipe);
+ async RespondStartSwipeEvent(uint64_t aInputBlockId, bool aStartSwipe);
/**
* Brings up the auth prompt dialog.
* Called when this is the PBrowserParent for a nested remote iframe.
* aCallbackId corresponds to an nsIAuthPromptCallback that lives in the
* root process. It will be passed back to the root process with either the
* OnAuthAvailable or OnAuthCancelled message.
*/
- AsyncAuthPrompt(nsCString uri, nsString realm, uint64_t aCallbackId);
+ async AsyncAuthPrompt(nsCString uri, nsString realm, uint64_t aCallbackId);
- __delete__();
+ async __delete__();
- ReplyKeyEvent(WidgetKeyboardEvent event);
+ async ReplyKeyEvent(WidgetKeyboardEvent event);
- DispatchAfterKeyboardEvent(WidgetKeyboardEvent event);
+ async DispatchAfterKeyboardEvent(WidgetKeyboardEvent event);
sync RequestNativeKeyBindings(WidgetKeyboardEvent event)
returns (MaybeNativeKeyBinding bindings);
- SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
- int32_t aNativeKeyCode,
- uint32_t aModifierFlags,
- nsString aCharacters,
- nsString aUnmodifiedCharacters,
- uint64_t aObserverId);
- SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
- uint32_t aNativeMessage,
- uint32_t aModifierFlags,
- uint64_t aObserverId);
- SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
- uint64_t aObserverId);
- SynthesizeNativeMouseScrollEvent(LayoutDeviceIntPoint aPoint,
+ async SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
+ int32_t aNativeKeyCode,
+ uint32_t aModifierFlags,
+ nsString aCharacters,
+ nsString aUnmodifiedCharacters,
+ uint64_t aObserverId);
+ async SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
uint32_t aNativeMessage,
- double aDeltaX,
- double aDeltaY,
- double aDeltaZ,
uint32_t aModifierFlags,
- uint32_t aAdditionalFlags,
uint64_t aObserverId);
- SynthesizeNativeTouchPoint(uint32_t aPointerId,
- TouchPointerState aPointerState,
- ScreenIntPoint aPointerScreenPoint,
- double aPointerPressure,
- uint32_t aPointerOrientation,
- uint64_t aObserverId);
- SynthesizeNativeTouchTap(ScreenIntPoint aPointerScreenPoint,
- bool aLongTap,
- uint64_t aObserverId);
- ClearNativeTouchSequence(uint64_t aObserverId);
+ async SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
+ uint64_t aObserverId);
+ async SynthesizeNativeMouseScrollEvent(LayoutDeviceIntPoint aPoint,
+ uint32_t aNativeMessage,
+ double aDeltaX,
+ double aDeltaY,
+ double aDeltaZ,
+ uint32_t aModifierFlags,
+ uint32_t aAdditionalFlags,
+ uint64_t aObserverId);
+ async SynthesizeNativeTouchPoint(uint32_t aPointerId,
+ TouchPointerState aPointerState,
+ ScreenIntPoint aPointerScreenPoint,
+ double aPointerPressure,
+ uint32_t aPointerOrientation,
+ uint64_t aObserverId);
+ async SynthesizeNativeTouchTap(ScreenIntPoint aPointerScreenPoint,
+ bool aLongTap,
+ uint64_t aObserverId);
+ async ClearNativeTouchSequence(uint64_t aObserverId);
child:
- NativeSynthesisResponse(uint64_t aObserverId, nsCString aResponse);
+ async NativeSynthesisResponse(uint64_t aObserverId, nsCString aResponse);
parent:
/**
* Child informs the parent that the graphics objects are ready for
* compositing. This is sent when all pending changes have been
* sent to the compositor and are ready to be shown on the next composite.
@@ -535,201 +535,202 @@ parent:
prio(high) sync DispatchWheelEvent(WidgetWheelEvent event);
prio(high) sync DispatchMouseEvent(WidgetMouseEvent event);
prio(high) sync DispatchKeyboardEvent(WidgetKeyboardEvent event);
// Start an APZ drag on a scrollbar
async StartScrollbarDrag(AsyncDragMetrics aDragMetrics);
- InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action,
- nsCString visualData, uint32_t width, uint32_t height,
- uint32_t stride, uint8_t format, int32_t dragAreaX, int32_t dragAreaY);
+ async InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action,
+ nsCString visualData, uint32_t width, uint32_t height,
+ uint32_t stride, uint8_t format,
+ int32_t dragAreaX, int32_t dragAreaY);
async AudioChannelActivityNotification(uint32_t aAudioChannel,
bool aActive);
child:
/**
* Notify the remote browser that it has been Show()n on this
* side, with the given |visibleRect|. This message is expected
* to trigger creation of the remote browser's "widget".
*
* |Show()| and |Move()| take IntSizes rather than Rects because
* content processes always render to a virtual <0, 0> top-left
* point.
*/
- Show(ScreenIntSize size,
- ShowInfo info,
- TextureFactoryIdentifier textureFactoryIdentifier,
- uint64_t layersId,
- nullable PRenderFrame renderFrame,
- bool parentIsActive);
+ async Show(ScreenIntSize size,
+ ShowInfo info,
+ TextureFactoryIdentifier textureFactoryIdentifier,
+ uint64_t layersId,
+ nullable PRenderFrame renderFrame,
+ bool parentIsActive);
- LoadURL(nsCString uri, BrowserConfiguration config, ShowInfo info);
+ async LoadURL(nsCString uri, BrowserConfiguration config, ShowInfo info);
- OpenURI(URIParams uri, uint32_t flags);
+ async OpenURI(URIParams uri, uint32_t flags);
- CacheFileDescriptor(nsString path, FileDescriptor fd);
+ async CacheFileDescriptor(nsString path, FileDescriptor fd);
- UpdateDimensions(CSSRect rect, CSSSize size, nsSizeMode sizeMode,
- ScreenOrientationInternal orientation,
- LayoutDeviceIntPoint chromeDisp) compressall;
+ async UpdateDimensions(CSSRect rect, CSSSize size, nsSizeMode sizeMode,
+ ScreenOrientationInternal orientation,
+ LayoutDeviceIntPoint chromeDisp) compressall;
- UpdateFrame(FrameMetrics frame);
+ async UpdateFrame(FrameMetrics frame);
// The following methods correspond to functions on the GeckoContentController
// interface in gfx/layers/apz/public/GeckoContentController.h. Refer to documentation
// in that file for these functions.
- RequestFlingSnap(ViewID aScrollID, CSSPoint aDestination);
- AcknowledgeScrollUpdate(ViewID aScrollId, uint32_t aScrollGeneration);
- HandleDoubleTap(CSSPoint aPoint, Modifiers aModifiers, ScrollableLayerGuid aGuid);
- HandleSingleTap(CSSPoint aPoint, Modifiers aModifiers, ScrollableLayerGuid aGuid);
- HandleLongTap(CSSPoint point, Modifiers aModifiers, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
- NotifyAPZStateChange(ViewID aViewId, APZStateChange aChange, int aArg);
- NotifyFlushComplete();
+ async RequestFlingSnap(ViewID aScrollID, CSSPoint aDestination);
+ async AcknowledgeScrollUpdate(ViewID aScrollId, uint32_t aScrollGeneration);
+ async HandleDoubleTap(CSSPoint aPoint, Modifiers aModifiers, ScrollableLayerGuid aGuid);
+ async HandleSingleTap(CSSPoint aPoint, Modifiers aModifiers, ScrollableLayerGuid aGuid);
+ async HandleLongTap(CSSPoint point, Modifiers aModifiers, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
+ async NotifyAPZStateChange(ViewID aViewId, APZStateChange aChange, int aArg);
+ async NotifyFlushComplete();
/**
* Sending an activate message moves focus to the child.
*/
- Activate();
+ async Activate();
- Deactivate();
+ async Deactivate();
- ParentActivated(bool aActivated);
+ async ParentActivated(bool aActivated);
/**
* StopIMEStateManagement() is called when the process loses focus and
* should stop managing IME state.
*/
- StopIMEStateManagement();
+ async StopIMEStateManagement();
/**
* MenuKeyboardListenerInstalled() is called when menu keyboard listener
* is installed in the parent process.
*/
- MenuKeyboardListenerInstalled(bool aInstalled);
+ async MenuKeyboardListenerInstalled(bool aInstalled);
/**
* @see nsIDOMWindowUtils sendMouseEvent.
*/
- MouseEvent(nsString aType,
- float aX,
- float aY,
- int32_t aButton,
- int32_t aClickCount,
- int32_t aModifiers,
- bool aIgnoreRootScrollFrame);
+ async MouseEvent(nsString aType,
+ float aX,
+ float aY,
+ int32_t aButton,
+ int32_t aClickCount,
+ int32_t aModifiers,
+ bool aIgnoreRootScrollFrame);
/**
* When two consecutive mouse move events would be added to the message queue,
* they are 'compressed' by dumping the oldest one.
*/
- RealMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId) compress;
+ async RealMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId) compress;
/**
* Mouse move events with |reason == eSynthesized| are sent via a separate
* message because they do not generate DOM 'mousemove' events, and the
* 'compress' attribute on RealMouseMoveEvent() could result in a
* |reason == eReal| event being dropped in favour of an |eSynthesized|
* event, and thus a DOM 'mousemove' event to be lost.
*/
- SynthMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
- RealMouseButtonEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
- RealKeyEvent(WidgetKeyboardEvent event, MaybeNativeKeyBinding keyBinding);
- MouseWheelEvent(WidgetWheelEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
- RealTouchEvent(WidgetTouchEvent aEvent,
- ScrollableLayerGuid aGuid,
- uint64_t aInputBlockId,
- nsEventStatus aApzResponse);
- RealTouchMoveEvent(WidgetTouchEvent aEvent,
- ScrollableLayerGuid aGuid,
- uint64_t aInputBlockId,
- nsEventStatus aApzResponse);
- RealDragEvent(WidgetDragEvent aEvent, uint32_t aDragAction, uint32_t aDropEffect);
- PluginEvent(WidgetPluginEvent aEvent);
+ async SynthMouseMoveEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
+ async RealMouseButtonEvent(WidgetMouseEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
+ async RealKeyEvent(WidgetKeyboardEvent event, MaybeNativeKeyBinding keyBinding);
+ async MouseWheelEvent(WidgetWheelEvent event, ScrollableLayerGuid aGuid, uint64_t aInputBlockId);
+ async RealTouchEvent(WidgetTouchEvent aEvent,
+ ScrollableLayerGuid aGuid,
+ uint64_t aInputBlockId,
+ nsEventStatus aApzResponse);
+ async RealTouchMoveEvent(WidgetTouchEvent aEvent,
+ ScrollableLayerGuid aGuid,
+ uint64_t aInputBlockId,
+ nsEventStatus aApzResponse);
+ async RealDragEvent(WidgetDragEvent aEvent, uint32_t aDragAction, uint32_t aDropEffect);
+ async PluginEvent(WidgetPluginEvent aEvent);
/**
* @see nsIDOMWindowUtils sendKeyEvent.
*/
- KeyEvent(nsString aType,
- int32_t aKeyCode,
- int32_t aCharCode,
- int32_t aModifiers,
- bool aPreventDefault);
+ async KeyEvent(nsString aType,
+ int32_t aKeyCode,
+ int32_t aCharCode,
+ int32_t aModifiers,
+ bool aPreventDefault);
/**
* APZ notification for mouse scroll testing events.
*/
- MouseScrollTestEvent(ViewID aScrollId, nsString aEvent);
+ async MouseScrollTestEvent(ViewID aScrollId, nsString aEvent);
- CompositionEvent(WidgetCompositionEvent event);
+ async CompositionEvent(WidgetCompositionEvent event);
- SelectionEvent(WidgetSelectionEvent event);
+ async SelectionEvent(WidgetSelectionEvent event);
/**
* Activate event forwarding from client to parent.
*/
- ActivateFrameEvent(nsString aType, bool capture);
+ async ActivateFrameEvent(nsString aType, bool capture);
- LoadRemoteScript(nsString aURL, bool aRunInGlobalScope);
+ async LoadRemoteScript(nsString aURL, bool aRunInGlobalScope);
/**
* Create a asynchronous request to render whatever document is
* loaded in the child when this message arrives. When the
* request finishes, PDocumentRenderer:__delete__ is sent back to
* this side to notify completion.
*
* |documentRect| is the area of the remote document to draw,
* transformed by |transform|. The rendered area will have the
* default background color |bgcolor|. |renderFlags| are the
* nsIPresShell::RenderDocument() flags to use on the remote side,
* and if true, |flushLayout| will do just that before rendering
* the document. The rendered image will be of size |renderSize|.
*/
- PDocumentRenderer(nsRect documentRect, Matrix transform,
- nsString bgcolor,
- uint32_t renderFlags, bool flushLayout,
- IntSize renderSize);
+ async PDocumentRenderer(nsRect documentRect, Matrix transform,
+ nsString bgcolor,
+ uint32_t renderFlags, bool flushLayout,
+ IntSize renderSize);
/**
* Sent by the chrome process when it no longer wants this remote
* <browser>. The child side cleans up in response, then
* finalizing its death by sending back __delete__() to the
* parent.
*/
- Destroy();
+ async Destroy();
/**
* Tell the child side if it has to update it's touchable region
* to the parent.
*/
- SetUpdateHitRegion(bool aEnabled);
+ async SetUpdateHitRegion(bool aEnabled);
/**
* Update the child side docShell active (resource use) state.
*/
- SetDocShellIsActive(bool aIsActive, bool aIsHidden);
+ async SetDocShellIsActive(bool aIsActive, bool aIsHidden);
/**
* Notify the child that it shouldn't paint the offscreen displayport.
* This is useful to speed up interactive operations over async
* scrolling performance like resize, tabswitch, pageload.
*
* Each enable call must be matched with a disable call. The child
* will remain in the suppress mode as long as there's
* a single unmatched call.
*/
async SuppressDisplayport(bool aEnabled);
/**
* Navigate by key (Tab/Shift+Tab/F6/Shift+f6).
*/
- NavigateByKey(bool aForward, bool aForDocumentNavigation);
+ async NavigateByKey(bool aForward, bool aForDocumentNavigation);
/**
* The parent (chrome thread) requests that the child inform it when
* the graphics objects are ready to display.
* @see PCompositor
* @see RemotePaintIsReady
*/
async RequestNotifyAfterRemotePaint();
@@ -738,51 +739,51 @@ child:
* Tell the child that the UI resolution changed for the containing
* window.
* To avoid some sync messages from child to parent, we also send the dpi
* and default scale with the notification.
* If we don't know the dpi and default scale, we just pass in a negative
* value (-1) but in the majority of the cases this saves us from two
* sync requests from the child to the parent.
*/
- UIResolutionChanged(float dpi, double scale);
+ async UIResolutionChanged(float dpi, double scale);
/**
* Tell the child that the system theme has changed, and that a repaint
* is necessary.
*/
- ThemeChanged(LookAndFeelInt[] lookAndFeelIntCache);
+ async ThemeChanged(LookAndFeelInt[] lookAndFeelIntCache);
/**
* Tell the child of an app's offline status
*/
- AppOfflineStatus(uint32_t id, bool offline);
+ async AppOfflineStatus(uint32_t id, bool offline);
/**
* Tell the browser that its frame loader has been swapped
* with another.
*/
- SwappedWithOtherRemoteLoader();
+ async SwappedWithOtherRemoteLoader();
/**
* A potential accesskey was just pressed. Look for accesskey targets
* using the list of provided charCodes.
*
* @param charCode array of potential character codes
* @param isTrusted true if triggered by a trusted key event
* @param modifierMask indicates which accesskey modifiers are pressed
*/
- HandleAccessKey(uint32_t[] charCodes, bool isTrusted, int32_t modifierMask);
+ async HandleAccessKey(uint32_t[] charCodes, bool isTrusted, int32_t modifierMask);
/**
* Propagate a refresh to the child process
*/
- AudioChannelChangeNotification(uint32_t aAudioChannel,
- float aVolume,
- bool aMuted);
+ async AudioChannelChangeNotification(uint32_t aAudioChannel,
+ float aVolume,
+ bool aMuted);
/*
* FIXME: write protocol!
state LIVE:
send LoadURL goto LIVE;
//etc.
send Destroy goto DYING;
--- a/dom/ipc/PColorPicker.ipdl
+++ b/dom/ipc/PColorPicker.ipdl
@@ -10,18 +10,18 @@ include protocol PBrowser;
namespace mozilla {
namespace dom {
protocol PColorPicker
{
manager PBrowser;
parent:
- Open();
+ async Open();
child:
- Update(nsString color);
+ async Update(nsString color);
- __delete__(nsString color);
+ async __delete__(nsString color);
};
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/PContent.ipdl
+++ b/dom/ipc/PContent.ipdl
@@ -527,35 +527,35 @@ both:
// 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);
- PFileDescriptorSet(FileDescriptor fd);
+ 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.
- PWebBrowserPersistDocument(nullable PBrowser aBrowser,
- uint64_t aOuterWindowID);
+ async PWebBrowserPersistDocument(nullable PBrowser aBrowser,
+ uint64_t aOuterWindowID);
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);
- PMemoryReportRequest(uint32_t generation, bool anonymize,
- bool minimizeMemoryUsage, MaybeFileDesc DMDFile);
+ 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);
@@ -564,104 +564,104 @@ child:
nsString aManifestURL);
/**
* Dump this process's GC and CC logs to the provided files.
*
* For documentation on the other args, see dumpGCAndCCLogsToFile in
* nsIMemoryInfoDumper.idl
*/
- PCycleCollectWithLogs(bool dumpAllTraces,
- FileDescriptor gcLog,
- FileDescriptor ccLog);
+ async PCycleCollectWithLogs(bool dumpAllTraces,
+ FileDescriptor gcLog,
+ FileDescriptor ccLog);
- PTestShell();
+ async PTestShell();
- RegisterChrome(ChromePackage[] packages, SubstitutionMapping[] substitutions,
- OverrideMapping[] overrides, nsCString locale, bool reset);
- RegisterChromeItem(ChromeRegistryItem item);
+ 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);
- PreferenceUpdate(PrefSetting pref);
+ async PreferenceUpdate(PrefSetting pref);
- DataStoragePut(nsString aFilename, DataStorageItem aItem);
- DataStorageRemove(nsString aFilename, nsCString aKey, DataStorageType aType);
- DataStorageClear(nsString aFilename);
+ async DataStoragePut(nsString aFilename, DataStorageItem aItem);
+ async DataStorageRemove(nsString aFilename, nsCString aKey, DataStorageType aType);
+ async DataStorageClear(nsString aFilename);
- NotifyAlertsObserver(nsCString topic, nsString data);
+ async NotifyAlertsObserver(nsCString topic, nsString data);
- GeolocationUpdate(GeoPosition somewhere);
+ async GeolocationUpdate(GeoPosition somewhere);
- GeolocationError(uint16_t errorCode);
+ async GeolocationError(uint16_t errorCode);
- UpdateDictionaryList(nsString[] dictionaries);
+ async UpdateDictionaryList(nsString[] dictionaries);
// nsIPermissionManager messages
- AddPermission(Permission permission);
+ async AddPermission(Permission permission);
- ScreenSizeChanged(IntSize size);
+ async ScreenSizeChanged(IntSize size);
- Volumes(VolumeInfo[] volumes);
+ async Volumes(VolumeInfo[] volumes);
- FlushMemory(nsString reason);
+ async FlushMemory(nsString reason);
- GarbageCollect();
- CycleCollect();
+ async GarbageCollect();
+ async CycleCollect();
/**
* Start accessibility engine in content process.
*/
- ActivateA11y();
+ async ActivateA11y();
- AppInfo(nsCString version, nsCString buildID, nsCString name, nsCString UAName,
- nsCString ID, nsCString vendor);
- AppInit();
+ 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
- LastPrivateDocShellDestroyed();
+ async LastPrivateDocShellDestroyed();
- FilePathUpdate(nsString storageType, nsString storageName, nsString filepath,
- nsCString reasons);
+ async FilePathUpdate(nsString storageType, nsString storageName, nsString filepath,
+ nsCString reasons);
// Note: Any changes to this structure should also be changed in
// VolumeInfo above.
- 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);
+ 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.
- VolumeRemoved(nsString fsName);
+ async VolumeRemoved(nsString fsName);
- NotifyProcessPriorityChanged(ProcessPriority priority);
- MinimizeMemoryUsage();
+ 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);
- NotifyPhoneStateChange(nsString newState);
+ async NotifyPhoneStateChange(nsString newState);
/**
* Notify idle observers in the child
*/
- NotifyIdleObserver(uint64_t observerId, nsCString topic, nsString str);
+ async NotifyIdleObserver(uint64_t observerId, nsCString topic, nsString str);
/**
* Notify windows in the child to apply a new app style.
*/
- OnAppThemeChanged();
+ async OnAppThemeChanged();
/**
* Called during plugin initialization to map a plugin id to a child process
* id.
*/
async AssociatePluginId(uint32_t aPluginId, ProcessId aProcessId);
/**
@@ -675,19 +675,19 @@ child:
* Control the Gecko Profiler in the child process.
*/
async StartProfiler(ProfilerInitParams params);
async StopProfiler();
async PauseProfiler(bool aPause);
async GatherProfile();
- InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action);
+ async InvokeDragSession(IPCDataTransfer[] transfers, uint32_t action);
- EndDragSession(bool aDoneDrag, bool aUserCancelled);
+ 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();
@@ -698,17 +698,17 @@ child:
* 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.
*/
- GamepadUpdate(GamepadChangeEvent aGamepadEvent);
+ async GamepadUpdate(GamepadChangeEvent aGamepadEvent);
/**
* Tell the child that for testing purposes, a graphics device reset has
* occurred.
*/
async TestGraphicsDeviceReset(uint32_t aReason);
/**
@@ -726,27 +726,27 @@ child:
/**
* 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.
*/
- Push(nsCString scope, Principal principal);
+ async Push(nsCString scope, Principal principal);
/**
* Send a `push` event with data to a service worker in the child.
*/
- PushWithData(nsCString scope, Principal principal, uint8_t[] data);
+ async PushWithData(nsCString scope, Principal principal, uint8_t[] data);
/**
* Send a `pushsubscriptionchange` event to a service worker in the child.
*/
- PushSubscriptionChange(nsCString scope, Principal principal);
+ async PushSubscriptionChange(nsCString scope, Principal principal);
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.)
*
@@ -809,20 +809,20 @@ parent:
* |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();
- PRemoteSpellcheckEngine();
- PDeviceStorageRequest(DeviceStorageParams params);
+ async PRemoteSpellcheckEngine();
+ async PDeviceStorageRequest(DeviceStorageParams params);
- PFileSystemRequest(FileSystemParams params);
+ async PFileSystemRequest(FileSystemParams params);
sync PCrashReporter(NativeThreadId tid, uint32_t processType);
prio(urgent) sync GetRandomValues(uint32_t length)
returns (uint8_t[] randomValues);
async GetSystemMemory(uint64_t getterId);
@@ -833,50 +833,50 @@ parent:
sync GetLookAndFeelCache()
returns (LookAndFeelInt[] lookAndFeelIntCache);
prio(urgent) async PHal();
async PHeapSnapshotTempFileHelper();
- PIcc(uint32_t serviceId);
+ async PIcc(uint32_t serviceId);
- PMobileConnection(uint32_t clientId);
+ async PMobileConnection(uint32_t clientId);
- PNecko();
+ async PNecko();
- PPrinting();
+ async PPrinting();
prio(high) sync PScreenManager()
returns (uint32_t numberOfScreens,
float systemDefaultScale,
bool success);
- PCellBroadcast();
+ async PCellBroadcast();
- PSms();
+ async PSms();
- PSpeechSynthesis();
+ async PSpeechSynthesis();
prio(urgent) async PStorage();
- PTelephony();
+ async PTelephony();
- PVoicemail();
+ async PVoicemail();
- PMedia();
+ async PMedia();
- PBluetooth();
+ async PBluetooth();
- PFMRadio();
+ async PFMRadio();
- PWebrtcGlobal();
+ async PWebrtcGlobal();
- PPresentation();
+ 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);
@@ -892,78 +892,78 @@ parent:
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);
- ShowAlert(AlertNotificationType alert);
+ async ShowAlert(AlertNotificationType alert);
- CloseAlert(nsString name, Principal principal);
+ async CloseAlert(nsString name, Principal principal);
- DisableNotifications(Principal principal);
+ async DisableNotifications(Principal principal);
- OpenNotificationSettings(Principal principal);
+ async OpenNotificationSettings(Principal principal);
- PPSMContentDownloader(uint32_t aCertType);
+ async PPSMContentDownloader(uint32_t aCertType);
- PExternalHelperApp(OptionalURIParams uri,
- nsCString aMimeContentType,
- nsCString aContentDisposition,
- uint32_t aContentDispositionHint,
- nsString aContentDispositionFilename,
- bool aForceSave,
- int64_t aContentLength,
- OptionalURIParams aReferrer,
- nullable PBrowser aBrowser);
+ async PExternalHelperApp(OptionalURIParams uri,
+ nsCString aMimeContentType,
+ nsCString aContentDisposition,
+ uint32_t aContentDispositionHint,
+ nsString aContentDispositionFilename,
+ bool aForceSave,
+ int64_t aContentLength,
+ OptionalURIParams aReferrer,
+ nullable PBrowser aBrowser);
- PHandlerService();
+ async PHandlerService();
- AddGeolocationListener(Principal principal, bool highAccuracy);
- RemoveGeolocationListener();
- SetGeolocationHigherAccuracy(bool enable);
+ async AddGeolocationListener(Principal principal, bool highAccuracy);
+ async RemoveGeolocationListener();
+ async SetGeolocationHigherAccuracy(bool enable);
- ConsoleMessage(nsString message);
- ScriptError(nsString message, nsString sourceName, nsString sourceLine,
- uint32_t lineNumber, uint32_t colNumber, uint32_t flags,
- nsCString category);
+ 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.
- SetClipboard(IPCDataTransfer aDataTransfer,
- bool aIsPrivateData,
- int32_t aWhichClipboard);
+ 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.
- EmptyClipboard(int32_t aWhichClipboard);
+ 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
- PrivateDocShellsExist(bool aExist);
+ 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);
@@ -1015,31 +1015,31 @@ parent:
bool isVideo);
sync GetGraphicsFeatureStatus(int32_t aFeature) returns (int32_t aStatus, bool aSuccess);
// Driver crash guards. aGuardType must be a member of CrashGuardType.
sync BeginDriverCrashGuard(uint32_t aGuardType) returns (bool crashDetected);
sync EndDriverCrashGuard(uint32_t aGuardType);
- AddIdleObserver(uint64_t observerId, uint32_t idleTimeInS);
- RemoveIdleObserver(uint64_t observerId, uint32_t idleTimeInS);
+ 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.
*/
- BackUpXResources(FileDescriptor aXSocketFd);
+ 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.
*/
@@ -1051,17 +1051,17 @@ parent:
/**
* Called to provide the options for <keygen> elements.
*/
sync KeygenProvideContent()
returns (nsString aAttribute, nsString[] aContent);
// Use only for testing!
- FlushPendingFileDeletions();
+ 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,
@@ -1094,67 +1094,67 @@ parent:
* 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.
*/
- POfflineCacheUpdate(URIParams manifestURI, URIParams documentURI,
- PrincipalInfo loadingPrincipal, bool stickDocument);
+ 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.
*/
- SetOfflinePermission(Principal principal);
+ async SetOfflinePermission(Principal principal);
/**
* Notifies the parent to continue shutting down after the child performs
* its shutdown tasks.
*/
async FinishShutdown();
- UpdateDropEffect(uint32_t aDragAction, uint32_t aDropEffect);
+ 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.
*/
- PContentPermissionRequest(PermissionRequest[] aRequests, Principal aPrincipal,
- TabId tabId);
+ 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.
*/
- GamepadListenerAdded();
+ async GamepadListenerAdded();
/**
* Tells the parent to stop the gamepad listening service if it hasn't already.
*/
- GamepadListenerRemoved();
+ async GamepadListenerRemoved();
async Profile(nsCString aProfile);
/**
* Request graphics initialization information from the parent.
*/
sync GetGraphicsDeviceInitData()
returns (DeviceInitData aData);
@@ -1186,14 +1186,14 @@ parent:
/**
* 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);
both:
- AsyncMessage(nsString aMessage, ClonedMessageData aData,
- CpowEntry[] aCpows, Principal aPrincipal);
+ async AsyncMessage(nsString aMessage, ClonedMessageData aData,
+ CpowEntry[] aCpows, Principal aPrincipal);
};
}
}
--- a/dom/ipc/PContentBridge.ipdl
+++ b/dom/ipc/PContentBridge.ipdl
@@ -46,14 +46,14 @@ parent:
both:
// Both the parent and the child can construct the PBrowser.
// See the comment in PContent::PBrowser().
async PBrowser(TabId tabId, IPCTabContext context, uint32_t chromeFlags,
ContentParentId cpId, bool isForApp, bool isForBrowser);
async PBlob(BlobConstructorParams params);
- AsyncMessage(nsString aMessage, ClonedMessageData aData,
- CpowEntry[] aCpows, Principal aPrincipal);
+ async AsyncMessage(nsString aMessage, ClonedMessageData aData,
+ CpowEntry[] aCpows, Principal aPrincipal);
};
}
}
--- a/dom/ipc/PContentDialog.ipdl
+++ b/dom/ipc/PContentDialog.ipdl
@@ -10,13 +10,13 @@ include protocol PBrowser;
namespace mozilla {
namespace dom {
protocol PContentDialog
{
manager PBrowser;
child:
- __delete__(int32_t[] aIntParams, nsString[] aStringParams);
+ async __delete__(int32_t[] aIntParams, nsString[] aStringParams);
};
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/PContentPermissionRequest.ipdl
+++ b/dom/ipc/PContentPermissionRequest.ipdl
@@ -8,21 +8,21 @@ include PContentPermission;
namespace mozilla {
namespace dom {
protocol PContentPermissionRequest
{
manager PContent;
parent:
- prompt();
- NotifyVisibility(bool visibility);
- Destroy();
+ async prompt();
+ async NotifyVisibility(bool visibility);
+ async Destroy();
child:
- GetVisibility();
- NotifyResult(bool allow, PermissionChoice[] choices);
- __delete__();
+ async GetVisibility();
+ async NotifyResult(bool allow, PermissionChoice[] choices);
+ async __delete__();
};
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/PCrashReporter.ipdl
+++ b/dom/ipc/PCrashReporter.ipdl
@@ -17,15 +17,15 @@ struct Mapping {
uintptr_t start_address;
size_t mapping_length;
size_t file_offset;
};
async protocol PCrashReporter {
manager PContent or PPluginModule or PGMP;
parent:
- AnnotateCrashReport(nsCString key, nsCString data);
- AppendAppNotes(nsCString data);
- __delete__();
+ async AnnotateCrashReport(nsCString key, nsCString data);
+ async AppendAppNotes(nsCString data);
+ async __delete__();
};
}
}
--- a/dom/ipc/PCycleCollectWithLogs.ipdl
+++ b/dom/ipc/PCycleCollectWithLogs.ipdl
@@ -7,16 +7,16 @@ include protocol PContent;
namespace mozilla {
namespace dom {
protocol PCycleCollectWithLogs {
manager PContent;
parent:
- CloseGCLog();
- CloseCCLog();
+ async CloseGCLog();
+ async CloseCCLog();
- __delete__();
+ async __delete__();
};
}
}
--- a/dom/ipc/PDocumentRenderer.ipdl
+++ b/dom/ipc/PDocumentRenderer.ipdl
@@ -13,13 +13,13 @@ namespace mozilla {
namespace ipc {
protocol PDocumentRenderer
{
manager PBrowser;
parent:
// Returns the width and height, in pixels, of the returned ARGB32 data.
- __delete__(nsIntSize renderedSize, nsCString data);
+ async __delete__(nsIntSize renderedSize, nsCString data);
};
} // namespace ipc
} // namespace mozilla
--- a/dom/ipc/PFilePicker.ipdl
+++ b/dom/ipc/PFilePicker.ipdl
@@ -23,18 +23,18 @@ union MaybeInputFiles
void_t;
};
protocol PFilePicker
{
manager PBrowser;
parent:
- Open(int16_t selectedType, bool addToRecentDocs, nsString defaultFile,
- nsString defaultExtension, nsString[] filters, nsString[] filterNames,
- nsString displayDirectory);
+ async Open(int16_t selectedType, bool addToRecentDocs, nsString defaultFile,
+ nsString defaultExtension, nsString[] filters, nsString[] filterNames,
+ nsString displayDirectory);
child:
- __delete__(MaybeInputFiles files, int16_t result);
+ async __delete__(MaybeInputFiles files, int16_t result);
};
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/PMemoryReportRequest.ipdl
+++ b/dom/ipc/PMemoryReportRequest.ipdl
@@ -16,14 +16,14 @@ struct MemoryReport {
int64_t amount;
nsCString desc;
};
protocol PMemoryReportRequest {
manager PContent;
parent:
- Report(MemoryReport aReport);
- __delete__();
+ async Report(MemoryReport aReport);
+ async __delete__();
};
}
}
--- a/dom/ipc/PScreenManager.ipdl
+++ b/dom/ipc/PScreenManager.ipdl
@@ -50,13 +50,13 @@ parent:
returns (ScreenDetails screen,
bool success);
prio(high) sync ScreenForBrowser(TabId aTabId)
returns (ScreenDetails screen,
bool success);
child:
- __delete__();
+ async __delete__();
};
} // namespace dom
} // namespace mozilla
--- a/dom/media/gmp/PGMPAudioDecoder.ipdl
+++ b/dom/media/gmp/PGMPAudioDecoder.ipdl
@@ -13,25 +13,25 @@ include "GMPMessageUtils.h";
namespace mozilla {
namespace gmp {
async protocol PGMPAudioDecoder
{
manager PGMPContent;
child:
- InitDecode(GMPAudioCodecData aCodecSettings);
- Decode(GMPAudioEncodedSampleData aInput);
- Reset();
- Drain();
- DecodingComplete();
+ async InitDecode(GMPAudioCodecData aCodecSettings);
+ async Decode(GMPAudioEncodedSampleData aInput);
+ async Reset();
+ async Drain();
+ async DecodingComplete();
parent:
- __delete__();
- Decoded(GMPAudioDecodedSampleData aDecoded);
- InputDataExhausted();
- DrainComplete();
- ResetComplete();
- Error(GMPErr aErr);
+ async __delete__();
+ async Decoded(GMPAudioDecodedSampleData aDecoded);
+ async InputDataExhausted();
+ async DrainComplete();
+ async ResetComplete();
+ async Error(GMPErr aErr);
async Shutdown();
};
} // namespace gmp
} // namespace mozilla
--- a/dom/media/gmp/PGMPDecryptor.ipdl
+++ b/dom/media/gmp/PGMPDecryptor.ipdl
@@ -15,78 +15,78 @@ using GMPErr from "gmp-errors.h";
namespace mozilla {
namespace gmp {
async protocol PGMPDecryptor
{
manager PGMPContent;
child:
- Init();
+ async Init();
- CreateSession(uint32_t aCreateSessionToken,
- uint32_t aPromiseId,
- nsCString aInitDataType,
- uint8_t[] aInitData,
- GMPSessionType aSessionType);
+ async CreateSession(uint32_t aCreateSessionToken,
+ uint32_t aPromiseId,
+ nsCString aInitDataType,
+ uint8_t[] aInitData,
+ GMPSessionType aSessionType);
- LoadSession(uint32_t aPromiseId,
- nsCString aSessionId);
+ async LoadSession(uint32_t aPromiseId,
+ nsCString aSessionId);
- UpdateSession(uint32_t aPromiseId,
- nsCString aSessionId,
- uint8_t[] aResponse);
+ async UpdateSession(uint32_t aPromiseId,
+ nsCString aSessionId,
+ uint8_t[] aResponse);
- CloseSession(uint32_t aPromiseId,
- nsCString aSessionId);
+ async CloseSession(uint32_t aPromiseId,
+ nsCString aSessionId);
- RemoveSession(uint32_t aPromiseId,
- nsCString aSessionId);
+ async RemoveSession(uint32_t aPromiseId,
+ nsCString aSessionId);
- SetServerCertificate(uint32_t aPromiseId,
- uint8_t[] aServerCert);
+ async SetServerCertificate(uint32_t aPromiseId,
+ uint8_t[] aServerCert);
- Decrypt(uint32_t aId,
- uint8_t[] aBuffer,
- GMPDecryptionData aMetadata);
+ async Decrypt(uint32_t aId,
+ uint8_t[] aBuffer,
+ GMPDecryptionData aMetadata);
- DecryptingComplete();
+ async DecryptingComplete();
parent:
- __delete__();
+ async __delete__();
- SetSessionId(uint32_t aCreateSessionToken,
- nsCString aSessionId);
+ async SetSessionId(uint32_t aCreateSessionToken,
+ nsCString aSessionId);
- ResolveLoadSessionPromise(uint32_t aPromiseId,
- bool aSuccess);
+ async ResolveLoadSessionPromise(uint32_t aPromiseId,
+ bool aSuccess);
- ResolvePromise(uint32_t aPromiseId);
+ async ResolvePromise(uint32_t aPromiseId);
- RejectPromise(uint32_t aPromiseId,
- GMPDOMException aDOMExceptionCode,
- nsCString aMessage);
+ async RejectPromise(uint32_t aPromiseId,
+ GMPDOMException aDOMExceptionCode,
+ nsCString aMessage);
- SessionMessage(nsCString aSessionId,
- GMPSessionMessageType aMessageType,
- uint8_t[] aMessage);
+ async SessionMessage(nsCString aSessionId,
+ GMPSessionMessageType aMessageType,
+ uint8_t[] aMessage);
- ExpirationChange(nsCString aSessionId, double aExpiryTime);
+ async ExpirationChange(nsCString aSessionId, double aExpiryTime);
- SessionClosed(nsCString aSessionId);
+ async SessionClosed(nsCString aSessionId);
- SessionError(nsCString aSessionId,
- GMPDOMException aDOMExceptionCode,
- uint32_t aSystemCode,
- nsCString aMessage);
+ async SessionError(nsCString aSessionId,
+ GMPDOMException aDOMExceptionCode,
+ uint32_t aSystemCode,
+ nsCString aMessage);
- KeyStatusChanged(nsCString aSessionId, uint8_t[] aKey,
- GMPMediaKeyStatus aStatus);
+ async KeyStatusChanged(nsCString aSessionId, uint8_t[] aKey,
+ GMPMediaKeyStatus aStatus);
- SetCaps(uint64_t aCaps);
+ async SetCaps(uint64_t aCaps);
- Decrypted(uint32_t aId, GMPErr aResult, uint8_t[] aBuffer);
+ async Decrypted(uint32_t aId, GMPErr aResult, uint8_t[] aBuffer);
async Shutdown();
};
} // namespace gmp
} // namespace mozilla
--- a/dom/media/gmp/PGMPStorage.ipdl
+++ b/dom/media/gmp/PGMPStorage.ipdl
@@ -11,26 +11,26 @@ using GMPErr from "gmp-errors.h";
namespace mozilla {
namespace gmp {
async protocol PGMPStorage
{
manager PGMP;
child:
- OpenComplete(nsCString aRecordName, GMPErr aStatus);
- ReadComplete(nsCString aRecordName, GMPErr aStatus, uint8_t[] aBytes);
- WriteComplete(nsCString aRecordName, GMPErr aStatus);
- RecordNames(nsCString[] aRecordNames, GMPErr aStatus);
- Shutdown();
+ async OpenComplete(nsCString aRecordName, GMPErr aStatus);
+ async ReadComplete(nsCString aRecordName, GMPErr aStatus, uint8_t[] aBytes);
+ async WriteComplete(nsCString aRecordName, GMPErr aStatus);
+ async RecordNames(nsCString[] aRecordNames, GMPErr aStatus);
+ async Shutdown();
parent:
- Open(nsCString aRecordName);
- Read(nsCString aRecordName);
- Write(nsCString aRecordName, uint8_t[] aBytes);
- Close(nsCString aRecordName);
- GetRecordNames();
- __delete__();
+ async Open(nsCString aRecordName);
+ async Read(nsCString aRecordName);
+ async Write(nsCString aRecordName, uint8_t[] aBytes);
+ async Close(nsCString aRecordName);
+ async GetRecordNames();
+ async __delete__();
};
} // namespace gmp
} // namespace mozilla
--- a/dom/media/gmp/PGMPTimer.ipdl
+++ b/dom/media/gmp/PGMPTimer.ipdl
@@ -7,16 +7,16 @@ include protocol PGMP;
namespace mozilla {
namespace gmp {
async protocol PGMPTimer
{
manager PGMP;
child:
- TimerExpired(uint32_t aTimerId);
+ async TimerExpired(uint32_t aTimerId);
parent:
- SetTimer(uint32_t aTimerId, uint32_t aTimeoutMs);
- __delete__();
+ async SetTimer(uint32_t aTimerId, uint32_t aTimeoutMs);
+ async __delete__();
};
} // namespace gmp
} // namespace mozilla
--- a/dom/media/systemservices/PMedia.ipdl
+++ b/dom/media/systemservices/PMedia.ipdl
@@ -23,29 +23,29 @@ parent:
* If no key exists, a temporal one is created.
* If aPersist is true and key is temporal, the key is promoted to persistent.
* Once persistent, a key cannot become temporal again.
*
* If aPrivateBrowsing is true, a different key for this origin is returned
* from a secondary pool that is never persisted to disk, and aPersist is
* ignored.
*/
- GetOriginKey(uint32_t aRequestId, nsCString aOrigin, bool aPrivateBrowsing,
- bool aPersist);
+ async GetOriginKey(uint32_t aRequestId, nsCString aOrigin, bool aPrivateBrowsing,
+ bool aPersist);
/**
* Clear per-orgin list of persistent deviceIds stored for enumerateDevices
* Fire and forget.
*
* aSinceTime - milliseconds since 1 January 1970 00:00:00 UTC. 0 = clear all
*
* aOnlyPrivateBrowsing - if true then only purge the separate in-memory
* per-origin list used in Private Browsing.
*/
- SanitizeOriginKeys(uint64_t aSinceWhen, bool aOnlyPrivateBrowsing);
+ async SanitizeOriginKeys(uint64_t aSinceWhen, bool aOnlyPrivateBrowsing);
child:
- GetOriginKeyResponse(uint32_t aRequestId, nsCString key);
- __delete__();
+ async GetOriginKeyResponse(uint32_t aRequestId, nsCString key);
+ async __delete__();
};
} // namespace media
} // namespace mozilla
--- a/dom/media/webrtc/PWebrtcGlobal.ipdl
+++ b/dom/media/webrtc/PWebrtcGlobal.ipdl
@@ -11,23 +11,23 @@ using WebrtcGlobalLog from "mozilla/medi
namespace mozilla {
namespace dom {
async protocol PWebrtcGlobal {
manager PContent;
child: // parent -> child messages
- GetStatsRequest(int aRequestId, nsString aPcIdFilter);
- ClearStatsRequest();
- GetLogRequest(int aRequestId, nsCString aPattern);
- ClearLogRequest();
- SetAecLogging(bool aEnable);
- SetDebugMode(int aLevel);
+ async GetStatsRequest(int aRequestId, nsString aPcIdFilter);
+ async ClearStatsRequest();
+ async GetLogRequest(int aRequestId, nsCString aPattern);
+ async ClearLogRequest();
+ async SetAecLogging(bool aEnable);
+ async SetDebugMode(int aLevel);
parent: // child -> parent messages
- GetStatsResult(int aRequestId, RTCStatsReportInternal[] aStats);
- GetLogResult(int aRequestId, WebrtcGlobalLog aLog);
- __delete__();
+ async GetStatsResult(int aRequestId, RTCStatsReportInternal[] aStats);
+ async GetLogResult(int aRequestId, WebrtcGlobalLog aLog);
+ async __delete__();
};
} // end namespace net
} // end namespace mozilla
--- a/dom/media/webspeech/synth/ipc/PSpeechSynthesis.ipdl
+++ b/dom/media/webspeech/synth/ipc/PSpeechSynthesis.ipdl
@@ -20,28 +20,28 @@ struct RemoteVoice {
sync protocol PSpeechSynthesis
{
manager PContent;
manages PSpeechSynthesisRequest;
child:
- VoiceAdded(RemoteVoice aVoice);
+ async VoiceAdded(RemoteVoice aVoice);
- VoiceRemoved(nsString aUri);
+ async VoiceRemoved(nsString aUri);
- SetDefaultVoice(nsString aUri, bool aIsDefault);
+ async SetDefaultVoice(nsString aUri, bool aIsDefault);
- IsSpeakingChanged(bool aIsSpeaking);
+ async IsSpeakingChanged(bool aIsSpeaking);
parent:
- __delete__();
+ async __delete__();
- PSpeechSynthesisRequest(nsString aText, nsString aUri, nsString aLang,
- float aVolume, float aRate, float aPitch);
+ async PSpeechSynthesisRequest(nsString aText, nsString aUri, nsString aLang,
+ float aVolume, float aRate, float aPitch);
sync ReadVoicesAndState() returns (RemoteVoice[] aVoices,
nsString[] aDefaults, bool aIsSpeaking);
};
} // namespace dom
} // namespace mozilla
--- a/dom/media/webspeech/synth/ipc/PSpeechSynthesisRequest.ipdl
+++ b/dom/media/webspeech/synth/ipc/PSpeechSynthesisRequest.ipdl
@@ -10,37 +10,37 @@ namespace mozilla {
namespace dom {
async protocol PSpeechSynthesisRequest
{
manager PSpeechSynthesis;
parent:
- __delete__();
+ async __delete__();
- Pause();
+ async Pause();
- Resume();
+ async Resume();
- Cancel();
+ async Cancel();
- ForceEnd();
+ async ForceEnd();
- SetAudioOutputVolume(float aVolume);
+ async SetAudioOutputVolume(float aVolume);
child:
- OnEnd(bool aIsError, float aElapsedTime, uint32_t aCharIndex);
+ async OnEnd(bool aIsError, float aElapsedTime, uint32_t aCharIndex);
- OnStart(nsString aUri);
+ async OnStart(nsString aUri);
- OnPause(float aElapsedTime, uint32_t aCharIndex);
+ async OnPause(float aElapsedTime, uint32_t aCharIndex);
- OnResume(float aElapsedTime, uint32_t aCharIndex);
+ async OnResume(float aElapsedTime, uint32_t aCharIndex);
- OnBoundary(nsString aName, float aElapsedTime, uint32_t aCharIndex);
+ async OnBoundary(nsString aName, float aElapsedTime, uint32_t aCharIndex);
- OnMark(nsString aName, float aElapsedTime, uint32_t aCharIndex);
+ async OnMark(nsString aName, float aElapsedTime, uint32_t aCharIndex);
};
} // namespace dom
} // namespace mozilla
--- a/dom/messagechannel/PMessagePort.ipdl
+++ b/dom/messagechannel/PMessagePort.ipdl
@@ -39,24 +39,24 @@ protocol PMessagePort
/* When the port is transferred the sequence is:
1. SendStopSendingData();
2. RecvStopSendingDataConfirmed();
3. SendDisentangle();
4. Recv__delete__(); */
parent:
- PostMessages(MessagePortMessage[] messages);
- Disentangle(MessagePortMessage[] messages);
- StopSendingData();
- Close();
+ async PostMessages(MessagePortMessage[] messages);
+ async Disentangle(MessagePortMessage[] messages);
+ async StopSendingData();
+ async Close();
child:
- Entangled(MessagePortMessage[] messages);
- ReceiveData(MessagePortMessage[] messages);
- StopSendingDataConfirmed();
+ async Entangled(MessagePortMessage[] messages);
+ async ReceiveData(MessagePortMessage[] messages);
+ async StopSendingDataConfirmed();
- __delete__();
+ async __delete__();
};
} // namespace dom
} // namespace mozilla
--- a/dom/mobileconnection/ipc/PMobileConnection.ipdl
+++ b/dom/mobileconnection/ipc/PMobileConnection.ipdl
@@ -13,39 +13,39 @@ namespace dom {
namespace mobileconnection {
sync protocol PMobileConnection
{
manager PContent;
manages PMobileConnectionRequest;
child:
- NotifyVoiceInfoChanged(nsMobileConnectionInfo aInfo);
- NotifyDataInfoChanged(nsMobileConnectionInfo aInfo);
- NotifyDataError(nsString aMessage);
- NotifyCFStateChanged(uint16_t aAction, uint16_t aReason, nsString aNumber,
- uint16_t aTimeSeconds, uint16_t aServiceClass);
- NotifyEmergencyCbModeChanged(bool aActive, uint32_t aTimeoutMs);
- NotifyOtaStatusChanged(nsString aStatus);
- NotifyRadioStateChanged(int32_t aRadioState);
- NotifyClirModeChanged(uint32_t aMode);
- NotifyLastNetworkChanged(nsString aNetwork);
- NotifyLastHomeNetworkChanged(nsString aNetwork);
- NotifyNetworkSelectionModeChanged(int32_t aMode);
+ async NotifyVoiceInfoChanged(nsMobileConnectionInfo aInfo);
+ async NotifyDataInfoChanged(nsMobileConnectionInfo aInfo);
+ async NotifyDataError(nsString aMessage);
+ async NotifyCFStateChanged(uint16_t aAction, uint16_t aReason, nsString aNumber,
+ uint16_t aTimeSeconds, uint16_t aServiceClass);
+ async NotifyEmergencyCbModeChanged(bool aActive, uint32_t aTimeoutMs);
+ async NotifyOtaStatusChanged(nsString aStatus);
+ async NotifyRadioStateChanged(int32_t aRadioState);
+ async NotifyClirModeChanged(uint32_t aMode);
+ async NotifyLastNetworkChanged(nsString aNetwork);
+ async NotifyLastHomeNetworkChanged(nsString aNetwork);
+ async NotifyNetworkSelectionModeChanged(int32_t aMode);
parent:
/**
* Send when child no longer needs to use PMobileConnection.
*/
- __delete__();
+ async __delete__();
/**
* Sent when the child makes an asynchronous request to the parent.
*/
- PMobileConnectionRequest(MobileConnectionRequest aRequest);
+ async PMobileConnectionRequest(MobileConnectionRequest aRequest);
/**
* Sync call only be called once per child actor for initialization.
*/
sync Init()
returns (nsMobileConnectionInfo aVoice, nsMobileConnectionInfo aData,
nsString aLastKnownNetwork, nsString aLastKnownHomeNetwork,
int32_t aNetworkSelectionMode, int32_t aRadioState,
--- a/dom/mobileconnection/ipc/PMobileConnectionRequest.ipdl
+++ b/dom/mobileconnection/ipc/PMobileConnectionRequest.ipdl
@@ -14,17 +14,17 @@ namespace mobileconnection {
protocol PMobileConnectionRequest
{
manager PMobileConnection;
child:
/**
* Send when asynchronous request has completed.
*/
- __delete__(MobileConnectionReply aResponse);
+ async __delete__(MobileConnectionReply aResponse);
};
/**
* MobileConnectionReply
*/
// Success
struct MobileConnectionReplySuccess
{
--- a/dom/mobilemessage/ipc/PMobileMessageCursor.ipdl
+++ b/dom/mobilemessage/ipc/PMobileMessageCursor.ipdl
@@ -12,22 +12,22 @@ namespace mozilla {
namespace dom {
namespace mobilemessage {
protocol PMobileMessageCursor
{
manager PSms;
child:
- NotifyResult(MobileMessageCursorData aData);
+ async NotifyResult(MobileMessageCursorData aData);
/**
* Sent when the asynchronous cursor request has completed.
*/
- __delete__(int32_t aError);
+ async __delete__(int32_t aError);
parent:
- Continue();
+ async Continue();
};
} // namespace mobilemessage
} // namespace dom
} // namespace mozilla
--- a/dom/mobilemessage/ipc/PSms.ipdl
+++ b/dom/mobilemessage/ipc/PSms.ipdl
@@ -106,53 +106,53 @@ union IPCMobileMessageCursor
};
sync protocol PSms {
manager PContent;
manages PSmsRequest;
manages PMobileMessageCursor;
child:
- NotifyReceivedMessage(MobileMessageData aMessageData);
+ async NotifyReceivedMessage(MobileMessageData aMessageData);
- NotifyRetrievingMessage(MobileMessageData aMessageData);
+ async NotifyRetrievingMessage(MobileMessageData aMessageData);
- NotifySendingMessage(MobileMessageData aMessageData);
+ async NotifySendingMessage(MobileMessageData aMessageData);
- NotifySentMessage(MobileMessageData aMessageData);
+ async NotifySentMessage(MobileMessageData aMessageData);
- NotifyFailedMessage(MobileMessageData aMessageData);
+ async NotifyFailedMessage(MobileMessageData aMessageData);
- NotifyDeliverySuccessMessage(MobileMessageData aMessageData);
+ async NotifyDeliverySuccessMessage(MobileMessageData aMessageData);
- NotifyDeliveryErrorMessage(MobileMessageData aMessageData);
+ async NotifyDeliveryErrorMessage(MobileMessageData aMessageData);
- NotifyReceivedSilentMessage(MobileMessageData aMessageData);
+ async NotifyReceivedSilentMessage(MobileMessageData aMessageData);
- NotifyReadSuccessMessage(MobileMessageData aMessageData);
+ async NotifyReadSuccessMessage(MobileMessageData aMessageData);
- NotifyReadErrorMessage(MobileMessageData aMessageData);
+ async NotifyReadErrorMessage(MobileMessageData aMessageData);
- NotifyDeletedMessageInfo(DeletedMessageInfoData aDeletedInfo);
+ async NotifyDeletedMessageInfo(DeletedMessageInfoData aDeletedInfo);
parent:
/**
* Sent when the child no longer needs to use sms.
*/
- __delete__();
+ async __delete__();
/**
* Sent when the child makes an asynchronous request to the parent.
*/
- PSmsRequest(IPCSmsRequest request);
+ async PSmsRequest(IPCSmsRequest request);
/**
* Sent when the child makes an asynchronous cursor to the parent.
*/
- PMobileMessageCursor(IPCMobileMessageCursor request);
+ async PMobileMessageCursor(IPCMobileMessageCursor request);
- AddSilentNumber(nsString aNumber);
- RemoveSilentNumber(nsString aNumber);
+ async AddSilentNumber(nsString aNumber);
+ async RemoveSilentNumber(nsString aNumber);
};
} // namespace mobilemessage
} // namespace dom
} // namespace mozilla
--- a/dom/mobilemessage/ipc/PSmsRequest.ipdl
+++ b/dom/mobilemessage/ipc/PSmsRequest.ipdl
@@ -17,17 +17,17 @@ namespace mobilemessage {
protocol PSmsRequest
{
manager PSms;
child:
/**
* Sent when the asynchronous request has completed.
*/
- __delete__(MessageReply response);
+ async __delete__(MessageReply response);
};
struct ReplyMessageSend
{
MobileMessageData messageData;
};
union OptionalMobileMessageData
--- a/dom/network/PTCPServerSocket.ipdl
+++ b/dom/network/PTCPServerSocket.ipdl
@@ -14,19 +14,19 @@ namespace mozilla {
namespace net {
//-------------------------------------------------------------------
protocol PTCPServerSocket
{
manager PNecko;
parent:
- Close();
- RequestDelete();
+ async Close();
+ async RequestDelete();
child:
- CallbackAccept(PTCPSocket socket);
- __delete__();
+ async CallbackAccept(PTCPSocket socket);
+ async __delete__();
};
} // namespace net
} // namespace mozilla
--- a/dom/network/PTCPSocket.ipdl
+++ b/dom/network/PTCPSocket.ipdl
@@ -34,50 +34,50 @@ namespace net {
protocol PTCPSocket
{
manager PNecko;
parent:
// Forward calling to child's open() method to parent, expect TCPOptions
// is expanded to |useSSL| (from TCPOptions.useSecureTransport) and
// |binaryType| (from TCPOption.binaryType).
- Open(nsString host, uint16_t port, bool useSSL, bool useArrayBuffers);
+ async Open(nsString host, uint16_t port, bool useSSL, bool useArrayBuffers);
// Ask parent to open a socket and bind the newly-opened socket to a local
// address specified in |localAddr| and |localPort|.
- OpenBind(nsCString host, uint16_t port,
- nsCString localAddr, uint16_t localPort,
- bool useSSL, bool aUseArrayBuffers);
+ async OpenBind(nsCString host, uint16_t port,
+ nsCString localAddr, uint16_t localPort,
+ bool useSSL, bool aUseArrayBuffers);
// When child's send() is called, this message requrests parent to send
// data and update it's trackingNumber.
- Data(SendableData data, uint32_t trackingNumber);
+ async Data(SendableData data, uint32_t trackingNumber);
// Forward calling to child's upgradeToSecure() method to parent.
- StartTLS();
+ async StartTLS();
// Forward calling to child's send() method to parent.
- Suspend();
+ async Suspend();
// Forward calling to child's resume() method to parent.
- Resume();
+ async Resume();
// Forward calling to child's close() method to parent.
- Close();
+ async Close();
child:
// Forward events that are dispatched by parent.
- Callback(nsString type, CallbackData data, uint32_t readyState);
+ async Callback(nsString type, CallbackData data, uint32_t readyState);
// Update child's bufferedAmount when parent's bufferedAmount is updated.
// trackingNumber is also passed back to child to ensure the bufferedAmount
// is corresponding the last call to send().
- UpdateBufferedAmount(uint32_t bufferedAmount, uint32_t trackingNumber);
+ async UpdateBufferedAmount(uint32_t bufferedAmount, uint32_t trackingNumber);
both:
- RequestDelete();
- __delete__();
+ async RequestDelete();
+ async __delete__();
};
} // namespace net
} // namespace mozilla
--- a/dom/network/PUDPSocket.ipdl
+++ b/dom/network/PUDPSocket.ipdl
@@ -36,33 +36,33 @@ namespace mozilla {
namespace net {
//-------------------------------------------------------------------
protocol PUDPSocket
{
manager PNecko or PBackground;
parent:
- Bind(UDPAddressInfo addressInfo, bool addressReuse, bool loopback);
- Connect(UDPAddressInfo addressInfo);
+ async Bind(UDPAddressInfo addressInfo, bool addressReuse, bool loopback);
+ async Connect(UDPAddressInfo addressInfo);
- OutgoingData(UDPData data, UDPSocketAddr addr);
+ async OutgoingData(UDPData data, UDPSocketAddr addr);
- JoinMulticast(nsCString multicastAddress, nsCString iface);
- LeaveMulticast(nsCString multicastAddress, nsCString iface);
+ async JoinMulticast(nsCString multicastAddress, nsCString iface);
+ async LeaveMulticast(nsCString multicastAddress, nsCString iface);
- Close();
+ async Close();
- RequestDelete();
+ async RequestDelete();
child:
- CallbackOpened(UDPAddressInfo addressInfo);
- CallbackConnected(UDPAddressInfo addressInfo);
- CallbackClosed();
- CallbackReceivedData(UDPAddressInfo addressInfo, uint8_t[] data);
- CallbackError(nsCString message, nsCString filename, uint32_t lineNumber);
- __delete__();
+ async CallbackOpened(UDPAddressInfo addressInfo);
+ async CallbackConnected(UDPAddressInfo addressInfo);
+ async CallbackClosed();
+ async CallbackReceivedData(UDPAddressInfo addressInfo, uint8_t[] data);
+ async CallbackError(nsCString message, nsCString filename, uint32_t lineNumber);
+ async __delete__();
};
} // namespace net
} // namespace mozilla
--- a/dom/plugins/ipc/PPluginBackgroundDestroyer.ipdl
+++ b/dom/plugins/ipc/PPluginBackgroundDestroyer.ipdl
@@ -22,16 +22,16 @@ namespace plugins {
*/
protocol PPluginBackgroundDestroyer {
manager PPluginInstance;
// The ctor message for this protocol serves double-duty as
// notification that that the background is stale.
parent:
- __delete__();
+ async __delete__();
state DESTROYING:
recv __delete__;
};
} // namespace plugins
} // namespace mozilla
--- a/dom/presentation/ipc/PPresentation.ipdl
+++ b/dom/presentation/ipc/PPresentation.ipdl
@@ -45,32 +45,32 @@ union PresentationIPCRequest
};
sync protocol PPresentation
{
manager PContent;
manages PPresentationRequest;
child:
- NotifyAvailableChange(bool aAvailable);
- NotifySessionStateChange(nsString aSessionId, uint16_t aState);
- NotifyMessage(nsString aSessionId, nsCString aData);
- NotifySessionConnect(uint64_t aWindowId, nsString aSessionId);
+ async NotifyAvailableChange(bool aAvailable);
+ async NotifySessionStateChange(nsString aSessionId, uint16_t aState);
+ async NotifyMessage(nsString aSessionId, nsCString aData);
+ async NotifySessionConnect(uint64_t aWindowId, nsString aSessionId);
parent:
- __delete__();
+ async __delete__();
- RegisterAvailabilityHandler();
- UnregisterAvailabilityHandler();
+ async RegisterAvailabilityHandler();
+ async UnregisterAvailabilityHandler();
- RegisterSessionHandler(nsString aSessionId);
- UnregisterSessionHandler(nsString aSessionId);
+ async RegisterSessionHandler(nsString aSessionId);
+ async UnregisterSessionHandler(nsString aSessionId);
- RegisterRespondingHandler(uint64_t aWindowId);
- UnregisterRespondingHandler(uint64_t aWindowId);
+ async RegisterRespondingHandler(uint64_t aWindowId);
+ async UnregisterRespondingHandler(uint64_t aWindowId);
- PPresentationRequest(PresentationIPCRequest aRequest);
+ async PPresentationRequest(PresentationIPCRequest aRequest);
- NotifyReceiverReady(nsString aSessionId);
+ async NotifyReceiverReady(nsString aSessionId);
};
} // namespace dom
} // namespace mozilla
--- a/dom/presentation/ipc/PPresentationRequest.ipdl
+++ b/dom/presentation/ipc/PPresentationRequest.ipdl
@@ -9,13 +9,13 @@ include protocol PPresentation;
namespace mozilla {
namespace dom {
sync protocol PPresentationRequest
{
manager PPresentation;
child:
- __delete__(nsresult result);
+ async __delete__(nsresult result);
};
} // namespace dom
} // namespace mozilla
--- a/dom/quota/PQuota.ipdl
+++ b/dom/quota/PQuota.ipdl
@@ -59,22 +59,22 @@ union RequestParams
protocol PQuota
{
manager PBackground;
manages PQuotaRequest;
manages PQuotaUsageRequest;
parent:
- __delete__();
+ async __delete__();
- PQuotaUsageRequest(UsageRequestParams params);
+ async PQuotaUsageRequest(UsageRequestParams params);
- PQuotaRequest(RequestParams params);
+ async PQuotaRequest(RequestParams params);
- StartIdleMaintenance();
+ async StartIdleMaintenance();
- StopIdleMaintenance();
+ async StopIdleMaintenance();
};
} // namespace quota
} // namespace dom
} // namespace mozilla
--- a/dom/quota/PQuotaRequest.ipdl
+++ b/dom/quota/PQuotaRequest.ipdl
@@ -33,14 +33,14 @@ union RequestResponse
ResetAllResponse;
};
protocol PQuotaRequest
{
manager PQuota;
child:
- __delete__(RequestResponse response);
+ async __delete__(RequestResponse response);
};
} // namespace quota
} // namespace dom
} // namespace mozilla
--- a/dom/quota/PQuotaUsageRequest.ipdl
+++ b/dom/quota/PQuotaUsageRequest.ipdl
@@ -20,17 +20,17 @@ union UsageRequestResponse
UsageResponse;
};
protocol PQuotaUsageRequest
{
manager PQuota;
parent:
- Cancel();
+ async Cancel();
child:
- __delete__(UsageRequestResponse response);
+ async __delete__(UsageRequestResponse response);
};
} // namespace quota
} // namespace dom
} // namespace mozilla
--- a/dom/telephony/ipc/PTelephony.ipdl
+++ b/dom/telephony/ipc/PTelephony.ipdl
@@ -120,50 +120,50 @@ union IPCTelephonyRequest
SendTonesRequest;
};
sync protocol PTelephony {
manager PContent;
manages PTelephonyRequest;
child:
- NotifyCallStateChanged(nsTelephonyCallInfo[] aAllInfo);
+ async NotifyCallStateChanged(nsTelephonyCallInfo[] aAllInfo);
- NotifyCdmaCallWaiting(uint32_t aClientId, IPCCdmaWaitingCallData aData);
+ async NotifyCdmaCallWaiting(uint32_t aClientId, IPCCdmaWaitingCallData aData);
- NotifyConferenceError(nsString aName, nsString aMessage);
+ async NotifyConferenceError(nsString aName, nsString aMessage);
- NotifySupplementaryService(uint32_t aClientId, int32_t aCallIndex,
- uint16_t aNotification);
+ async NotifySupplementaryService(uint32_t aClientId, int32_t aCallIndex,
+ uint16_t aNotification);
parent:
/**
* Sent when the child no longer needs to use PTelephony.
*/
- __delete__();
+ async __delete__();
/**
* Sent when the child makes an asynchronous request to the parent.
*/
- PTelephonyRequest(IPCTelephonyRequest request);
+ async PTelephonyRequest(IPCTelephonyRequest request);
- RegisterListener();
+ async RegisterListener();
- UnregisterListener();
+ async UnregisterListener();
- StartTone(uint32_t aClientId, nsString aTone);
+ async StartTone(uint32_t aClientId, nsString aTone);
- StopTone(uint32_t aClientId);
+ async StopTone(uint32_t aClientId);
sync GetMicrophoneMuted()
returns (bool aMuted);
- SetMicrophoneMuted(bool aMuted);
+ async SetMicrophoneMuted(bool aMuted);
sync GetSpeakerEnabled()
returns (bool aEnabled);
- SetSpeakerEnabled(bool aEnabled);
+ async SetSpeakerEnabled(bool aEnabled);
};
} /* namespace telephony */
} /* namespace dom */
} /* namespace mozilla */
--- a/dom/telephony/ipc/PTelephonyRequest.ipdl
+++ b/dom/telephony/ipc/PTelephonyRequest.ipdl
@@ -61,21 +61,21 @@ union IPCTelephonyResponse
DialResponseMMIError;
};
protocol PTelephonyRequest
{
manager PTelephony;
child:
- NotifyEnumerateCallState(nsTelephonyCallInfo aInfo);
+ async NotifyEnumerateCallState(nsTelephonyCallInfo aInfo);
- NotifyDialMMI(nsString aServiceCode);
+ async NotifyDialMMI(nsString aServiceCode);
/**
* Sent when the asynchronous request has completed.
*/
- __delete__(IPCTelephonyResponse aResponse);
+ async __delete__(IPCTelephonyResponse aResponse);
};
} /* namespace telephony */
} /* namespace dom */
} /* namespace mozilla */
--- a/dom/voicemail/ipc/PVoicemail.ipdl
+++ b/dom/voicemail/ipc/PVoicemail.ipdl
@@ -10,31 +10,31 @@ namespace mozilla {
namespace dom {
namespace voicemail {
sync protocol PVoicemail
{
manager PContent;
child:
- NotifyInfoChanged(uint32_t aServiceId,
- nsString aNumber,
- nsString aDisplayName);
+ async NotifyInfoChanged(uint32_t aServiceId,
+ nsString aNumber,
+ nsString aDisplayName);
- NotifyStatusChanged(uint32_t aServiceId,
- bool aHasMessages,
- int32_t aMessageCount,
- nsString aNumber,
- nsString aDisplayName);
+ async NotifyStatusChanged(uint32_t aServiceId,
+ bool aHasMessages,
+ int32_t aMessageCount,
+ nsString aNumber,
+ nsString aDisplayName);
parent:
/**
* Send when child no longer needs to use PVoicemail.
*/
- __delete__();
+ async __delete__();
sync GetAttributes(uint32_t aServiceId)
returns (nsString aNumber,
nsString aDisplayName,
bool aHasMessages,
int32_t aMessageCount,
nsString aReturnNumber,
nsString aReturnMessage);
--- a/dom/workers/PServiceWorkerManager.ipdl
+++ b/dom/workers/PServiceWorkerManager.ipdl
@@ -12,34 +12,34 @@ using mozilla::PrincipalOriginAttributes
namespace mozilla {
namespace dom {
protocol PServiceWorkerManager
{
manager PBackground;
parent:
- Register(ServiceWorkerRegistrationData data);
+ async Register(ServiceWorkerRegistrationData data);
- Unregister(PrincipalInfo principalInfo, nsString scope);
+ async Unregister(PrincipalInfo principalInfo, nsString scope);
- PropagateSoftUpdate(PrincipalOriginAttributes originAttributes,
- nsString scope);
- PropagateUnregister(PrincipalInfo principalInfo, nsString scope);
+ async PropagateSoftUpdate(PrincipalOriginAttributes originAttributes,
+ nsString scope);
+ async PropagateUnregister(PrincipalInfo principalInfo, nsString scope);
- PropagateRemove(nsCString host);
+ async PropagateRemove(nsCString host);
- PropagateRemoveAll();
+ async PropagateRemoveAll();
- Shutdown();
+ async Shutdown();
child:
- NotifyRegister(ServiceWorkerRegistrationData data);
- NotifySoftUpdate(PrincipalOriginAttributes originAttributes, nsString scope);
- NotifyUnregister(PrincipalInfo principalInfo, nsString scope);
- NotifyRemove(nsCString host);
- NotifyRemoveAll();
+ async NotifyRegister(ServiceWorkerRegistrationData data);
+ async NotifySoftUpdate(PrincipalOriginAttributes originAttributes, nsString scope);
+ async NotifyUnregister(PrincipalInfo principalInfo, nsString scope);
+ async NotifyRemove(nsCString host);
+ async NotifyRemoveAll();
- __delete__();
+ async __delete__();
};
} // namespace dom
} // namespace mozilla
--- a/embedding/components/printingui/ipc/PPrintProgressDialog.ipdl
+++ b/embedding/components/printingui/ipc/PPrintProgressDialog.ipdl
@@ -8,28 +8,28 @@ include protocol PPrinting;
namespace mozilla {
namespace embedding {
protocol PPrintProgressDialog
{
manager PPrinting;
parent:
- StateChange(long stateFlags,
- nsresult status);
+ async StateChange(long stateFlags,
+ nsresult status);
- ProgressChange(long curSelfProgress,
- long maxSelfProgress,
- long curTotalProgress,
- long maxTotalProgress);
+ async ProgressChange(long curSelfProgress,
+ long maxSelfProgress,
+ long curTotalProgress,
+ long maxTotalProgress);
- DocTitleChange(nsString newTitle);
+ async DocTitleChange(nsString newTitle);
- DocURLChange(nsString newURL);
+ async DocURLChange(nsString newURL);
- __delete__();
+ async __delete__();
child:
- DialogOpened();
+ async DialogOpened();
};
} // namespace embedding
} // namespace mozilla
--- a/embedding/components/printingui/ipc/PPrintSettingsDialog.ipdl
+++ b/embedding/components/printingui/ipc/PPrintSettingsDialog.ipdl
@@ -17,13 +17,13 @@ union PrintDataOrNSResult
nsresult;
};
protocol PPrintSettingsDialog
{
manager PPrinting;
child:
- __delete__(PrintDataOrNSResult result);
+ async __delete__(PrintDataOrNSResult result);
};
} // namespace embedding
} // namespace mozilla
--- a/embedding/components/printingui/ipc/PPrinting.ipdl
+++ b/embedding/components/printingui/ipc/PPrinting.ipdl
@@ -26,22 +26,22 @@ parent:
bool isForPrinting)
returns(bool notifyOnOpen,
nsresult rv);
async ShowPrintDialog(PPrintSettingsDialog dialog,
PBrowser browser,
PrintData settings);
- PPrintProgressDialog();
- PPrintSettingsDialog();
+ async PPrintProgressDialog();
+ async PPrintSettingsDialog();
sync SavePrintSettings(PrintData settings, bool usePrinterNamePrefix,
uint32_t flags)
returns(nsresult rv);
child:
async PRemotePrintJob();
- __delete__();
+ async __delete__();
};
} // namespace embedding
} // namespace mozilla
--- a/embedding/components/webbrowserpersist/PWebBrowserPersistDocument.ipdl
+++ b/embedding/components/webbrowserpersist/PWebBrowserPersistDocument.ipdl
@@ -54,29 +54,29 @@ protocol PWebBrowserPersistDocument {
manages PWebBrowserPersistResources;
manages PWebBrowserPersistSerialize;
parent:
// The actor isn't exposed to XPCOM until after it gets one of these
// two messages; see also the state transition rules. The message
// is either a response to the constructor (if it was parent->child)
// or sent after it (if it was child->parent).
- Attributes(WebBrowserPersistDocumentAttrs aAttrs,
- OptionalInputStreamParams postData,
- FileDescriptor[] postFiles);
- InitFailure(nsresult aStatus);
+ async Attributes(WebBrowserPersistDocumentAttrs aAttrs,
+ OptionalInputStreamParams postData,
+ FileDescriptor[] postFiles);
+ async InitFailure(nsresult aStatus);
child:
- SetPersistFlags(uint32_t aNewFlags);
- PWebBrowserPersistResources();
- PWebBrowserPersistSerialize(WebBrowserPersistURIMap aMap,
- nsCString aRequestedContentType,
- uint32_t aEncoderFlags,
- uint32_t aWrapColumn);
- __delete__();
+ async SetPersistFlags(uint32_t aNewFlags);
+ async PWebBrowserPersistResources();
+ async PWebBrowserPersistSerialize(WebBrowserPersistURIMap aMap,
+ nsCString aRequestedContentType,
+ uint32_t aEncoderFlags,
+ uint32_t aWrapColumn);
+ async __delete__();
state START:
recv Attributes goto MAIN;
recv InitFailure goto FAILED;
state MAIN:
send SetPersistFlags goto MAIN;
send PWebBrowserPersistResources goto MAIN;
--- a/embedding/components/webbrowserpersist/PWebBrowserPersistResources.ipdl
+++ b/embedding/components/webbrowserpersist/PWebBrowserPersistResources.ipdl
@@ -7,20 +7,20 @@ include protocol PWebBrowserPersistDocum
namespace mozilla {
// == nsIWebBrowserPersistResourceVisitor
protocol PWebBrowserPersistResources {
manager PWebBrowserPersistDocument;
parent:
- VisitResource(nsCString aURI);
+ async VisitResource(nsCString aURI);
// The actor sent here is in the START state; the parent-side
// receiver will have to wait for it to enter the MAIN state
// before exposing it with a visitDocument call.
- VisitDocument(PWebBrowserPersistDocument aSubDocument);
+ async VisitDocument(PWebBrowserPersistDocument aSubDocument);
// This reflects the endVisit method.
- __delete__(nsresult aStatus);
+ async __delete__(nsresult aStatus);
};
} // namespace mozilla
--- a/embedding/components/webbrowserpersist/PWebBrowserPersistSerialize.ipdl
+++ b/embedding/components/webbrowserpersist/PWebBrowserPersistSerialize.ipdl
@@ -14,16 +14,16 @@ protocol PWebBrowserPersistSerialize {
parent:
// This sends the data with no flow control, so the parent could
// wind up buffering an arbitrarily large amount of data... but
// it's a serialized DOM that's already in memory as DOM nodes, so
// this is at worst just a constant-factor increase in memory usage.
// Also, Chromium does the same thing; see
// content::RenderViewImpl::didSerializeDataForFrame.
- WriteData(uint8_t[] aData);
+ async WriteData(uint8_t[] aData);
// This is the onFinish method.
- __delete__(nsCString aContentType,
- nsresult aStatus);
+ async __delete__(nsCString aContentType,
+ nsresult aStatus);
};
} // namespace mozilla
--- a/extensions/spellcheck/hunspell/glue/PRemoteSpellcheckEngine.ipdl
+++ b/extensions/spellcheck/hunspell/glue/PRemoteSpellcheckEngine.ipdl
@@ -5,17 +5,17 @@
include protocol PContent;
namespace mozilla {
sync protocol PRemoteSpellcheckEngine {
manager PContent;
parent:
- __delete__();
+ async __delete__();
sync Check(nsString aWord) returns (bool aIsMisspelled);
sync CheckAndSuggest(nsString aWord) returns (bool aIsMisspelled, nsString[] aSuggestions);
sync SetDictionary(nsString aDictionary) returns (bool success);
};
--- a/hal/sandbox/PHal.ipdl
+++ b/hal/sandbox/PHal.ipdl
@@ -95,89 +95,89 @@ struct SystemTimezoneChangeInformation {
} // namespace hal
namespace hal_sandbox {
prio(normal upto urgent) sync protocol PHal {
manager PContent;
child:
- NotifyBatteryChange(BatteryInformation aBatteryInfo);
- NotifyNetworkChange(NetworkInformation aNetworkInfo);
- NotifyWakeLockChange(WakeLockInformation aWakeLockInfo);
- NotifyScreenConfigurationChange(ScreenConfiguration aScreenOrientation);
- NotifySwitchChange(SwitchEvent aEvent);
- NotifySystemClockChange(int64_t aClockDeltaMS);
- NotifySystemTimezoneChange(SystemTimezoneChangeInformation aSystemTimezoneChangeInfo);
+ async NotifyBatteryChange(BatteryInformation aBatteryInfo);
+ async NotifyNetworkChange(NetworkInformation aNetworkInfo);
+ async NotifyWakeLockChange(WakeLockInformation aWakeLockInfo);
+ async NotifyScreenConfigurationChange(ScreenConfiguration aScreenOrientation);
+ async NotifySwitchChange(SwitchEvent aEvent);
+ async NotifySystemClockChange(int64_t aClockDeltaMS);
+ async NotifySystemTimezoneChange(SystemTimezoneChangeInformation aSystemTimezoneChangeInfo);
parent:
- Vibrate(uint32_t[] pattern, uint64_t[] id, PBrowser browser);
- CancelVibrate(uint64_t[] id, PBrowser browser);
+ async Vibrate(uint32_t[] pattern, uint64_t[] id, PBrowser browser);
+ async CancelVibrate(uint64_t[] id, PBrowser browser);
- EnableBatteryNotifications();
- DisableBatteryNotifications();
+ async EnableBatteryNotifications();
+ async DisableBatteryNotifications();
sync GetCurrentBatteryInformation()
returns (BatteryInformation aBatteryInfo);
- EnableNetworkNotifications();
- DisableNetworkNotifications();
+ async EnableNetworkNotifications();
+ async DisableNetworkNotifications();
sync GetCurrentNetworkInformation()
returns (NetworkInformation aNetworkInfo);
sync GetScreenEnabled() returns (bool enabled);
- SetScreenEnabled(bool aEnabled);
+ async SetScreenEnabled(bool aEnabled);
sync GetKeyLightEnabled() returns (bool enabled);
- SetKeyLightEnabled(bool aEnabled);
+ async SetKeyLightEnabled(bool aEnabled);
sync GetCpuSleepAllowed() returns (bool allowed);
- SetCpuSleepAllowed(bool aAllowed);
+ async SetCpuSleepAllowed(bool aAllowed);
sync GetScreenBrightness() returns (double brightness);
- SetScreenBrightness(double aBrightness);
+ async SetScreenBrightness(double aBrightness);
- AdjustSystemClock(int64_t aDeltaMilliseconds);
- SetTimezone(nsCString aTimezoneSpec);
+ async AdjustSystemClock(int64_t aDeltaMilliseconds);
+ async SetTimezone(nsCString aTimezoneSpec);
sync GetTimezone()
returns (nsCString aTimezoneSpec);
sync GetTimezoneOffset()
returns (int32_t aTimezoneOffset);
- EnableSystemClockChangeNotifications();
- DisableSystemClockChangeNotifications();
- EnableSystemTimezoneChangeNotifications();
- DisableSystemTimezoneChangeNotifications();
+ async EnableSystemClockChangeNotifications();
+ async DisableSystemClockChangeNotifications();
+ async EnableSystemTimezoneChangeNotifications();
+ async DisableSystemTimezoneChangeNotifications();
- ModifyWakeLock(nsString aTopic,
- WakeLockControl aLockAdjust,
- WakeLockControl aHiddenAdjust,
- uint64_t aProcessID);
- EnableWakeLockNotifications();
- DisableWakeLockNotifications();
+ async ModifyWakeLock(nsString aTopic,
+ WakeLockControl aLockAdjust,
+ WakeLockControl aHiddenAdjust,
+ uint64_t aProcessID);
+ async EnableWakeLockNotifications();
+ async DisableWakeLockNotifications();
sync GetWakeLockInfo(nsString aTopic)
returns (WakeLockInformation aWakeLockInfo);
- EnableScreenConfigurationNotifications();
- DisableScreenConfigurationNotifications();
+ async EnableScreenConfigurationNotifications();
+ async DisableScreenConfigurationNotifications();
prio(urgent) sync GetCurrentScreenConfiguration()
returns (ScreenConfiguration aScreenConfiguration);
sync LockScreenOrientation(ScreenOrientationInternal aOrientation)
returns (bool allowed);
- UnlockScreenOrientation();
+ async UnlockScreenOrientation();
- EnableSwitchNotifications(SwitchDevice aDevice);
- DisableSwitchNotifications(SwitchDevice aDevice);
+ async EnableSwitchNotifications(SwitchDevice aDevice);
+ async DisableSwitchNotifications(SwitchDevice aDevice);
sync GetCurrentSwitchState(SwitchDevice aDevice)
returns (SwitchState aState);
- FactoryReset(nsString aReason);
+ async FactoryReset(nsString aReason);
child:
- NotifySensorChange(SensorData aSensorData);
+ async NotifySensorChange(SensorData aSensorData);
parent:
- EnableSensorNotifications(SensorType aSensor);
- DisableSensorNotifications(SensorType aSensor);
+ async EnableSensorNotifications(SensorType aSensor);
+ async DisableSensorNotifications(SensorType aSensor);
- __delete__();
+ async __delete__();
};
} // namespace hal
} // namespace mozilla
--- a/ipc/glue/PBackground.ipdl
+++ b/ipc/glue/PBackground.ipdl
@@ -55,52 +55,52 @@ sync protocol PBackground
manages PNuwa;
manages PQuota;
manages PServiceWorkerManager;
manages PUDPSocket;
manages PVsync;
parent:
// Only called at startup during mochitests to check the basic infrastructure.
- PBackgroundTest(nsCString testArg);
+ async PBackgroundTest(nsCString testArg);
- PBackgroundIDBFactory(LoggingInfo loggingInfo);
+ async PBackgroundIDBFactory(LoggingInfo loggingInfo);
- PBackgroundIndexedDBUtils();
+ async PBackgroundIndexedDBUtils();
- PVsync();
+ async PVsync();
- PCameras();
+ async PCameras();
- PUDPSocket(OptionalPrincipalInfo pInfo, nsCString filter);
- PBroadcastChannel(PrincipalInfo pInfo, nsCString origin, nsString channel,
- bool privateBrowsing);
+ async PUDPSocket(OptionalPrincipalInfo pInfo, nsCString filter);
+ async PBroadcastChannel(PrincipalInfo pInfo, nsCString origin, nsString channel,
+ bool privateBrowsing);
- PServiceWorkerManager();
+ async PServiceWorkerManager();
- ShutdownServiceWorkerRegistrar();
+ async ShutdownServiceWorkerRegistrar();
- PCacheStorage(Namespace aNamespace, PrincipalInfo aPrincipalInfo);
+ async PCacheStorage(Namespace aNamespace, PrincipalInfo aPrincipalInfo);
- PMessagePort(nsID uuid, nsID destinationUuid, uint32_t sequenceId);
+ async PMessagePort(nsID uuid, nsID destinationUuid, uint32_t sequenceId);
- PNuwa();
+ async PNuwa();
- MessagePortForceClose(nsID uuid, nsID destinationUuid, uint32_t sequenceId);
+ async MessagePortForceClose(nsID uuid, nsID destinationUuid, uint32_t sequenceId);
- PAsmJSCacheEntry(OpenMode openMode,
- WriteParams write,
- PrincipalInfo principalInfo);
+ async PAsmJSCacheEntry(OpenMode openMode,
+ WriteParams write,
+ PrincipalInfo principalInfo);
- PQuota();
+ async PQuota();
child:
- PCache();
- PCacheStreamControl();
+ async PCache();
+ async PCacheStreamControl();
both:
- PBlob(BlobConstructorParams params);
+ async PBlob(BlobConstructorParams params);
- PFileDescriptorSet(FileDescriptor fd);
+ async PFileDescriptorSet(FileDescriptor fd);
};
} // namespace ipc
} // namespace mozilla
--- a/ipc/glue/PBackgroundTest.ipdl
+++ b/ipc/glue/PBackgroundTest.ipdl
@@ -8,13 +8,13 @@ namespace mozilla {
namespace ipc {
// This is a very simple testing protocol that is only used during mochitests.
protocol PBackgroundTest
{
manager PBackground;
child:
- __delete__(nsCString testArg);
+ async __delete__(nsCString testArg);
};
} // namespace ipc
} // namespace mozilla
--- a/ipc/glue/PFileDescriptorSet.ipdl
+++ b/ipc/glue/PFileDescriptorSet.ipdl
@@ -8,15 +8,15 @@ include protocol PContent;
namespace mozilla {
namespace ipc {
protocol PFileDescriptorSet
{
manager PBackground or PContent;
both:
- AddFileDescriptor(FileDescriptor fd);
+ async AddFileDescriptor(FileDescriptor fd);
- __delete__();
+ async __delete__();
};
} // namespace ipc
} // namespace mozilla
--- a/ipc/ipdl/ipdl/parser.py
+++ b/ipc/ipdl/ipdl/parser.py
@@ -494,17 +494,17 @@ def p_MessageDirectionLabel(p):
elif p[1] == 'child':
Parser.current.direction = OUT
elif p[1] == 'both':
Parser.current.direction = INOUT
else:
assert 0
def p_MessageDecl(p):
- """MessageDecl : OptionalSendSemanticsQual MessageBody"""
+ """MessageDecl : SendSemanticsQual MessageBody"""
msg = p[2]
msg.priority = p[1][0]
msg.sendSemantics = p[1][1]
if Parser.current.direction is None:
_error(msg.loc, 'missing message direction')
msg.direction = Parser.current.direction
@@ -631,22 +631,16 @@ def p_Priority(p):
"""Priority : NORMAL
| HIGH
| URGENT"""
prios = {'normal': 1,
'high': 2,
'urgent': 3}
p[0] = prios[p[1]]
-def p_OptionalSendSemanticsQual(p):
- """OptionalSendSemanticsQual : SendSemanticsQual
- | """
- if 2 == len(p): p[0] = p[1]
- else: p[0] = [ NORMAL_PRIORITY, ASYNC ]
-
def p_SendSemanticsQual(p):
"""SendSemanticsQual : ASYNC
| SYNC
| PRIO '(' Priority ')' ASYNC
| PRIO '(' Priority ')' SYNC
| INTR"""
if p[1] == 'prio':
mtype = p[5]
--- a/ipc/ipdl/test/cxx/PTestActorPunning.ipdl
+++ b/ipc/ipdl/test/cxx/PTestActorPunning.ipdl
@@ -8,23 +8,23 @@ using struct mozilla::_ipdltest::Bad fro
namespace mozilla {
namespace _ipdltest {
protocol PTestActorPunning {
manages PTestActorPunningPunned;
manages PTestActorPunningSub;
child:
- Start();
+ async Start();
parent:
- PTestActorPunningPunned();
- PTestActorPunningSub();
- Pun(PTestActorPunningSub a, Bad bad);
- __delete__();
+ async PTestActorPunningPunned();
+ async PTestActorPunningSub();
+ async Pun(PTestActorPunningSub a, Bad bad);
+ async __delete__();
state PING:
send Start goto CONSTRUCTING;
state CONSTRUCTING:
recv PTestActorPunningPunned goto CONSTRUCTING;
recv PTestActorPunningSub goto CONSTRUCTING;
--- a/ipc/ipdl/test/cxx/PTestActorPunningPunned.ipdl
+++ b/ipc/ipdl/test/cxx/PTestActorPunningPunned.ipdl
@@ -3,13 +3,13 @@ include protocol PTestActorPunning;
namespace mozilla {
namespace _ipdltest {
protocol PTestActorPunningPunned {
manager PTestActorPunning;
child:
- __delete__();
+ async __delete__();
};
} // namespace mozilla
} // namespace _ipdltes
--- a/ipc/ipdl/test/cxx/PTestActorPunningSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestActorPunningSub.ipdl
@@ -3,14 +3,14 @@ include protocol PTestActorPunning;
namespace mozilla {
namespace _ipdltest {
protocol PTestActorPunningSub {
manager PTestActorPunning;
child:
- Bad();
- __delete__();
+ async Bad();
+ async __delete__();
};
} // namespace mozilla
} // namespace _ipdltes
--- a/ipc/ipdl/test/cxx/PTestBadActor.ipdl
+++ b/ipc/ipdl/test/cxx/PTestBadActor.ipdl
@@ -5,14 +5,14 @@ namespace _ipdltest {
// Test that a parent sending a reentrant __delete__ message
// is not killed if a child's message races with the reply.
intr protocol PTestBadActor {
manages PTestBadActorSub;
child:
- PTestBadActorSub();
- __delete__();
+ async PTestBadActorSub();
+ async __delete__();
};
} // namespace _ipdltest
} // namespace mozilla
--- a/ipc/ipdl/test/cxx/PTestBadActorSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestBadActorSub.ipdl
@@ -5,13 +5,13 @@ namespace _ipdltest {
intr protocol PTestBadActorSub {
manager PTestBadActor;
child:
intr __delete__();
parent:
- Ping();
+ async Ping();
};
} // namespace _ipdltest
} // namespace mozilla
--- a/ipc/ipdl/test/cxx/PTestBridgeMain.ipdl
+++ b/ipc/ipdl/test/cxx/PTestBridgeMain.ipdl
@@ -5,20 +5,20 @@ namespace mozilla {
namespace _ipdltest {
protocol PTestBridgeMain {
child spawns PTestBridgeSub;
child opens PTestBridgeMainSub;
child:
- Start();
+ async Start();
parent:
- __delete__();
+ async __delete__();
state START:
send Start goto DEAD;
state DEAD:
recv __delete__;
};
--- a/ipc/ipdl/test/cxx/PTestBridgeMainSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestBridgeMainSub.ipdl
@@ -5,24 +5,24 @@ namespace mozilla {
namespace _ipdltest {
// (Bridge protocols can have different semantics than the endpoints
// they bridge)
intr protocol PTestBridgeMainSub {
bridges PTestBridgeMain, PTestBridgeSub;
child:
- Hi();
+ async Hi();
intr HiRpc();
parent:
- Hello();
+ async Hello();
sync HelloSync();
intr HelloRpc();
- __delete__();
+ async __delete__();
state START: recv Hello goto HI;
state HI: send Hi goto HELLO_SYNC;
state HELLO_SYNC: recv HelloSync goto HELLO_RPC;
state HELLO_RPC: answer HelloRpc goto HI_RPC;
state HI_RPC: call HiRpc goto DEAD;
state DEAD:
recv __delete__;
--- a/ipc/ipdl/test/cxx/PTestBridgeSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestBridgeSub.ipdl
@@ -1,21 +1,21 @@
include protocol PTestBridgeMainSub;
namespace mozilla {
namespace _ipdltest {
protocol PTestBridgeSub {
child:
- Ping();
+ async Ping();
parent:
- BridgeEm();
- __delete__();
+ async BridgeEm();
+ async __delete__();
state START:
send Ping goto BRIDGEEM;
state BRIDGEEM:
recv BridgeEm goto DEAD;
state DEAD:
recv __delete__;
};
--- a/ipc/ipdl/test/cxx/PTestCrashCleanup.ipdl
+++ b/ipc/ipdl/test/cxx/PTestCrashCleanup.ipdl
@@ -5,17 +5,17 @@
namespace mozilla {
namespace _ipdltest {
// NB: needs to be RPC so that the parent blocks on the child's crash.
intr protocol PTestCrashCleanup {
child:
intr DIEDIEDIE();
- __delete__();
+ async __delete__();
state ALIVE:
call DIEDIEDIE goto CRASH;
state CRASH:
send __delete__;
};
}
--- a/ipc/ipdl/test/cxx/PTestDataStructures.ipdl
+++ b/ipc/ipdl/test/cxx/PTestDataStructures.ipdl
@@ -5,22 +5,22 @@ include "mozilla/GfxMessageUtils.h";
namespace mozilla {
namespace _ipdltest {
sync protocol PTestDataStructures {
manages PTestDataStructuresSub;
child:
- PTestDataStructuresSub(int i);
+ async PTestDataStructuresSub(int i);
- Start();
+ async Start();
parent:
- __delete__();
+ async __delete__();
sync Test1(int[] i1)
returns (int[] o1);
sync Test2(PTestDataStructuresSub[] i1)
returns (PTestDataStructuresSub[] o1);
sync Test3(IntDouble i1,
--- a/ipc/ipdl/test/cxx/PTestDesc.ipdl
+++ b/ipc/ipdl/test/cxx/PTestDesc.ipdl
@@ -4,22 +4,22 @@ include protocol PTestDescSubsub;
namespace mozilla {
namespace _ipdltest {
intr protocol PTestDesc {
manages PTestDescSub;
child:
intr PTestDescSub(nullable PTestDescSubsub dummy);
- Test(PTestDescSubsub a);
+ async Test(PTestDescSubsub a);
- __delete__();
+ async __delete__();
parent:
- Ok(PTestDescSubsub a);
+ async Ok(PTestDescSubsub a);
state CONSTRUCT:
call PTestDescSub goto TEST;
state TEST:
send Test goto ACK;
state ACK:
recv Ok goto DEAD;
--- a/ipc/ipdl/test/cxx/PTestDescSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestDescSub.ipdl
@@ -4,15 +4,15 @@ include protocol PTestDescSubsub;
namespace mozilla {
namespace _ipdltest {
intr protocol PTestDescSub {
manager PTestDesc;
manages PTestDescSubsub;
child:
- __delete__();
+ async __delete__();
intr PTestDescSubsub();
};
}
}
--- a/ipc/ipdl/test/cxx/PTestEndpointBridgeMain.ipdl
+++ b/ipc/ipdl/test/cxx/PTestEndpointBridgeMain.ipdl
@@ -7,17 +7,17 @@ include protocol PTestEndpointBridgeSub;
namespace mozilla {
namespace _ipdltest {
protocol PTestEndpointBridgeMain {
child spawns PTestEndpointBridgeSub;
child:
- Start();
+ async Start();
parent:
- Bridged(Endpoint<PTestEndpointBridgeMainSubParent> endpoint);
+ async Bridged(Endpoint<PTestEndpointBridgeMainSubParent> endpoint);
};
} // namespace mozilla
} // namespace _ipdltest
--- a/ipc/ipdl/test/cxx/PTestEndpointBridgeMainSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestEndpointBridgeMainSub.ipdl
@@ -6,20 +6,20 @@ include protocol PTestEndpointBridgeSub;
namespace mozilla {
namespace _ipdltest {
// (Bridge protocols can have different semantics than the endpoints
// they bridge)
intr protocol PTestEndpointBridgeMainSub {
child:
- Hi();
+ async Hi();
intr HiRpc();
parent:
- Hello();
+ async Hello();
sync HelloSync();
intr HelloRpc();
};
} // namespace mozilla
} // namespace _ipdltest
--- a/ipc/ipdl/test/cxx/PTestEndpointBridgeSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestEndpointBridgeSub.ipdl
@@ -4,19 +4,19 @@
include protocol PTestEndpointBridgeMainSub;
namespace mozilla {
namespace _ipdltest {
protocol PTestEndpointBridgeSub {
child:
- Ping();
+ async Ping();
- Bridged(Endpoint<PTestEndpointBridgeMainSubChild> endpoint);
+ async Bridged(Endpoint<PTestEndpointBridgeMainSubChild> endpoint);
parent:
- BridgeEm();
+ async BridgeEm();
};
} // namespace mozilla
} // namespace _ipdltest
--- a/ipc/ipdl/test/cxx/PTestEndpointOpens.ipdl
+++ b/ipc/ipdl/test/cxx/PTestEndpointOpens.ipdl
@@ -2,18 +2,18 @@
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
include protocol PTestEndpointOpensOpened;
namespace mozilla {
namespace _ipdltest {
protocol PTestEndpointOpens {
child:
- Start();
+ async Start();
parent:
- StartSubprotocol(Endpoint<PTestEndpointOpensOpenedParent> endpoint);
+ async StartSubprotocol(Endpoint<PTestEndpointOpensOpenedParent> endpoint);
- __delete__();
+ async __delete__();
};
} // namespace mozilla
} // namespace _ipdltest
--- a/ipc/ipdl/test/cxx/PTestEndpointOpensOpened.ipdl
+++ b/ipc/ipdl/test/cxx/PTestEndpointOpensOpened.ipdl
@@ -2,24 +2,24 @@
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
namespace mozilla {
namespace _ipdltest2 {
// (Opens protocols can have different semantics than the endpoints
// that opened them)
intr protocol PTestEndpointOpensOpened {
child:
- Hi();
+ async Hi();
intr HiRpc();
parent:
- Hello();
+ async Hello();
sync HelloSync();
intr HelloRpc();
- __delete__();
+ async __delete__();
state START: recv Hello goto HI;
state HI: send Hi goto HELLO_SYNC;
state HELLO_SYNC: recv HelloSync goto HELLO_RPC;
state HELLO_RPC: answer HelloRpc goto HI_RPC;
state HI_RPC: call HiRpc goto DEAD;
state DEAD:
recv __delete__;
--- a/ipc/ipdl/test/cxx/PTestFailedCtor.ipdl
+++ b/ipc/ipdl/test/cxx/PTestFailedCtor.ipdl
@@ -2,17 +2,17 @@ include protocol PTestFailedCtorSub;
namespace mozilla {
namespace _ipdltest {
intr protocol PTestFailedCtor {
manages PTestFailedCtorSub;
child:
intr PTestFailedCtorSub();
- __delete__();
+ async __delete__();
state CONSTRUCT:
call PTestFailedCtorSub goto DEAD;
state DEAD:
send __delete__;
};
}
--- a/ipc/ipdl/test/cxx/PTestFailedCtorSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestFailedCtorSub.ipdl
@@ -6,13 +6,13 @@ namespace _ipdltest {
intr protocol PTestFailedCtorSub {
manager PTestFailedCtor;
manages PTestFailedCtorSubsub;
parent:
async PTestFailedCtorSubsub();
sync Sync();
- __delete__();
+ async __delete__();
};
}
}
--- a/ipc/ipdl/test/cxx/PTestFailedCtorSubsub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestFailedCtorSubsub.ipdl
@@ -3,13 +3,13 @@ include protocol PTestFailedCtorSub;
namespace mozilla {
namespace _ipdltest {
intr protocol PTestFailedCtorSubsub {
manager PTestFailedCtorSub;
parent:
- __delete__();
+ async __delete__();
};
}
}
--- a/ipc/ipdl/test/cxx/PTestHandle.ipdl
+++ b/ipc/ipdl/test/cxx/PTestHandle.ipdl
@@ -2,13 +2,13 @@ include protocol PTestJSON;
namespace mozilla {
namespace _ipdltest {
protocol PTestHandle {
manager PTestJSON;
child:
- __delete__();
+ async __delete__();
};
} // namespace mozilla
} // namespace _ipdltest
--- a/ipc/ipdl/test/cxx/PTestHangs.ipdl
+++ b/ipc/ipdl/test/cxx/PTestHangs.ipdl
@@ -7,17 +7,17 @@ both:
intr StackFrame();
parent:
async Nonce();
child:
async Start();
intr Hang();
- __delete__();
+ async __delete__();
state START:
send Start goto RACE;
state RACE:
recv Nonce goto RACE1;
call StackFrame goto RACE2;
--- a/ipc/ipdl/test/cxx/PTestIndirectProtocolParamFirst.ipdl
+++ b/ipc/ipdl/test/cxx/PTestIndirectProtocolParamFirst.ipdl
@@ -7,13 +7,13 @@ include PTestIndirectProtocolParam;
namespace mozilla {
namespace _ipdltest {
sync protocol PTestIndirectProtocolParamFirst {
manager PTestIndirectProtocolParamManage;
parent:
sync Test(IndirectParamUnion actor);
both:
- __delete__();
+ async __delete__();
};
}
}
--- a/ipc/ipdl/test/cxx/PTestIndirectProtocolParamManage.ipdl
+++ b/ipc/ipdl/test/cxx/PTestIndirectProtocolParamManage.ipdl
@@ -3,15 +3,15 @@ include protocol PTestIndirectProtocolPa
namespace mozilla {
namespace _ipdltest {
sync protocol PTestIndirectProtocolParamManage {
manages PTestIndirectProtocolParamFirst;
manages PTestIndirectProtocolParamSecond;
both:
- PTestIndirectProtocolParamFirst();
- PTestIndirectProtocolParamSecond();
- __delete__();
+ async PTestIndirectProtocolParamFirst();
+ async PTestIndirectProtocolParamSecond();
+ async __delete__();
};
}
}
--- a/ipc/ipdl/test/cxx/PTestIndirectProtocolParamSecond.ipdl
+++ b/ipc/ipdl/test/cxx/PTestIndirectProtocolParamSecond.ipdl
@@ -1,13 +1,13 @@
include protocol PTestIndirectProtocolParamManage;
namespace mozilla {
namespace _ipdltest {
sync protocol PTestIndirectProtocolParamSecond {
manager PTestIndirectProtocolParamManage;
both:
- __delete__();
+ async __delete__();
};
}
}
--- a/ipc/ipdl/test/cxx/PTestInterruptRaces.ipdl
+++ b/ipc/ipdl/test/cxx/PTestInterruptRaces.ipdl
@@ -8,21 +8,21 @@ both:
intr StackFrame3() returns ();
parent:
sync StartRace();
intr Parent();
sync GetAnsweredParent() returns (bool answeredParent);
child:
- Start();
- Wakeup();
- Wakeup3();
+ async Start();
+ async Wakeup();
+ async Wakeup3();
intr Child();
- __delete__();
+ async __delete__();
state START:
send Start goto TEST1;
// First test: race while no other messages are on the Interrupt stack
state TEST1:
recv StartRace goto RACE1;
state RACE1:
--- a/ipc/ipdl/test/cxx/PTestLatency.ipdl
+++ b/ipc/ipdl/test/cxx/PTestLatency.ipdl
@@ -1,29 +1,29 @@
namespace mozilla {
namespace _ipdltest {
intr protocol PTestLatency {
child:
- __delete__();
- Ping();
- Ping5();
+ async __delete__();
+ async Ping();
+ async Ping5();
intr Rpc();
- Spam();
+ async Spam();
intr Synchro();
- CompressedSpam(uint32_t seqno) compress;
+ async CompressedSpam(uint32_t seqno) compress;
intr Synchro2() returns (uint32_t lastSeqno,
uint32_t numMessagesDispatched);
parent:
- Pong();
- Pong5();
+ async Pong();
+ async Pong5();
state START:
// if the timing resolution is too low, abort the test
send __delete__;
// otherwise, kick off the ping/pong trials
send Ping goto PONG;
// Trial 1: single ping/pong latency
--- a/ipc/ipdl/test/cxx/PTestManyChildAllocs.ipdl
+++ b/ipc/ipdl/test/cxx/PTestManyChildAllocs.ipdl
@@ -2,18 +2,18 @@ include protocol PTestManyChildAllocsSub
namespace mozilla {
namespace _ipdltest {
protocol PTestManyChildAllocs {
manages PTestManyChildAllocsSub;
child:
- Go(); // start allocating
+ async Go(); // start allocating
parent:
- Done();
+ async Done();
- PTestManyChildAllocsSub();
+ async PTestManyChildAllocsSub();
};
} // namespace _ipdltest
} // namespace mozilla
--- a/ipc/ipdl/test/cxx/PTestManyChildAllocsSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestManyChildAllocsSub.ipdl
@@ -2,18 +2,18 @@ include protocol PTestManyChildAllocs;
namespace mozilla {
namespace _ipdltest {
protocol PTestManyChildAllocsSub {
manager PTestManyChildAllocs;
child:
- __delete__();
+ async __delete__();
parent:
- Hello();
+ async Hello();
// empty
};
} // namespace _ipdltest
} // namespace mozilla
--- a/ipc/ipdl/test/cxx/PTestMultiMgrs.ipdl
+++ b/ipc/ipdl/test/cxx/PTestMultiMgrs.ipdl
@@ -4,23 +4,23 @@ include protocol PTestMultiMgrsRight;
namespace mozilla {
namespace _ipdltest {
protocol PTestMultiMgrs {
manages PTestMultiMgrsLeft;
manages PTestMultiMgrsRight;
parent:
- OK();
+ async OK();
child:
- PTestMultiMgrsLeft();
- PTestMultiMgrsRight();
- Check();
- __delete__();
+ async PTestMultiMgrsLeft();
+ async PTestMultiMgrsRight();
+ async Check();
+ async __delete__();
state START:
send PTestMultiMgrsLeft goto CONSTRUCT_RIGHT;
state CONSTRUCT_RIGHT:
send PTestMultiMgrsRight goto CHILD_CHECK;
state CHILD_CHECK:
send Check goto CHILD_ACK;
state CHILD_ACK:
--- a/ipc/ipdl/test/cxx/PTestMultiMgrsBottom.ipdl
+++ b/ipc/ipdl/test/cxx/PTestMultiMgrsBottom.ipdl
@@ -3,16 +3,16 @@ include protocol PTestMultiMgrsRight;
namespace mozilla {
namespace _ipdltest {
protocol PTestMultiMgrsBottom {
manager PTestMultiMgrsLeft or PTestMultiMgrsRight;
child:
- __delete__();
+ async __delete__();
state DOA:
send __delete__;
};
} // namespace _ipdltest
} // namespace mozilla
--- a/ipc/ipdl/test/cxx/PTestMultiMgrsLeft.ipdl
+++ b/ipc/ipdl/test/cxx/PTestMultiMgrsLeft.ipdl
@@ -5,18 +5,18 @@ namespace mozilla {
namespace _ipdltest {
protocol PTestMultiMgrsLeft {
manager PTestMultiMgrs;
manages PTestMultiMgrsBottom;
child:
- PTestMultiMgrsBottom();
- __delete__();
+ async PTestMultiMgrsBottom();
+ async __delete__();
state START:
send PTestMultiMgrsBottom goto DONE;
state DONE:
send __delete__;
};
--- a/ipc/ipdl/test/cxx/PTestMultiMgrsRight.ipdl
+++ b/ipc/ipdl/test/cxx/PTestMultiMgrsRight.ipdl
@@ -5,18 +5,18 @@ namespace mozilla {
namespace _ipdltest {
protocol PTestMultiMgrsRight {
manager PTestMultiMgrs;
manages PTestMultiMgrsBottom;
child:
- PTestMultiMgrsBottom();
- __delete__();
+ async PTestMultiMgrsBottom();
+ async __delete__();
state START:
send PTestMultiMgrsBottom goto DONE;
state DONE:
send __delete__;
};
--- a/ipc/ipdl/test/cxx/PTestNestedLoops.ipdl
+++ b/ipc/ipdl/test/cxx/PTestNestedLoops.ipdl
@@ -3,17 +3,17 @@ namespace mozilla {
namespace _ipdltest {
intr protocol PTestNestedLoops {
child:
async Start();
intr R();
- __delete__();
+ async __delete__();
parent:
async Nonce();
state START:
send Start goto RACE;
--- a/ipc/ipdl/test/cxx/PTestOpens.ipdl
+++ b/ipc/ipdl/test/cxx/PTestOpens.ipdl
@@ -4,20 +4,20 @@ namespace mozilla {
namespace _ipdltest {
protocol PTestOpens {
// This channel is opened and parked on a non-main thread
child opens PTestOpensOpened;
child:
- Start();
+ async Start();
parent:
- __delete__();
+ async __delete__();
state START:
send Start goto DEAD;
state DEAD:
recv __delete__;
};
--- a/ipc/ipdl/test/cxx/PTestOpensOpened.ipdl
+++ b/ipc/ipdl/test/cxx/PTestOpensOpened.ipdl
@@ -1,23 +1,23 @@
namespace mozilla {
namespace _ipdltest2 {
// (Opens protocols can have different semantics than the endpoints
// that opened them)
intr protocol PTestOpensOpened {
child:
- Hi();
+ async Hi();
intr HiRpc();
parent:
- Hello();
+ async Hello();
sync HelloSync();
intr HelloRpc();
- __delete__();
+ async __delete__();
state START: recv Hello goto HI;
state HI: send Hi goto HELLO_SYNC;
state HELLO_SYNC: recv HelloSync goto HELLO_RPC;
state HELLO_RPC: answer HelloRpc goto HI_RPC;
state HI_RPC: call HiRpc goto DEAD;
state DEAD:
recv __delete__;
--- a/ipc/ipdl/test/cxx/PTestRacyReentry.ipdl
+++ b/ipc/ipdl/test/cxx/PTestRacyReentry.ipdl
@@ -2,17 +2,17 @@
namespace mozilla {
namespace _ipdltest {
intr protocol PTestRacyReentry {
parent:
intr E();
- __delete__();
+ async __delete__();
child:
async Start();
async N();
intr H();
};
--- a/ipc/ipdl/test/cxx/PTestSanity.ipdl
+++ b/ipc/ipdl/test/cxx/PTestSanity.ipdl
@@ -1,21 +1,21 @@
namespace mozilla {
namespace _ipdltest {
protocol PTestSanity {
child:
- Ping(int zero, float zeroPtFive, int8_t dummy);
- __delete__();
+ async Ping(int zero, float zeroPtFive, int8_t dummy);
+ async __delete__();
parent:
- Pong(int one, float zeroPtTwoFive, uint8_t dummy);
+ async Pong(int one, float zeroPtTwoFive, uint8_t dummy);
state PING:
send Ping goto PONG;
state PONG:
recv Pong goto DEAD;
--- a/ipc/ipdl/test/cxx/PTestSelfManage.ipdl
+++ b/ipc/ipdl/test/cxx/PTestSelfManage.ipdl
@@ -4,18 +4,18 @@ namespace mozilla {
namespace _ipdltest {
protocol PTestSelfManage {
manager PTestSelfManageRoot or PTestSelfManage;
manages PTestSelfManage;
child:
- PTestSelfManage();
- __delete__();
+ async PTestSelfManage();
+ async __delete__();
state LIVE:
send PTestSelfManage goto LIVE;
send __delete__;
};
} // namespace mozilla
--- a/ipc/ipdl/test/cxx/PTestSelfManageRoot.ipdl
+++ b/ipc/ipdl/test/cxx/PTestSelfManageRoot.ipdl
@@ -3,18 +3,18 @@ include protocol PTestSelfManage;
namespace mozilla {
namespace _ipdltest {
protocol PTestSelfManageRoot {
manages PTestSelfManage;
child:
- PTestSelfManage();
- __delete__();
+ async PTestSelfManage();
+ async __delete__();
state LIVE:
send PTestSelfManage goto DEAD;
state DEAD:
send __delete__;
};
--- a/ipc/ipdl/test/cxx/PTestShmem.ipdl
+++ b/ipc/ipdl/test/cxx/PTestShmem.ipdl
@@ -1,18 +1,18 @@
namespace mozilla {
namespace _ipdltest {
protocol PTestShmem {
child:
- Give(Shmem mem, Shmem unsafe, size_t expectedSize);
+ async Give(Shmem mem, Shmem unsafe, size_t expectedSize);
parent:
- Take(Shmem mem, Shmem unsafe, size_t expectedSize);
- __delete__();
+ async Take(Shmem mem, Shmem unsafe, size_t expectedSize);
+ async __delete__();
state GIVING:
send Give goto TAKING;
state TAKING:
recv Take goto TAKING;
recv __delete__;
--- a/ipc/ipdl/test/cxx/PTestShutdown.ipdl
+++ b/ipc/ipdl/test/cxx/PTestShutdown.ipdl
@@ -2,29 +2,29 @@ include protocol PTestShutdownSub;
namespace mozilla {
namespace _ipdltest {
intr protocol PTestShutdown {
manages PTestShutdownSub;
child:
- Start();
+ async Start();
parent:
// NB: we test deletion and crashing only, not shutdown, because
// crashing is the same code path as shutdown, and other IPDL unit
// tests check shutdown semantics
- PTestShutdownSub(bool expectCrash);
+ async PTestShutdownSub(bool expectCrash);
// Used to synchronize between parent and child, to avoid races
// around flushing socket write queues
sync Sync();
- __delete__();
+ async __delete__();
state START:
send Start goto TESTING;
state TESTING:
recv PTestShutdownSub goto TESTING;
recv Sync goto DYING;
--- a/ipc/ipdl/test/cxx/PTestShutdownSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestShutdownSub.ipdl
@@ -7,17 +7,17 @@ namespace _ipdltest {
intr protocol PTestShutdownSub {
manager PTestShutdown;
manages PTestShutdownSubsub;
both:
intr StackFrame();
parent:
- PTestShutdownSubsub(bool expectParentDeleted);
+ async PTestShutdownSubsub(bool expectParentDeleted);
sync __delete__();
state CREATING:
recv PTestShutdownSubsub goto CREATING;
answer StackFrame goto DUMMYFRAME;
state DUMMYFRAME:
call StackFrame goto DEAD;
--- a/ipc/ipdl/test/cxx/PTestStackHooks.ipdl
+++ b/ipc/ipdl/test/cxx/PTestStackHooks.ipdl
@@ -13,17 +13,17 @@ parent:
async Async();
sync Sync();
intr Rpc();
both:
intr StackFrame();
parent:
- __delete__();
+ async __delete__();
state START:
send Start goto TEST1;
state TEST1:
recv Async goto TEST2;
--- a/ipc/ipdl/test/cxx/PTestSyncError.ipdl
+++ b/ipc/ipdl/test/cxx/PTestSyncError.ipdl
@@ -1,21 +1,21 @@
namespace mozilla {
namespace _ipdltest {
sync protocol PTestSyncError {
child:
- Start();
+ async Start();
parent:
sync Error();
- __delete__();
+ async __delete__();
state START:
send Start goto SYNC_ERROR;
state SYNC_ERROR:
recv Error goto DEAD;
--- a/ipc/ipdl/test/cxx/PTestSyncHang.ipdl
+++ b/ipc/ipdl/test/cxx/PTestSyncHang.ipdl
@@ -1,15 +1,15 @@
namespace mozilla {
namespace _ipdltest {
protocol PTestSyncHang {
child:
- __delete__();
+ async __delete__();
};
} // namespace mozilla
} // namespace _ipdltest
--- a/ipc/ipdl/test/cxx/PTestSysVShmem.ipdl
+++ b/ipc/ipdl/test/cxx/PTestSysVShmem.ipdl
@@ -1,18 +1,18 @@
namespace mozilla {
namespace _ipdltest {
protocol PTestSysVShmem {
child:
- Give(Shmem mem, Shmem unsafe, size_t expectedSize);
+ async Give(Shmem mem, Shmem unsafe, size_t expectedSize);
parent:
- Take(Shmem mem, Shmem unsafe, size_t expectedSize);
- __delete__();
+ async Take(Shmem mem, Shmem unsafe, size_t expectedSize);
+ async __delete__();
state GIVING:
send Give goto TAKING;
state TAKING:
recv Take goto TAKING;
recv __delete__;
--- a/ipc/ipdl/test/ipdl/error/DeleteRace.ipdl
+++ b/ipc/ipdl/test/ipdl/error/DeleteRace.ipdl
@@ -1,14 +1,14 @@
// XXX kind of a gray area whether |__delete__| should be a part of the
// top-level protocol. but if it's ever not, this test will break and
// we'll notice, right?
protocol DeleteRace {
parent:
- M1();
+ async M1();
child:
- __delete__();
+ async __delete__();
state START:
send __delete__;
recv M1 goto START;
};
--- a/ipc/ipdl/test/ipdl/error/Nullable.ipdl
+++ b/ipc/ipdl/test/ipdl/error/Nullable.ipdl
@@ -1,4 +1,4 @@
protocol Nullable {
child:
- Msg(nullable int i);
+ async Msg(nullable int i);
};
--- a/ipc/ipdl/test/ipdl/error/Nullable2.ipdl
+++ b/ipc/ipdl/test/ipdl/error/Nullable2.ipdl
@@ -1,8 +1,8 @@
union Union {
nullable int;
};
protocol Nullable2 {
child:
- Msg(Union i);
+ async Msg(Union i);
};
--- a/ipc/ipdl/test/ipdl/error/actorparam_badState.ipdl
+++ b/ipc/ipdl/test/ipdl/error/actorparam_badState.ipdl
@@ -1,10 +1,10 @@
protocol actorparam_badState {
child:
- Msg(actorparam_badState:FARGEL p);
- __delete__();
+ async Msg(actorparam_badState:FARGEL p);
+ async __delete__();
state S1:
send Msg goto S1;
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/bridgesSubprotocol.ipdl
+++ b/ipc/ipdl/test/ipdl/error/bridgesSubprotocol.ipdl
@@ -2,12 +2,12 @@ include protocol subprotocolBridges;
protocol bridgesSubprotocol {
bridges subprotocolBridges, subprotocolBridges;
manages subprotocolBridges;
child:
subprotocolBridges();
- __delete__();
+ async __delete__();
state DEAD: send __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/cyclecheck_Child.ipdl
+++ b/ipc/ipdl/test/ipdl/error/cyclecheck_Child.ipdl
@@ -2,11 +2,11 @@ include protocol cyclecheck_Parent;
include protocol cyclecheck_Grandchild;
protocol cyclecheck_Child {
manager cyclecheck_Parent;
manages cyclecheck_Grandchild;
child:
cyclecheck_Grandchild();
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/cyclecheck_Grandchild.ipdl
+++ b/ipc/ipdl/test/ipdl/error/cyclecheck_Grandchild.ipdl
@@ -2,11 +2,11 @@ include protocol cyclecheck_Child;
include protocol cyclecheck_Parent;
protocol cyclecheck_Grandchild {
manager cyclecheck_Child;
manages cyclecheck_Parent;
child:
cyclecheck_Parent();
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/cyclecheck_Parent.ipdl
+++ b/ipc/ipdl/test/ipdl/error/cyclecheck_Parent.ipdl
@@ -1,10 +1,10 @@
include protocol cyclecheck_Child;
protocol cyclecheck_Parent {
manages cyclecheck_Child;
child:
cyclecheck_Child();
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/manageSelfToplevel.ipdl
+++ b/ipc/ipdl/test/ipdl/error/manageSelfToplevel.ipdl
@@ -1,8 +1,8 @@
protocol manageSelfToplevel {
manager manageSelfToplevel;
manages manageSelfToplevel;
child:
manageSelfToplevel();
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/messageNoDirection.ipdl
+++ b/ipc/ipdl/test/ipdl/error/messageNoDirection.ipdl
@@ -1,3 +1,3 @@
protocol messageNoDirection {
- NoDirection();
+ async NoDirection();
};
--- a/ipc/ipdl/test/ipdl/error/multimanDupMgrs.ipdl
+++ b/ipc/ipdl/test/ipdl/error/multimanDupMgrs.ipdl
@@ -1,8 +1,8 @@
include protocol multimanDupMgrsMgr;
protocol multimanDupMgrs {
manager multimanDupMgrsMgr or multimanDupMgrsMgr;
child:
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/multimanDupMgrsMgr.ipdl
+++ b/ipc/ipdl/test/ipdl/error/multimanDupMgrsMgr.ipdl
@@ -1,9 +1,9 @@
include protocol multimanDupMgrs;
protocol multimanDupMgrsMgr {
manages multimanDupMgrs;
child:
multimanDupMgrs();
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/multimanNonexistentMgrs.ipdl
+++ b/ipc/ipdl/test/ipdl/error/multimanNonexistentMgrs.ipdl
@@ -1,7 +1,7 @@
protocol multimanNonexistentManagers {
manager Starsky or Hutch;
child:
- Dummy();
- __delete__();
+ async Dummy();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/mutualRecStruct.ipdl
+++ b/ipc/ipdl/test/ipdl/error/mutualRecStruct.ipdl
@@ -10,11 +10,11 @@ struct Y {
struct Z {
double d;
X x;
};
protocol mutualRecStruct {
child:
- Test(X x, Y y, Z z);
- __delete__();
+ async Test(X x, Y y, Z z);
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/mutualRecStructUnion.ipdl
+++ b/ipc/ipdl/test/ipdl/error/mutualRecStructUnion.ipdl
@@ -10,11 +10,11 @@ union Y {
struct Z {
double d;
X x;
};
protocol mutualRecStructUnion {
child:
- Test(X x, Y y, Z z);
- __delete__();
+ async Test(X x, Y y, Z z);
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/opensSubprotocol.ipdl
+++ b/ipc/ipdl/test/ipdl/error/opensSubprotocol.ipdl
@@ -2,12 +2,12 @@ include protocol subprotocolOpens;
protocol opensSubprotocol {
child opens subprotocolOpens;
manages subprotocolOpens;
child:
subprotocolOpens();
- __delete__();
+ async __delete__();
state DEAD: send __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/race_OverlappingMultiOut.ipdl
+++ b/ipc/ipdl/test/ipdl/error/race_OverlappingMultiOut.ipdl
@@ -1,17 +1,17 @@
protocol race_OverlappingMultiOut {
child:
- Msg1();
- Msg1_();
- __delete__(); suppressUndeleteableError();
+ async Msg1();
+ async Msg1_();
+ async __delete__(); suppressUndeleteableError();
parent:
- Msg2();
- Msg2_();
+ async Msg2();
+ async Msg2_();
start state _:
send __delete__;
send suppressUndeleteableError goto S10;
// *** ERROR: send/recv of Msg1/Msg2 in state S10 goes to overlapping
// sets { S11, S12 }, { S12, S13 } and thus can't be unidirectional
--- a/ipc/ipdl/test/ipdl/error/race_ViolateSameDirection.ipdl
+++ b/ipc/ipdl/test/ipdl/error/race_ViolateSameDirection.ipdl
@@ -1,16 +1,17 @@
protocol race_ViolateSameDirection {
child:
- Msg1();
- Msg1_();
- __delete__(); suppressUndeleteableError();
+ async Msg1();
+ async Msg1_();
+ async __delete__();
+ async suppressUndeleteableError();
parent:
- Msg2();
- Msg2_();
+ async Msg2();
+ async Msg2_();
// *** ERROR: state S7 doesn't have all-same-direction
start state _:
send __delete__;
send suppressUndeleteableError goto S6;
state S6:
send Msg1 goto S7;
--- a/ipc/ipdl/test/ipdl/error/redeclMessage.ipdl
+++ b/ipc/ipdl/test/ipdl/error/redeclMessage.ipdl
@@ -1,9 +1,9 @@
protocol redeclMessage {
// can't declare two messages with the same name
child:
- Msg();
- Msg();
+ async Msg();
+ async Msg();
};
--- a/ipc/ipdl/test/ipdl/error/redefState.ipdl
+++ b/ipc/ipdl/test/ipdl/error/redefState.ipdl
@@ -1,14 +1,14 @@
protocol redefState {
// error: redefining state in state machine
child:
- Msg();
- __delete__();
+ async Msg();
+ async __delete__();
state S1: send Msg goto S1;
state S1: send Msg goto S1;
start state _:
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/shmem_access_union.ipdl
+++ b/ipc/ipdl/test/ipdl/error/shmem_access_union.ipdl
@@ -1,8 +1,8 @@
union Union {
[-r-w|+r+w] Shmem;
};
protocol shmem_access_union {
child:
- Msg(Union u);
+ async Msg(Union u);
};
--- a/ipc/ipdl/test/ipdl/error/spawnsSubprotocol.ipdl
+++ b/ipc/ipdl/test/ipdl/error/spawnsSubprotocol.ipdl
@@ -2,12 +2,12 @@ include protocol subprotocolSpawns;
protocol spawnsSubprotocol {
parent spawns subprotocolSpawns;
manages subprotocolSpawns;
child:
subprotocolSpawns();
- __delete__();
+ async __delete__();
state DEAD: send __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongDirection.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongDirection.ipdl
@@ -1,12 +1,12 @@
protocol trans_WrongDirection {
child:
- Msg();
- __delete__();
+ async Msg();
+ async __delete__();
state S1:
recv Msg goto S1;
start state _:
send __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongDirection2.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongDirection2.ipdl
@@ -1,12 +1,12 @@
protocol trans_WrongDirection2 {
parent:
- Msg();
- __delete__();
+ async Msg();
+ async __delete__();
state S1:
send Msg goto S1;
start state _:
recv __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongDirection3.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongDirection3.ipdl
@@ -1,12 +1,12 @@
sync protocol trans_WrongDirection3 {
parent:
sync Msg();
- __delete__();
+ async __delete__();
state S1:
send Msg goto S1;
start state _:
recv __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongDirection4.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongDirection4.ipdl
@@ -1,12 +1,12 @@
intr protocol trans_WrongDirection4 {
child:
intr Msg();
- __delete__();
+ async __delete__();
state S1:
answer Msg goto S1;
start state _:
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongDirection5.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongDirection5.ipdl
@@ -1,12 +1,12 @@
intr protocol trans_WrongDirection5 {
parent:
intr Msg();
- __delete__()
+ async __delete__()
state S1:
call Msg goto S1;
start state_:
recv __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongName.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongName.ipdl
@@ -1,10 +1,10 @@
protocol trans_WrongName {
child:
- Msg();
- __delete__();
+ async Msg();
+ async __delete__();
state S1:
call Msg goto S1;
send __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongName2.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongName2.ipdl
@@ -1,10 +1,10 @@
protocol trans_WrongName2 {
parent:
- Msg();
- __delete__();
+ async Msg();
+ async __delete__();
state S1:
answer Msg goto S1;
recv __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongName3.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongName3.ipdl
@@ -1,10 +1,10 @@
sync protocol trans_WrongName3 {
parent:
sync Msg();
- __delete__();
+ async __delete__();
state S1:
answer Msg goto S1;
recv __delete__();
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongName4.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongName4.ipdl
@@ -1,10 +1,10 @@
intr protocol trans_WrongName4 {
child:
intr Msg();
- __delete__();
+ async __delete__();
state S1:
send Msg goto S1;
send __delete__
};
--- a/ipc/ipdl/test/ipdl/error/trans_WrongName5.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongName5.ipdl
@@ -1,10 +1,10 @@
intr protocol trans_WrongName5 {
parent:
intr Msg();
- __delete__();
+ async __delete__();
state S1:
recv Msg goto S1;
recv __delete__;
};
--- a/ipc/ipdl/test/ipdl/error/unreachedDeleteMultiStart.ipdl
+++ b/ipc/ipdl/test/ipdl/error/unreachedDeleteMultiStart.ipdl
@@ -1,10 +1,10 @@
protocol unreachedDeleteMultiStart {
child:
- M1(); M2(); __delete__();
+ async M1(); async M2(); async __delete__();
start state S1: send M1 goto S2;
state S2: send __delete__;
start state S3: send M2 goto S4;
state S4: send M1 goto S3;
};
--- a/ipc/ipdl/test/ipdl/ok/Delete.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/Delete.ipdl
@@ -1,8 +1,8 @@
include protocol DeleteSub;
sync protocol Delete {
manages DeleteSub;
child:
- DeleteSub();
+ async DeleteSub();
};
--- a/ipc/ipdl/test/ipdl/ok/Nullable.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/Nullable.ipdl
@@ -1,11 +1,11 @@
union Union {
nullable Nullable;
nullable Nullable[];
};
protocol Nullable {
child:
- Msg(nullable Nullable n);
- Msg2(nullable Nullable[] N);
- Msg3(Union u);
+ async Msg(nullable Nullable n);
+ async Msg2(nullable Nullable[] N);
+ async Msg3(Union u);
};
--- a/ipc/ipdl/test/ipdl/ok/Struct.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/Struct.ipdl
@@ -1,10 +1,10 @@
struct S {
int i;
double d;
};
sync protocol Struct {
parent:
sync test(S s) returns (S ss);
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/ok/actorparam_state.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/actorparam_state.ipdl
@@ -1,10 +1,10 @@
protocol actorparam_state {
child:
- Msg(actorparam_state:S1 p);
- __delete__();
+ async Msg(actorparam_state:S1 p);
+ async __delete__();
state S1:
send Msg goto S1;
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/ok/array_Basic.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/array_Basic.ipdl
@@ -1,4 +1,4 @@
protocol array_Basic {
child:
- Msg(int[] array);
+ async Msg(int[] array);
};
--- a/ipc/ipdl/test/ipdl/ok/array_OfActors.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/array_OfActors.ipdl
@@ -1,10 +1,10 @@
include protocol array_OfActorsSub;
protocol array_OfActors {
manages array_OfActorsSub;
child:
- Msg(array_OfActorsSub[] p);
+ async Msg(array_OfActorsSub[] p);
array_OfActorsSub();
};
--- a/ipc/ipdl/test/ipdl/ok/compositor.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/compositor.ipdl
@@ -1,11 +1,11 @@
include protocol content;
sync protocol compositor {
bridges compositor, content;
child:
- __delete__();
+ async __delete__();
state DEAD:
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/ok/content.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/content.ipdl
@@ -5,13 +5,13 @@ include protocol plugin;
sync protocol content {
parent spawns compositor as parent;
parent spawns jetpack;
child spawns plugin;
child opens media;
child:
- __delete__();
+ async __delete__();
state DEAD:
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/ok/headerProto.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/headerProto.ipdl
@@ -1,10 +1,10 @@
include header;
namespace c {
protocol headerProto {
child:
- __delete__(foo a, baz b, Inner1 c, Inner2 d, X x);
+ async __delete__(foo a, baz b, Inner1 c, Inner2 d, X x);
};
}
--- a/ipc/ipdl/test/ipdl/ok/intrProtocol.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/intrProtocol.ipdl
@@ -1,13 +1,13 @@
intr protocol intrProtocol {
// sanity check of Interrupt protocols
child:
- AsyncMsg();
+ async AsyncMsg();
parent:
sync SyncMsg(int i) returns (int r);
both:
intr InterruptMsg(int x) returns (int y);
};
--- a/ipc/ipdl/test/ipdl/ok/jetpack.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/jetpack.ipdl
@@ -1,7 +1,7 @@
sync protocol jetpack {
child:
- __delete__();
+ async __delete__();
state DEAD:
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/ok/jetpackContent.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/jetpackContent.ipdl
@@ -1,12 +1,12 @@
include protocol content;
include protocol jetpack;
intr protocol jetpackContent {
bridges jetpack, content;
child:
- __delete__();
+ async __delete__();
state DEAD:
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/ok/manageSelf.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/manageSelf.ipdl
@@ -1,10 +1,10 @@
include protocol manageSelf_Toplevel;
protocol manageSelf {
manager manageSelf_Toplevel or manageSelf;
manages manageSelf;
child:
manageSelf();
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/ok/manageSelf_Toplevel.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/manageSelf_Toplevel.ipdl
@@ -1,9 +1,9 @@
include protocol manageSelf;
protocol manageSelf_Toplevel {
manages manageSelf;
child:
manageSelf();
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/ok/managedProtocol.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/managedProtocol.ipdl
@@ -1,8 +1,8 @@
include protocol managerProtocol;
protocol managedProtocol {
manager managerProtocol;
child:
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/ok/media.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/media.ipdl
@@ -1,7 +1,7 @@
sync protocol media {
child:
- __delete__();
+ async __delete__();
state DEAD:
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/ok/multiManaged.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/multiManaged.ipdl
@@ -1,9 +1,9 @@
include protocol multiManager1;
include protocol multiManager2;
protocol multiManaged {
manager multiManager1 or multiManager2;
child:
- __delete__();
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/ok/multipleUsingCxxTypes.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/multipleUsingCxxTypes.ipdl
@@ -1,7 +1,7 @@
using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
protocol multipleUsingCxxTypes {
child:
- Msg(void_t foo);
+ async Msg(void_t foo);
};
--- a/ipc/ipdl/test/ipdl/ok/mutualRecStructUnion.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/mutualRecStructUnion.ipdl
@@ -11,11 +11,11 @@ union Y {
struct Z {
X x;
Y y;
};
protocol mutualRecStructUnion {
child:
- Test(X x, Y y, Z z);
- __delete__();
+ async Test(X x, Y y, Z z);
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/ok/mutualRecUnion.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/mutualRecUnion.ipdl
@@ -10,11 +10,11 @@ union Y {
union Z {
double;
X;
};
protocol mutualRecUnion {
child:
- Test(X x, Y y, Z z);
- __delete__();
+ async Test(X x, Y y, Z z);
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/ok/namespace_Basic.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/namespace_Basic.ipdl
@@ -1,12 +1,12 @@
namespace basic {
// sanity check of namespaced protocols
protocol namespace_Basic {
child:
- Msg();
+ async Msg();
};
} // namespace basic
--- a/ipc/ipdl/test/ipdl/ok/noRedeclCrossMessage.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/noRedeclCrossMessage.ipdl
@@ -1,9 +1,9 @@
protocol noRedeclCrossMessage {
// each message has its own scope for param/return names
child:
- Msg1(int f);
- Msg2(int f);
+ async Msg1(int f);
+ async Msg2(int f);
};
--- a/ipc/ipdl/test/ipdl/ok/plugin.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/plugin.ipdl
@@ -1,7 +1,7 @@
intr protocol plugin {
child:
- __delete__();
+ async __delete__();
state DEAD:
send __delete__;
};
--- a/ipc/ipdl/test/ipdl/ok/race_DiamondRule1.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/race_DiamondRule1.ipdl
@@ -1,16 +1,16 @@
protocol race_DiamondRule1 {
child:
- Msg1();
- Msg1_();
+ async Msg1();
+ async Msg1_();
parent:
- Msg2();
- Msg2_();
+ async Msg2();
+ async Msg2_();
// OK: this state machine is one of the simplest that follows the
// Diamond Rule
start state S1:
send Msg1 goto S2;
recv Msg2 goto S3;
--- a/ipc/ipdl/test/ipdl/ok/race_KitchenSink.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/race_KitchenSink.ipdl
@@ -1,15 +1,15 @@
protocol race_KitchenSink {
child:
- Msg1();
- Msg1_();
+ async Msg1();
+ async Msg1_();
parent:
- Msg2();
- Msg2_();
+ async Msg2();
+ async Msg2_();
// concatenation of a few other state machines, should be OK
start state S1:
send Msg1 goto S2;
recv Msg2 goto S3;
--- a/ipc/ipdl/test/ipdl/ok/race_MultiOut.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/race_MultiOut.ipdl
@@ -1,15 +1,15 @@
protocol race_MultiOut {
child:
- Msg1();
- Msg1_();
+ async Msg1();
+ async Msg1_();
parent:
- Msg2();
- Msg2_();
+ async Msg2();
+ async Msg2_();
start state S15:
send Msg1 goto S16 or S17;
recv Msg2 goto S18 or S19;
state S16:
recv Msg2 goto S20;
recv Msg2_ goto S18;
--- a/ipc/ipdl/test/ipdl/ok/race_Stateless.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/race_Stateless.ipdl
@@ -1,16 +1,16 @@
protocol race_Stateless {
// manages Child;
child:
- Msg1();
- Msg1_();
+ async Msg1();
+ async Msg1_();
parent:
- Msg2();
- Msg2_();
+ async Msg2();
+ async Msg2_();
// OK: this is trivial stateless protocol, so race-free "by definition"
start state S5:
send Msg1 goto S5;
recv Msg2 goto S5;
};
--- a/ipc/ipdl/test/ipdl/ok/selfRecUnion.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/selfRecUnion.ipdl
@@ -1,11 +1,11 @@
union R {
int;
double;
R;
};
protocol selfRecUnion {
child:
- Test(R r);
- __delete__();
+ async Test(R r);
+ async __delete__();
};
--- a/ipc/ipdl/test/ipdl/ok/shmem.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/shmem.ipdl
@@ -1,13 +1,13 @@
union Foo {
int;
Shmem;
};
intr protocol shmem {
parent:
- Msg(Shmem s, Foo f);
+ async Msg(Shmem s, Foo f);
sync SyncMsg(Shmem s, Foo f)
returns (Shmem t, Foo g);
intr InterruptMsg(Shmem s, Foo f)
returns (Shmem t, Foo g);
};
--- a/ipc/ipdl/test/ipdl/ok/syncProtocol.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/syncProtocol.ipdl
@@ -1,11 +1,11 @@
sync protocol syncProtocol {
// sanity check of sync protocols
child:
- AsyncMsg();
+ async AsyncMsg();
parent:
sync SyncMsg() returns (int i);
};
--- a/ipc/ipdl/test/ipdl/ok/threeDirections.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/threeDirections.ipdl
@@ -1,13 +1,13 @@
protocol threeDirections {
// sanity check that the three direction specifiers are being accepted
child:
- ChildMsg();
+ async ChildMsg();
parent:
- ParentMsg();
+ async ParentMsg();
both:
- BothMsg();
+ async BothMsg();
};
--- a/ipc/ipdl/test/ipdl/ok/union_Namespaced.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/union_Namespaced.ipdl
@@ -7,12 +7,12 @@ union Socks {
} // namespace kitties
namespace puppies {
protocol union_Namespaced {
child:
- Msg(Socks s);
+ async Msg(Socks s);
};
} // namespace puppies
--- a/ipc/testshell/PTestShell.ipdl
+++ b/ipc/testshell/PTestShell.ipdl
@@ -11,17 +11,17 @@ namespace ipc {
async protocol PTestShell
{
manager PContent;
manages PTestShellCommand;
child:
- __delete__();
+ async __delete__();
- ExecuteCommand(nsString aCommand);
+ async ExecuteCommand(nsString aCommand);
- PTestShellCommand(nsString aCommand);
+ async PTestShellCommand(nsString aCommand);
};
} // namespace ipc
} // namespace mozilla
--- a/ipc/testshell/PTestShellCommand.ipdl
+++ b/ipc/testshell/PTestShellCommand.ipdl
@@ -8,13 +8,13 @@ include protocol PTestShell;
namespace mozilla {
namespace ipc {
protocol PTestShellCommand
{
manager PTestShell;
parent:
- __delete__(nsString aResponse);
+ async __delete__(nsString aResponse);
};
} // namespace ipc
} // namespace mozilla
--- a/netwerk/cookie/PCookieService.ipdl
+++ b/netwerk/cookie/PCookieService.ipdl
@@ -97,14 +97,14 @@ parent:
*/
prio(urgent) async SetCookieString(URIParams host,
bool isForeign,
nsCString cookieString,
nsCString serverTime,
bool fromHttp,
SerializedLoadContext loadContext);
- __delete__();
+ async __delete__();
};
}
}
--- a/netwerk/dns/PDNSRequest.ipdl
+++ b/netwerk/dns/PDNSRequest.ipdl
@@ -18,19 +18,19 @@ async protocol PDNSRequest
{
manager PNecko;
parent:
// constructor in PNecko takes AsyncResolve args that initialize request
// Pass args here rather than storing them in the parent; they are only
// needed if the request is to be canceled.
- CancelDNSRequest(nsCString hostName, uint32_t flags,
- nsCString networkInterface, nsresult reason);
- __delete__();
+ async CancelDNSRequest(nsCString hostName, uint32_t flags,
+ nsCString networkInterface, nsresult reason);
+ async __delete__();
child:
- LookupCompleted(DNSRequestResponse reply);
+ async LookupCompleted(DNSRequestResponse reply);
};
} //namespace net
} //namespace mozilla
--- a/netwerk/ipc/PChannelDiverter.ipdl
+++ b/netwerk/ipc/PChannelDiverter.ipdl
@@ -13,13 +13,13 @@ namespace net {
// Used when diverting necko channels from child back to the parent.
// See nsIDivertableChannel.
async protocol PChannelDiverter
{
manager PNecko;
child:
- __delete__();
+ async __delete__();
};
}// namespace net
}// namespace mozilla
--- a/netwerk/ipc/PDataChannel.ipdl
+++ b/netwerk/ipc/PDataChannel.ipdl
@@ -13,13 +13,13 @@ namespace net {
async protocol PDataChannel
{
manager PNecko;
parent:
// Note: channels are opened during construction, so no open method here:
// see PNecko.ipdl
- __delete__();
+ async __delete__();
};
} // namespace net
} // namespace mozilla
--- a/netwerk/ipc/PNecko.ipdl
+++ b/netwerk/ipc/PNecko.ipdl
@@ -53,89 +53,89 @@ prio(normal upto urgent) sync protocol P
manages PDNSRequest;
manages PRemoteOpenFile;
manages PDataChannel;
manages PRtspController;
manages PRtspChannel;
manages PChannelDiverter;
parent:
- __delete__();
+ async __delete__();
prio(urgent) async PCookieService();
- PHttpChannel(PBrowserOrId browser,
- SerializedLoadContext loadContext,
- HttpChannelCreationArgs args);
- PWyciwygChannel();
- PFTPChannel(PBrowserOrId browser, SerializedLoadContext loadContext,
- FTPChannelCreationArgs args);
+ async PHttpChannel(PBrowserOrId browser,
+ SerializedLoadContext loadContext,
+ HttpChannelCreationArgs args);
+ async PWyciwygChannel();
+ async PFTPChannel(PBrowserOrId browser, SerializedLoadContext loadContext,
+ FTPChannelCreationArgs args);
- PWebSocket(PBrowserOrId browser, SerializedLoadContext loadContext,
- uint32_t aSerialID);
- PTCPServerSocket(uint16_t localPort, uint16_t backlog, bool useArrayBuffers);
- PUDPSocket(Principal principal, nsCString filter);
+ async PWebSocket(PBrowserOrId browser, SerializedLoadContext loadContext,
+ uint32_t aSerialID);
+ async PTCPServerSocket(uint16_t localPort, uint16_t backlog, bool useArrayBuffers);
+ async PUDPSocket(Principal principal, nsCString filter);
- PDNSRequest(nsCString hostName, uint32_t flags, nsCString networkInterface);
+ async PDNSRequest(nsCString hostName, uint32_t flags, nsCString networkInterface);
- PWebSocketEventListener(uint64_t aInnerWindowID);
+ async PWebSocketEventListener(uint64_t aInnerWindowID);
/* Predictor Methods */
- PredPredict(OptionalURIParams targetURI, OptionalURIParams sourceURI,
- uint32_t reason, SerializedLoadContext loadContext,
- bool hasVerifier);
- PredLearn(URIParams targetURI, OptionalURIParams sourceURI,
- uint32_t reason, SerializedLoadContext loadContext);
- PredReset();
+ async PredPredict(OptionalURIParams targetURI, OptionalURIParams sourceURI,
+ uint32_t reason, SerializedLoadContext loadContext,
+ bool hasVerifier);
+ async PredLearn(URIParams targetURI, OptionalURIParams sourceURI,
+ uint32_t reason, SerializedLoadContext loadContext);
+ async PredReset();
- PRemoteOpenFile(SerializedLoadContext loadContext,
- URIParams fileuri,
- OptionalURIParams appuri);
+ async PRemoteOpenFile(SerializedLoadContext loadContext,
+ URIParams fileuri,
+ OptionalURIParams appuri);
- SpeculativeConnect(URIParams uri, bool anonymous);
- HTMLDNSPrefetch(nsString hostname, uint16_t flags);
- CancelHTMLDNSPrefetch(nsString hostname, uint16_t flags, nsresult reason);
+ async SpeculativeConnect(URIParams uri, bool anonymous);
+ async HTMLDNSPrefetch(nsString hostname, uint16_t flags);
+ async CancelHTMLDNSPrefetch(nsString hostname, uint16_t flags, nsresult reason);
/**
* channelId is used to establish a connection between redirect channels in
* the parent and the child when we're redirecting to a data: URI.
*/
- PDataChannel(uint32_t channelId);
+ async PDataChannel(uint32_t channelId);
- PRtspController();
- PRtspChannel(RtspChannelConnectArgs args);
- PChannelDiverter(ChannelDiverterArgs channel);
+ async PRtspController();
+ async PRtspChannel(RtspChannelConnectArgs args);
+ async PChannelDiverter(ChannelDiverterArgs channel);
/**
* These are called from the child with the results of the auth prompt.
* callbackId is the id that was passed in PBrowser::AsyncAuthPrompt,
* corresponding to an nsIAuthPromptCallback
*/
- OnAuthAvailable(uint64_t callbackId, nsString user,
- nsString password, nsString domain);
- OnAuthCancelled(uint64_t callbackId, bool userCancel);
+ async OnAuthAvailable(uint64_t callbackId, nsString user,
+ nsString password, nsString domain);
+ async OnAuthCancelled(uint64_t callbackId, bool userCancel);
- RemoveSchedulingContext(nsCString scid);
+ async RemoveSchedulingContext(nsCString scid);
child:
/*
* Bring up the http auth prompt for a nested remote mozbrowser.
* NestedFrameId is the id corresponding to the PBrowser. It is the same id
* that was passed to the PBrowserOrId param in to the PHttpChannel constructor
*/
- AsyncAuthPromptForNestedFrame(TabId nestedFrameId, nsCString uri,
- nsString realm, uint64_t callbackId);
+ async AsyncAuthPromptForNestedFrame(TabId nestedFrameId, nsCString uri,
+ nsString realm, uint64_t callbackId);
// Notifies child that a given app is now offline (or online)
- AppOfflineStatus(uint32_t appId, bool offline);
+ async AppOfflineStatus(uint32_t appId, bool offline);
/* Predictor Methods */
- PredOnPredictPreconnect(URIParams uri);
- PredOnPredictDNS(URIParams uri);
+ async PredOnPredictPreconnect(URIParams uri);
+ async PredOnPredictDNS(URIParams uri);
both:
// Actually we need PTCPSocket() for parent. But ipdl disallows us having different
// signatures on parent and child. So when constructing the parent side object, we just
// leave host/port unused.
- PTCPSocket(nsString host, uint16_t port);
+ async PTCPSocket(nsString host, uint16_t port);
};
} // namespace net
} // namespace mozilla
--- a/netwerk/ipc/PRemoteOpenFile.ipdl
+++ b/netwerk/ipc/PRemoteOpenFile.ipdl
@@ -15,14 +15,14 @@ namespace net {
* the parent instead of the child (since child lacks permission to do so).
*/
protocol PRemoteOpenFile
{
manager PNecko;
child:
// Your file handle is ready, Sir...
- __delete__(FileDescriptor fd);
+ async __delete__(FileDescriptor fd);
};
} // namespace net
} // namespace mozilla
--- a/netwerk/ipc/PRtspChannel.ipdl
+++ b/netwerk/ipc/PRtspChannel.ipdl
@@ -13,13 +13,13 @@ namespace net {
async protocol PRtspChannel
{
manager PNecko;
parent:
// Note: channels are opened during construction, so no open method here:
// see PNecko.ipdl
- __delete__();
+ async __delete__();
};
} // namespace net
} // namespace mozilla
--- a/netwerk/ipc/PRtspController.ipdl
+++ b/netwerk/ipc/PRtspController.ipdl
@@ -32,33 +32,33 @@ struct RtspMetadataParam
RtspMetaValue value;
};
async protocol PRtspController
{
manager PNecko;
parent:
- AsyncOpen(URIParams aURI);
- Play();
- Pause();
- Resume();
- Suspend();
- Seek(uint64_t offset);
- Stop();
- PlaybackEnded();
- __delete__();
+ async AsyncOpen(URIParams aURI);
+ async Play();
+ async Pause();
+ async Resume();
+ async Suspend();
+ async Seek(uint64_t offset);
+ async Stop();
+ async PlaybackEnded();
+ async __delete__();
child:
- OnMediaDataAvailable(uint8_t index,
- nsCString data,
- uint32_t length,
- uint32_t offset,
- RtspMetadataParam[] meta);
- OnConnected(uint8_t index,
- RtspMetadataParam[] meta);
- OnDisconnected(uint8_t index,
- nsresult reason);
- AsyncOpenFailed(nsresult reason);
+ async OnMediaDataAvailable(uint8_t index,
+ nsCString data,
+ uint32_t length,
+ uint32_t offset,
+ RtspMetadataParam[] meta);
+ async OnConnected(uint8_t index,
+ RtspMetadataParam[] meta);
+ async OnDisconnected(uint8_t index,
+ nsresult reason);
+ async AsyncOpenFailed(nsresult reason);
};
} //namespace net
} //namespace mozilla
--- a/netwerk/protocol/ftp/PFTPChannel.ipdl
+++ b/netwerk/protocol/ftp/PFTPChannel.ipdl
@@ -21,52 +21,52 @@ namespace net {
async protocol PFTPChannel
{
manager PNecko;
parent:
// Note: channels are opened during construction, so no open method here:
// see PNecko.ipdl
- __delete__();
+ async __delete__();
- Cancel(nsresult status);
- Suspend();
- Resume();
+ async Cancel(nsresult status);
+ async Suspend();
+ async Resume();
// Divert OnDataAvailable to the parent.
- DivertOnDataAvailable(nsCString data,
- uint64_t offset,
- uint32_t count);
+ async DivertOnDataAvailable(nsCString data,
+ uint64_t offset,
+ uint32_t count);
// Divert OnStopRequest to the parent.
- DivertOnStopRequest(nsresult statusCode);
+ async DivertOnStopRequest(nsresult statusCode);
// Child has no more events/messages to divert to the parent.
- DivertComplete();
+ async DivertComplete();
child:
- OnStartRequest(nsresult aChannelStatus,
- int64_t aContentLength,
- nsCString aContentType,
- PRTime aLastModified,
- nsCString aEntityID,
- URIParams aURI);
- OnDataAvailable(nsresult channelStatus,
- nsCString data,
- uint64_t offset,
- uint32_t count);
- OnStopRequest(nsresult channelStatus);
- FailedAsyncOpen(nsresult statusCode);
+ async OnStartRequest(nsresult aChannelStatus,
+ int64_t aContentLength,
+ nsCString aContentType,
+ PRTime aLastModified,
+ nsCString aEntityID,
+ URIParams aURI);
+ async OnDataAvailable(nsresult channelStatus,
+ nsCString data,
+ uint64_t offset,
+ uint32_t count);
+ async OnStopRequest(nsresult channelStatus);
+ async FailedAsyncOpen(nsresult statusCode);
// Parent has been suspended for diversion; no more events to be enqueued.
- FlushedForDiversion();
+ async FlushedForDiversion();
// Child should resume processing the ChannelEventQueue, i.e. diverting any
// OnDataAvailable and OnStopRequest messages in the queue back to the parent.
- DivertMessages();
+ async DivertMessages();
- DeleteSelf();
+ async DeleteSelf();
};
} // namespace net
} // namespace mozilla
--- a/netwerk/protocol/http/PHttpChannel.ipdl
+++ b/netwerk/protocol/http/PHttpChannel.ipdl
@@ -26,139 +26,139 @@ namespace net {
protocol PHttpChannel
{
manager PNecko;
parent:
// Note: channels are opened during construction, so no open method here:
// see PNecko.ipdl
- SetPriority(uint16_t priority);
- SetClassOfService(uint32_t cos);
+ async SetPriority(uint16_t priority);
+ async SetClassOfService(uint32_t cos);
- SetCacheTokenCachedCharset(nsCString charset);
+ async SetCacheTokenCachedCharset(nsCString charset);
- UpdateAssociatedContentSecurity(int32_t broken,
- int32_t no);
- Suspend();
- Resume();
+ async UpdateAssociatedContentSecurity(int32_t broken,
+ int32_t no);
+ async Suspend();
+ async Resume();
- Cancel(nsresult status);
+ async Cancel(nsresult status);
// Reports approval/veto of redirect by child process redirect observers
- Redirect2Verify(nsresult result, RequestHeaderTuples changedHeaders,
- uint32_t loadFlags, OptionalURIParams apiRedirectTo,
- OptionalCorsPreflightArgs corsPreflightArgs);
+ async Redirect2Verify(nsresult result, RequestHeaderTuples changedHeaders,
+ uint32_t loadFlags, OptionalURIParams apiRedirectTo,
+ OptionalCorsPreflightArgs corsPreflightArgs);
// For document loads we keep this protocol open after child's
// OnStopRequest, and send this msg (instead of __delete__) to allow
// partial cleanup on parent.
- DocumentChannelCleanup();
+ async DocumentChannelCleanup();
// This might have to be sync. If this fails we must fail the document load
// to avoid endless loop.
//
// Explanation: the document loaded was loaded from the offline cache. But
// the cache group id (the manifest URL) of the cache group it was loaded
// from is different then the manifest the document refers to in the html
// tag. If we detect this during the cache selection algorithm, we must not
// load this document from the offline cache group it was just loaded from.
// Marking the cache entry as foreign in its cache group will prevent
// the document to load from the bad offline cache group. After it is marked,
// we reload the document to take the effect. If we fail to mark the entry
// as foreign, we will end up in the same situation and reload again and
// again, indefinitely.
- MarkOfflineCacheEntryAsForeign();
+ async MarkOfflineCacheEntryAsForeign();
// Divert OnDataAvailable to the parent.
- DivertOnDataAvailable(nsCString data,
- uint64_t offset,
- uint32_t count);
+ async DivertOnDataAvailable(nsCString data,
+ uint64_t offset,
+ uint32_t count);
// Divert OnStopRequest to the parent.
- DivertOnStopRequest(nsresult statusCode);
+ async DivertOnStopRequest(nsresult statusCode);
// Child has no more events/messages to divert to the parent.
- DivertComplete();
+ async DivertComplete();
// Child has detected a CORS check failure, so needs to tell the parent
// to remove any matching entry from the CORS preflight cache.
- RemoveCorsPreflightCacheEntry(URIParams uri,
- PrincipalInfo requestingPrincipal);
+ async RemoveCorsPreflightCacheEntry(URIParams uri,
+ PrincipalInfo requestingPrincipal);
- __delete__();
+ async __delete__();
child:
- OnStartRequest(nsresult channelStatus,
- nsHttpResponseHead responseHead,
- bool useResponseHead,
- nsHttpHeaderArray requestHeaders,
- bool isFromCache,
- bool cacheEntryAvailable,
- uint32_t cacheExpirationTime,
- nsCString cachedCharset,
- nsCString securityInfoSerialization,
- NetAddr selfAddr,
- NetAddr peerAddr,
- int16_t redirectCount,
- uint32_t cacheKey);
+ async OnStartRequest(nsresult channelStatus,
+ nsHttpResponseHead responseHead,
+ bool useResponseHead,
+ nsHttpHeaderArray requestHeaders,
+ bool isFromCache,
+ bool cacheEntryAvailable,
+ uint32_t cacheExpirationTime,
+ nsCString cachedCharset,
+ nsCString securityInfoSerialization,
+ NetAddr selfAddr,
+ NetAddr peerAddr,
+ int16_t redirectCount,
+ uint32_t cacheKey);
// Combines a single OnDataAvailable and its associated OnProgress &
// OnStatus calls into one IPDL message
- OnTransportAndData(nsresult channelStatus,
- nsresult transportStatus,
- uint64_t progress,
- uint64_t progressMax,
- nsCString data,
- uint64_t offset,
- uint32_t count);
+ async OnTransportAndData(nsresult channelStatus,
+ nsresult transportStatus,
+ uint64_t progress,
+ uint64_t progressMax,
+ nsCString data,
+ uint64_t offset,
+ uint32_t count);
- OnStopRequest(nsresult channelStatus, ResourceTimingStruct timing);
+ async OnStopRequest(nsresult channelStatus, ResourceTimingStruct timing);
- OnProgress(int64_t progress, int64_t progressMax);
+ async OnProgress(int64_t progress, int64_t progressMax);
- OnStatus(nsresult status);
+ async OnStatus(nsresult status);
// Used to cancel child channel if we hit errors during creating and
// AsyncOpen of nsHttpChannel on the parent.
- FailedAsyncOpen(nsresult status);
+ async FailedAsyncOpen(nsresult status);
// Called to initiate content channel redirect, starts talking to sinks
// on the content process and reports result via Redirect2Verify above
- Redirect1Begin(uint32_t newChannelId,
- URIParams newUri,
- uint32_t redirectFlags,
- nsHttpResponseHead responseHead,
- nsCString securityInfoSerialization);
+ async Redirect1Begin(uint32_t newChannelId,
+ URIParams newUri,
+ uint32_t redirectFlags,
+ nsHttpResponseHead responseHead,
+ nsCString securityInfoSerialization);
// Called if redirect successful so that child can complete setup.
- Redirect3Complete();
+ async Redirect3Complete();
// Associate the child with an application ids
- AssociateApplicationCache(nsCString groupID,
- nsCString clientID);
+ async AssociateApplicationCache(nsCString groupID,
+ nsCString clientID);
// Tell the child that tracking protection was disabled for this load.
- NotifyTrackingProtectionDisabled();
+ async NotifyTrackingProtectionDisabled();
// Parent has been suspended for diversion; no more events to be enqueued.
- FlushedForDiversion();
+ async FlushedForDiversion();
// Child should resume processing the ChannelEventQueue, i.e. diverting any
// OnDataAvailable and OnStopRequest messages in the queue back to the parent.
- DivertMessages();
+ async DivertMessages();
// Report a security message to the console associated with this
// channel.
- ReportSecurityMessage(nsString messageTag, nsString messageCategory);
+ async ReportSecurityMessage(nsString messageTag, nsString messageCategory);
// Tell child to delete channel (all IPDL deletes must be done from child to
// avoid races: see bug 591708).
- DeleteSelf();
+ async DeleteSelf();
// Tell the child to issue a deprecation warning.
- IssueDeprecationWarning(uint32_t warning, bool asError);
+ async IssueDeprecationWarning(uint32_t warning, bool asError);
};
} // namespace net
} // namespace mozilla
--- a/netwerk/protocol/websocket/PWebSocket.ipdl
+++ b/netwerk/protocol/websocket/PWebSocket.ipdl
@@ -19,42 +19,42 @@ namespace mozilla {
namespace net {
async protocol PWebSocket
{
manager PNecko;
parent:
// Forwarded methods corresponding to methods on nsIWebSocketChannel
- AsyncOpen(URIParams aURI,
- nsCString aOrigin,
- uint64_t aInnerWindowID,
- nsCString aProtocol,
- bool aSecure,
- // ping values only meaningful if client set them
- uint32_t aPingInterval,
- bool aClientSetPingInterval,
- uint32_t aPingTimeout,
- bool aClientSetPingTimeout,
- OptionalLoadInfoArgs aLoadInfoArgs);
- Close(uint16_t code, nsCString reason);
- SendMsg(nsCString aMsg);
- SendBinaryMsg(nsCString aMsg);
- SendBinaryStream(InputStreamParams aStream, uint32_t aLength);
+ async AsyncOpen(URIParams aURI,
+ nsCString aOrigin,
+ uint64_t aInnerWindowID,
+ nsCString aProtocol,
+ bool aSecure,
+ // ping values only meaningful if client set them
+ uint32_t aPingInterval,
+ bool aClientSetPingInterval,
+ uint32_t aPingTimeout,
+ bool aClientSetPingTimeout,
+ OptionalLoadInfoArgs aLoadInfoArgs);
+ async Close(uint16_t code, nsCString reason);
+ async SendMsg(nsCString aMsg);
+ async SendBinaryMsg(nsCString aMsg);
+ async SendBinaryStream(InputStreamParams aStream, uint32_t aLength);
- DeleteSelf();
+ async DeleteSelf();
child:
// Forwarded notifications corresponding to the nsIWebSocketListener interface
- OnStart(nsCString aProtocol, nsCString aExtensions,
- nsString aEffectiveURL, bool aEncrypted);
- OnStop(nsresult aStatusCode);
- OnMessageAvailable(nsCString aMsg);
- OnBinaryMessageAvailable(nsCString aMsg);
- OnAcknowledge(uint32_t aSize);
- OnServerClose(uint16_t code, nsCString aReason);
+ async OnStart(nsCString aProtocol, nsCString aExtensions,
+ nsString aEffectiveURL, bool aEncrypted);
+ async OnStop(nsresult aStatusCode);
+ async OnMessageAvailable(nsCString aMsg);
+ async OnBinaryMessageAvailable(nsCString aMsg);
+ async OnAcknowledge(uint32_t aSize);
+ async OnServerClose(uint16_t code, nsCString aReason);
- __delete__();
+ async __delete__();
};
} //namespace net
} //namespace mozilla
--- a/netwerk/protocol/websocket/PWebSocketEventListener.ipdl
+++ b/netwerk/protocol/websocket/PWebSocketEventListener.ipdl
@@ -12,40 +12,40 @@ using mozilla::net::WebSocketFrameData f
namespace mozilla {
namespace net {
async protocol PWebSocketEventListener
{
manager PNecko;
child:
- WebSocketCreated(uint32_t awebSocketSerialID,
- nsString aURI,
- nsCString aProtocols);
+ async WebSocketCreated(uint32_t awebSocketSerialID,
+ nsString aURI,
+ nsCString aProtocols);
- WebSocketOpened(uint32_t awebSocketSerialID,
- nsString aEffectiveURI,
- nsCString aProtocols,
- nsCString aExtensions);
+ async WebSocketOpened(uint32_t awebSocketSerialID,
+ nsString aEffectiveURI,
+ nsCString aProtocols,
+ nsCString aExtensions);
- WebSocketMessageAvailable(uint32_t awebSocketSerialID,
- nsCString aData,
- uint16_t aMessageType);
+ async WebSocketMessageAvailable(uint32_t awebSocketSerialID,
+ nsCString aData,
+ uint16_t aMessageType);
- WebSocketClosed(uint32_t awebSocketSerialID,
- bool aWasClean,
- uint16_t aCode,
- nsString aReason);
+ async WebSocketClosed(uint32_t awebSocketSerialID,
+ bool aWasClean,
+ uint16_t aCode,
+ nsString aReason);
- FrameReceived(uint32_t aWebSocketSerialID,
- WebSocketFrameData aFrameData);
+ async FrameReceived(uint32_t aWebSocketSerialID,
+ WebSocketFrameData aFrameData);
- FrameSent(uint32_t aWebSocketSerialID,
- WebSocketFrameData aFrameData);
+ async FrameSent(uint32_t aWebSocketSerialID,
+ WebSocketFrameData aFrameData);
- __delete__();
+ async __delete__();
parent:
- Close();
+ async Close();
};
} //namespace net
} //namespace mozilla
--- a/netwerk/protocol/wyciwyg/PWyciwygChannel.ipdl
+++ b/netwerk/protocol/wyciwyg/PWyciwygChannel.ipdl
@@ -1,8 +1,10 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 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 PNecko;
include protocol PBrowser;
include URIParams;
include PBackgroundSharedTypes;
@@ -14,46 +16,46 @@ namespace mozilla {
namespace net {
//-------------------------------------------------------------------
protocol PWyciwygChannel
{
manager PNecko;
parent:
- __delete__();
+ async __delete__();
- Init(URIParams uri,
- PrincipalInfo requestingPrincipalInfo,
- PrincipalInfo triggeringPrincipalInfo,
- uint32_t securityFlags,
- uint32_t contentPolicyType);
- AsyncOpen(URIParams originalURI,
- uint32_t loadFlags,
- SerializedLoadContext loadContext,
- PBrowserOrId browser);
- AppData(SerializedLoadContext loadContext, PBrowserOrId browser);
+ async Init(URIParams uri,
+ PrincipalInfo requestingPrincipalInfo,
+ PrincipalInfo triggeringPrincipalInfo,
+ uint32_t securityFlags,
+ uint32_t contentPolicyType);
+ async AsyncOpen(URIParams originalURI,
+ uint32_t loadFlags,
+ SerializedLoadContext loadContext,
+ PBrowserOrId browser);
+ async AppData(SerializedLoadContext loadContext, PBrowserOrId browser);
// methods corresponding to those of nsIWyciwygChannel
- WriteToCacheEntry(nsString data);
- CloseCacheEntry(nsresult reason);
- SetCharsetAndSource(int32_t source, nsCString charset);
- SetSecurityInfo(nsCString securityInfo);
- Cancel(nsresult status);
+ async WriteToCacheEntry(nsString data);
+ async CloseCacheEntry(nsresult reason);
+ async SetCharsetAndSource(int32_t source, nsCString charset);
+ async SetSecurityInfo(nsCString securityInfo);
+ async Cancel(nsresult status);
child:
- OnStartRequest(nsresult statusCode,
- int64_t contentLength,
- int32_t source,
- nsCString charset,
- nsCString securityInfo);
+ async OnStartRequest(nsresult statusCode,
+ int64_t contentLength,
+ int32_t source,
+ nsCString charset,
+ nsCString securityInfo);
- OnDataAvailable(nsCString data,
- uint64_t offset);
+ async OnDataAvailable(nsCString data,
+ uint64_t offset);
- OnStopRequest(nsresult statusCode);
+ async OnStopRequest(nsresult statusCode);
- CancelEarly(nsresult statusCode);
+ async CancelEarly(nsresult statusCode);
};
} // namespace net
} // namespace mozilla
--- a/security/manager/ssl/PPSMContentDownloader.ipdl
+++ b/security/manager/ssl/PPSMContentDownloader.ipdl
@@ -9,20 +9,20 @@ include protocol PChannelDiverter;
namespace mozilla {
namespace psm {
protocol PPSMContentDownloader
{
manager PContent;
parent:
- OnStartRequest(uint32_t contentLength);
- OnDataAvailable(nsCString data, uint64_t offset, uint32_t count);
- OnStopRequest(nsresult code);
+ async OnStartRequest(uint32_t contentLength);
+ async OnDataAvailable(nsCString data, uint64_t offset, uint32_t count);
+ async OnStopRequest(nsresult code);
- DivertToParentUsing(PChannelDiverter diverter);
+ async DivertToParentUsing(PChannelDiverter diverter);
child:
- __delete__();
+ async __delete__();
};
} // namespace psm
} // namespace mozilla
--- a/uriloader/exthandler/PExternalHelperApp.ipdl
+++ b/uriloader/exthandler/PExternalHelperApp.ipdl
@@ -8,22 +8,22 @@ include protocol PChannelDiverter;
namespace mozilla {
namespace dom {
protocol PExternalHelperApp
{
manager PContent;
parent:
- OnStartRequest(nsCString entityID);
- OnDataAvailable(nsCString data, uint64_t offset, uint32_t count);
- OnStopRequest(nsresult code);
+ async OnStartRequest(nsCString entityID);
+ async OnDataAvailable(nsCString data, uint64_t offset, uint32_t count);
+ async OnStopRequest(nsresult code);
- DivertToParentUsing(PChannelDiverter diverter);
+ async DivertToParentUsing(PChannelDiverter diverter);
child:
- Cancel(nsresult aStatus);
- __delete__();
+ async Cancel(nsresult aStatus);
+ async __delete__();
};
} // namespace dom
} // namespace mozilla
--- a/uriloader/exthandler/PHandlerService.ipdl
+++ b/uriloader/exthandler/PHandlerService.ipdl
@@ -29,14 +29,14 @@ sync protocol PHandlerService
parent:
sync FillHandlerInfo(HandlerInfo aHandlerInfoData,
nsCString aOverrideType)
returns (HandlerInfo handlerInfoData);
sync Exists(HandlerInfo aHandlerInfo)
returns (bool exists);
sync GetTypeFromExtension(nsCString aFileExtension)
returns (nsCString type);
- __delete__();
+ async __delete__();
};
} // namespace dom
} // namespace mozilla
--- a/uriloader/prefetch/POfflineCacheUpdate.ipdl
+++ b/uriloader/prefetch/POfflineCacheUpdate.ipdl
@@ -11,18 +11,18 @@ namespace mozilla {
namespace docshell {
//-------------------------------------------------------------------
protocol POfflineCacheUpdate
{
manager PContent;
parent:
- __delete__();
+ async __delete__();
child:
- NotifyStateEvent(uint32_t stateEvent, uint64_t byteProgress);
- AssociateDocuments(nsCString cacheGroupId, nsCString cacheClientId);
- Finish(bool succeeded, bool isUpgrade);
+ async NotifyStateEvent(uint32_t stateEvent, uint64_t byteProgress);
+ async AssociateDocuments(nsCString cacheGroupId, nsCString cacheClientId);
+ async Finish(bool succeeded, bool isUpgrade);
};
}
}