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 305242 b04361fcbafcb20cfab95999b6a7b37633dd3bc7
parent 305241 7ce66c0b2720e167ca1954aa61a303075354eb04
child 305243 76517f16771db1e293f2fc781eda6fba4d20f062
push id9214
push userraliiev@mozilla.com
push dateMon, 07 Mar 2016 14:25:21 +0000
treeherdermozilla-aurora@8849dd1a4a79 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmccr8, billm
bugs1240871
milestone47.0a1
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);
 };
 
 }
 }