Bug 1240871 - Don't allow implicit "async" in IPDL (r=mccr8,billm)
authorBill McCloskey <billm@mozilla.com>
Tue, 26 Jan 2016 13:51:53 -0800
changeset 320508 b04361fcbafcb20cfab95999b6a7b37633dd3bc7
parent 320507 7ce66c0b2720e167ca1954aa61a303075354eb04
child 320509 76517f16771db1e293f2fc781eda6fba4d20f062
push id1128
push userjlund@mozilla.com
push dateWed, 01 Jun 2016 01:31:59 +0000
treeherdermozilla-release@fe0d30de989d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmccr8, billm
bugs1240871
milestone47.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1240871 - Don't allow implicit "async" in IPDL (r=mccr8,billm)
accessible/ipc/PDocAccessible.ipdl
devtools/shared/heapsnapshot/PHeapSnapshotTempFileHelper.ipdl
dom/asmjscache/PAsmJSCacheEntry.ipdl
dom/bluetooth/ipc/PBluetooth.ipdl
dom/bluetooth/ipc/PBluetoothRequest.ipdl
dom/broadcastchannel/PBroadcastChannel.ipdl
dom/cache/PCache.ipdl
dom/cache/PCacheOp.ipdl
dom/cache/PCachePushStream.ipdl
dom/cache/PCacheStorage.ipdl
dom/cache/PCacheStreamControl.ipdl
dom/cellbroadcast/ipc/PCellBroadcast.ipdl
dom/devicestorage/PDeviceStorageRequest.ipdl
dom/filehandle/PBackgroundFileHandle.ipdl
dom/filehandle/PBackgroundFileRequest.ipdl
dom/filehandle/PBackgroundMutableFile.ipdl
dom/filesystem/PFileSystemRequest.ipdl
dom/fmradio/ipc/PFMRadio.ipdl
dom/fmradio/ipc/PFMRadioRequest.ipdl
dom/icc/ipc/PIcc.ipdl
dom/icc/ipc/PIccRequest.ipdl
dom/indexedDB/PBackgroundIDBCursor.ipdl
dom/indexedDB/PBackgroundIDBDatabase.ipdl
dom/indexedDB/PBackgroundIDBDatabaseFile.ipdl
dom/indexedDB/PBackgroundIDBDatabaseRequest.ipdl
dom/indexedDB/PBackgroundIDBFactory.ipdl
dom/indexedDB/PBackgroundIDBFactoryRequest.ipdl
dom/indexedDB/PBackgroundIDBRequest.ipdl
dom/indexedDB/PBackgroundIDBTransaction.ipdl
dom/indexedDB/PBackgroundIDBVersionChangeTransaction.ipdl
dom/indexedDB/PBackgroundIndexedDBUtils.ipdl
dom/indexedDB/PIndexedDBPermissionRequest.ipdl
dom/ipc/PBlob.ipdl
dom/ipc/PBlobStream.ipdl
dom/ipc/PBrowser.ipdl
dom/ipc/PColorPicker.ipdl
dom/ipc/PContent.ipdl
dom/ipc/PContentBridge.ipdl
dom/ipc/PContentDialog.ipdl
dom/ipc/PContentPermissionRequest.ipdl
dom/ipc/PCrashReporter.ipdl
dom/ipc/PCycleCollectWithLogs.ipdl
dom/ipc/PDocumentRenderer.ipdl
dom/ipc/PFilePicker.ipdl
dom/ipc/PMemoryReportRequest.ipdl
dom/ipc/PScreenManager.ipdl
dom/media/gmp/PGMPAudioDecoder.ipdl
dom/media/gmp/PGMPDecryptor.ipdl
dom/media/gmp/PGMPStorage.ipdl
dom/media/gmp/PGMPTimer.ipdl
dom/media/systemservices/PMedia.ipdl
dom/media/webrtc/PWebrtcGlobal.ipdl
dom/media/webspeech/synth/ipc/PSpeechSynthesis.ipdl
dom/media/webspeech/synth/ipc/PSpeechSynthesisRequest.ipdl
dom/messagechannel/PMessagePort.ipdl
dom/mobileconnection/ipc/PMobileConnection.ipdl
dom/mobileconnection/ipc/PMobileConnectionRequest.ipdl
dom/mobilemessage/ipc/PMobileMessageCursor.ipdl
dom/mobilemessage/ipc/PSms.ipdl
dom/mobilemessage/ipc/PSmsRequest.ipdl
dom/network/PTCPServerSocket.ipdl
dom/network/PTCPSocket.ipdl
dom/network/PUDPSocket.ipdl
dom/plugins/ipc/PPluginBackgroundDestroyer.ipdl
dom/presentation/ipc/PPresentation.ipdl
dom/presentation/ipc/PPresentationRequest.ipdl
dom/quota/PQuota.ipdl
dom/quota/PQuotaRequest.ipdl
dom/quota/PQuotaUsageRequest.ipdl
dom/telephony/ipc/PTelephony.ipdl
dom/telephony/ipc/PTelephonyRequest.ipdl
dom/voicemail/ipc/PVoicemail.ipdl
dom/workers/PServiceWorkerManager.ipdl
embedding/components/printingui/ipc/PPrintProgressDialog.ipdl
embedding/components/printingui/ipc/PPrintSettingsDialog.ipdl
embedding/components/printingui/ipc/PPrinting.ipdl
embedding/components/webbrowserpersist/PWebBrowserPersistDocument.ipdl
embedding/components/webbrowserpersist/PWebBrowserPersistResources.ipdl
embedding/components/webbrowserpersist/PWebBrowserPersistSerialize.ipdl
extensions/spellcheck/hunspell/glue/PRemoteSpellcheckEngine.ipdl
hal/sandbox/PHal.ipdl
ipc/glue/PBackground.ipdl
ipc/glue/PBackgroundTest.ipdl
ipc/glue/PFileDescriptorSet.ipdl
ipc/ipdl/ipdl/parser.py
ipc/ipdl/test/cxx/PTestActorPunning.ipdl
ipc/ipdl/test/cxx/PTestActorPunningPunned.ipdl
ipc/ipdl/test/cxx/PTestActorPunningSub.ipdl
ipc/ipdl/test/cxx/PTestBadActor.ipdl
ipc/ipdl/test/cxx/PTestBadActorSub.ipdl
ipc/ipdl/test/cxx/PTestBridgeMain.ipdl
ipc/ipdl/test/cxx/PTestBridgeMainSub.ipdl
ipc/ipdl/test/cxx/PTestBridgeSub.ipdl
ipc/ipdl/test/cxx/PTestCrashCleanup.ipdl
ipc/ipdl/test/cxx/PTestDataStructures.ipdl
ipc/ipdl/test/cxx/PTestDesc.ipdl
ipc/ipdl/test/cxx/PTestDescSub.ipdl
ipc/ipdl/test/cxx/PTestEndpointBridgeMain.ipdl
ipc/ipdl/test/cxx/PTestEndpointBridgeMainSub.ipdl
ipc/ipdl/test/cxx/PTestEndpointBridgeSub.ipdl
ipc/ipdl/test/cxx/PTestEndpointOpens.ipdl
ipc/ipdl/test/cxx/PTestEndpointOpensOpened.ipdl
ipc/ipdl/test/cxx/PTestFailedCtor.ipdl
ipc/ipdl/test/cxx/PTestFailedCtorSub.ipdl
ipc/ipdl/test/cxx/PTestFailedCtorSubsub.ipdl
ipc/ipdl/test/cxx/PTestHandle.ipdl
ipc/ipdl/test/cxx/PTestHangs.ipdl
ipc/ipdl/test/cxx/PTestIndirectProtocolParamFirst.ipdl
ipc/ipdl/test/cxx/PTestIndirectProtocolParamManage.ipdl
ipc/ipdl/test/cxx/PTestIndirectProtocolParamSecond.ipdl
ipc/ipdl/test/cxx/PTestInterruptRaces.ipdl
ipc/ipdl/test/cxx/PTestLatency.ipdl
ipc/ipdl/test/cxx/PTestManyChildAllocs.ipdl
ipc/ipdl/test/cxx/PTestManyChildAllocsSub.ipdl
ipc/ipdl/test/cxx/PTestMultiMgrs.ipdl
ipc/ipdl/test/cxx/PTestMultiMgrsBottom.ipdl
ipc/ipdl/test/cxx/PTestMultiMgrsLeft.ipdl
ipc/ipdl/test/cxx/PTestMultiMgrsRight.ipdl
ipc/ipdl/test/cxx/PTestNestedLoops.ipdl
ipc/ipdl/test/cxx/PTestOpens.ipdl
ipc/ipdl/test/cxx/PTestOpensOpened.ipdl
ipc/ipdl/test/cxx/PTestRacyReentry.ipdl
ipc/ipdl/test/cxx/PTestSanity.ipdl
ipc/ipdl/test/cxx/PTestSelfManage.ipdl
ipc/ipdl/test/cxx/PTestSelfManageRoot.ipdl
ipc/ipdl/test/cxx/PTestShmem.ipdl
ipc/ipdl/test/cxx/PTestShutdown.ipdl
ipc/ipdl/test/cxx/PTestShutdownSub.ipdl
ipc/ipdl/test/cxx/PTestStackHooks.ipdl
ipc/ipdl/test/cxx/PTestSyncError.ipdl
ipc/ipdl/test/cxx/PTestSyncHang.ipdl
ipc/ipdl/test/cxx/PTestSysVShmem.ipdl
ipc/ipdl/test/ipdl/error/DeleteRace.ipdl
ipc/ipdl/test/ipdl/error/Nullable.ipdl
ipc/ipdl/test/ipdl/error/Nullable2.ipdl
ipc/ipdl/test/ipdl/error/actorparam_badState.ipdl
ipc/ipdl/test/ipdl/error/bridgesSubprotocol.ipdl
ipc/ipdl/test/ipdl/error/cyclecheck_Child.ipdl
ipc/ipdl/test/ipdl/error/cyclecheck_Grandchild.ipdl
ipc/ipdl/test/ipdl/error/cyclecheck_Parent.ipdl
ipc/ipdl/test/ipdl/error/manageSelfToplevel.ipdl
ipc/ipdl/test/ipdl/error/messageNoDirection.ipdl
ipc/ipdl/test/ipdl/error/multimanDupMgrs.ipdl
ipc/ipdl/test/ipdl/error/multimanDupMgrsMgr.ipdl
ipc/ipdl/test/ipdl/error/multimanNonexistentMgrs.ipdl
ipc/ipdl/test/ipdl/error/mutualRecStruct.ipdl
ipc/ipdl/test/ipdl/error/mutualRecStructUnion.ipdl
ipc/ipdl/test/ipdl/error/opensSubprotocol.ipdl
ipc/ipdl/test/ipdl/error/race_OverlappingMultiOut.ipdl
ipc/ipdl/test/ipdl/error/race_ViolateSameDirection.ipdl
ipc/ipdl/test/ipdl/error/redeclMessage.ipdl
ipc/ipdl/test/ipdl/error/redefState.ipdl
ipc/ipdl/test/ipdl/error/shmem_access_union.ipdl
ipc/ipdl/test/ipdl/error/spawnsSubprotocol.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongDirection.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongDirection2.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongDirection3.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongDirection4.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongDirection5.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongName.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongName2.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongName3.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongName4.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongName5.ipdl
ipc/ipdl/test/ipdl/error/unreachedDeleteMultiStart.ipdl
ipc/ipdl/test/ipdl/ok/Delete.ipdl
ipc/ipdl/test/ipdl/ok/Nullable.ipdl
ipc/ipdl/test/ipdl/ok/Struct.ipdl
ipc/ipdl/test/ipdl/ok/actorparam_state.ipdl
ipc/ipdl/test/ipdl/ok/array_Basic.ipdl
ipc/ipdl/test/ipdl/ok/array_OfActors.ipdl
ipc/ipdl/test/ipdl/ok/compositor.ipdl
ipc/ipdl/test/ipdl/ok/content.ipdl
ipc/ipdl/test/ipdl/ok/headerProto.ipdl
ipc/ipdl/test/ipdl/ok/intrProtocol.ipdl
ipc/ipdl/test/ipdl/ok/jetpack.ipdl
ipc/ipdl/test/ipdl/ok/jetpackContent.ipdl
ipc/ipdl/test/ipdl/ok/manageSelf.ipdl
ipc/ipdl/test/ipdl/ok/manageSelf_Toplevel.ipdl
ipc/ipdl/test/ipdl/ok/managedProtocol.ipdl
ipc/ipdl/test/ipdl/ok/media.ipdl
ipc/ipdl/test/ipdl/ok/multiManaged.ipdl
ipc/ipdl/test/ipdl/ok/multipleUsingCxxTypes.ipdl
ipc/ipdl/test/ipdl/ok/mutualRecStructUnion.ipdl
ipc/ipdl/test/ipdl/ok/mutualRecUnion.ipdl
ipc/ipdl/test/ipdl/ok/namespace_Basic.ipdl
ipc/ipdl/test/ipdl/ok/noRedeclCrossMessage.ipdl
ipc/ipdl/test/ipdl/ok/plugin.ipdl
ipc/ipdl/test/ipdl/ok/race_DiamondRule1.ipdl
ipc/ipdl/test/ipdl/ok/race_KitchenSink.ipdl
ipc/ipdl/test/ipdl/ok/race_MultiOut.ipdl
ipc/ipdl/test/ipdl/ok/race_Stateless.ipdl
ipc/ipdl/test/ipdl/ok/selfRecUnion.ipdl
ipc/ipdl/test/ipdl/ok/shmem.ipdl
ipc/ipdl/test/ipdl/ok/syncProtocol.ipdl
ipc/ipdl/test/ipdl/ok/threeDirections.ipdl
ipc/ipdl/test/ipdl/ok/union_Namespaced.ipdl
ipc/testshell/PTestShell.ipdl
ipc/testshell/PTestShellCommand.ipdl
netwerk/cookie/PCookieService.ipdl
netwerk/dns/PDNSRequest.ipdl
netwerk/ipc/PChannelDiverter.ipdl
netwerk/ipc/PDataChannel.ipdl
netwerk/ipc/PNecko.ipdl
netwerk/ipc/PRemoteOpenFile.ipdl
netwerk/ipc/PRtspChannel.ipdl
netwerk/ipc/PRtspController.ipdl
netwerk/protocol/ftp/PFTPChannel.ipdl
netwerk/protocol/http/PHttpChannel.ipdl
netwerk/protocol/websocket/PWebSocket.ipdl
netwerk/protocol/websocket/PWebSocketEventListener.ipdl
netwerk/protocol/wyciwyg/PWyciwygChannel.ipdl
security/manager/ssl/PPSMContentDownloader.ipdl
uriloader/exthandler/PExternalHelperApp.ipdl
uriloader/exthandler/PHandlerService.ipdl
uriloader/prefetch/POfflineCacheUpdate.ipdl
--- 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);
 };
 
 }
 }