Rename IPDL's RPC to Interrupt (bug 910020, r=bent).
authorDavid Anderson <danderson@mozilla.com>
Mon, 30 Sep 2013 17:27:45 -0700
changeset 163210 2466893f18a72c83e618c9a30c3e8f13f5bfd707
parent 163209 f4708377f7884aa8204a04153ba3f4ee5936aba2
child 163211 571e97a6ae5442bad4cd2fffd5d0eebaad33e01a
push id3066
push userakeybl@mozilla.com
push dateMon, 09 Dec 2013 19:58:46 +0000
treeherdermozilla-beta@a31a0dce83aa [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbent
bugs910020
milestone27.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Rename IPDL's RPC to Interrupt (bug 910020, r=bent).
content/media/webspeech/synth/ipc/PSpeechSynthesis.ipdl
content/media/webspeech/synth/ipc/PSpeechSynthesisRequest.ipdl
dom/ipc/PBrowser.ipdl
dom/ipc/PContent.ipdl
dom/ipc/PCrashReporter.ipdl
dom/plugins/ipc/COMMessageFilter.cpp
dom/plugins/ipc/PBrowserStream.ipdl
dom/plugins/ipc/PPluginInstance.ipdl
dom/plugins/ipc/PPluginModule.ipdl
dom/plugins/ipc/PPluginScriptableObject.ipdl
dom/plugins/ipc/PPluginStream.ipdl
dom/plugins/ipc/PStreamNotify.ipdl
dom/plugins/ipc/PluginMessageUtils.cpp
dom/plugins/ipc/PluginMessageUtils.h
dom/plugins/ipc/PluginModuleChild.cpp
dom/plugins/ipc/PluginModuleChild.h
dom/plugins/ipc/PluginModuleParent.cpp
dom/plugins/ipc/PluginModuleParent.h
gfx/layers/ipc/PCompositor.ipdl
gfx/layers/ipc/PImageBridge.ipdl
ipc/chromium/src/chrome/common/ipc_message.cc
ipc/chromium/src/chrome/common/ipc_message.h
ipc/glue/MessageChannel.cpp
ipc/glue/MessageChannel.h
ipc/glue/MessageLink.h
ipc/glue/WindowsMessageLoop.cpp
ipc/ipdl/ipdl/ast.py
ipc/ipdl/ipdl/cgen.py
ipc/ipdl/ipdl/lower.py
ipc/ipdl/ipdl/parser.py
ipc/ipdl/ipdl/type.py
ipc/ipdl/test/cxx/Makefile.in
ipc/ipdl/test/cxx/PTestBadActor.ipdl
ipc/ipdl/test/cxx/PTestBadActorSub.ipdl
ipc/ipdl/test/cxx/PTestBridgeMainSub.ipdl
ipc/ipdl/test/cxx/PTestCrashCleanup.ipdl
ipc/ipdl/test/cxx/PTestDesc.ipdl
ipc/ipdl/test/cxx/PTestDescSub.ipdl
ipc/ipdl/test/cxx/PTestDescSubsub.ipdl
ipc/ipdl/test/cxx/PTestFailedCtor.ipdl
ipc/ipdl/test/cxx/PTestFailedCtorSub.ipdl
ipc/ipdl/test/cxx/PTestFailedCtorSubsub.ipdl
ipc/ipdl/test/cxx/PTestHangs.ipdl
ipc/ipdl/test/cxx/PTestInterruptErrorCleanup.ipdl
ipc/ipdl/test/cxx/PTestInterruptRaces.ipdl
ipc/ipdl/test/cxx/PTestInterruptShutdownRace.ipdl
ipc/ipdl/test/cxx/PTestLatency.ipdl
ipc/ipdl/test/cxx/PTestNestedLoops.ipdl
ipc/ipdl/test/cxx/PTestOpensOpened.ipdl
ipc/ipdl/test/cxx/PTestRPCErrorCleanup.ipdl
ipc/ipdl/test/cxx/PTestRPCRaces.ipdl
ipc/ipdl/test/cxx/PTestRPCShutdownRace.ipdl
ipc/ipdl/test/cxx/PTestRaceDeferral.ipdl
ipc/ipdl/test/cxx/PTestRacyInterruptReplies.ipdl
ipc/ipdl/test/cxx/PTestRacyRPCReplies.ipdl
ipc/ipdl/test/cxx/PTestRacyReentry.ipdl
ipc/ipdl/test/cxx/PTestRacyUndefer.ipdl
ipc/ipdl/test/cxx/PTestShutdown.ipdl
ipc/ipdl/test/cxx/PTestShutdownSub.ipdl
ipc/ipdl/test/cxx/PTestStackHooks.ipdl
ipc/ipdl/test/cxx/PTestSyncWakeup.ipdl
ipc/ipdl/test/cxx/PTestUrgency.ipdl
ipc/ipdl/test/cxx/TestInterruptErrorCleanup.cpp
ipc/ipdl/test/cxx/TestInterruptErrorCleanup.h
ipc/ipdl/test/cxx/TestInterruptRaces.cpp
ipc/ipdl/test/cxx/TestInterruptRaces.h
ipc/ipdl/test/cxx/TestInterruptShutdownRace.cpp
ipc/ipdl/test/cxx/TestInterruptShutdownRace.h
ipc/ipdl/test/cxx/TestRPCErrorCleanup.cpp
ipc/ipdl/test/cxx/TestRPCErrorCleanup.h
ipc/ipdl/test/cxx/TestRPCRaces.cpp
ipc/ipdl/test/cxx/TestRPCRaces.h
ipc/ipdl/test/cxx/TestRPCShutdownRace.cpp
ipc/ipdl/test/cxx/TestRPCShutdownRace.h
ipc/ipdl/test/cxx/TestRaceDeferral.cpp
ipc/ipdl/test/cxx/TestRaceDeferral.h
ipc/ipdl/test/cxx/TestRacyInterruptReplies.cpp
ipc/ipdl/test/cxx/TestRacyInterruptReplies.h
ipc/ipdl/test/cxx/TestRacyRPCReplies.cpp
ipc/ipdl/test/cxx/TestRacyRPCReplies.h
ipc/ipdl/test/cxx/moz.build
ipc/ipdl/test/ipdl/error/compressCtor.ipdl
ipc/ipdl/test/ipdl/error/compressCtorManagee.ipdl
ipc/ipdl/test/ipdl/error/intrMessageCompress.ipdl
ipc/ipdl/test/ipdl/error/rpcMessageCompress.ipdl
ipc/ipdl/test/ipdl/error/syncParentToChild.ipdl
ipc/ipdl/test/ipdl/error/tooWeakInterruptAsync.ipdl
ipc/ipdl/test/ipdl/error/tooWeakRPCAsync.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongDirection4.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongDirection5.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongName4.ipdl
ipc/ipdl/test/ipdl/error/trans_WrongName5.ipdl
ipc/ipdl/test/ipdl/ok/intrProtocol.ipdl
ipc/ipdl/test/ipdl/ok/jetpackContent.ipdl
ipc/ipdl/test/ipdl/ok/messageCompress.ipdl
ipc/ipdl/test/ipdl/ok/plugin.ipdl
ipc/ipdl/test/ipdl/ok/rpcProtocol.ipdl
ipc/ipdl/test/ipdl/ok/shmem.ipdl
ipc/testshell/PTestShell.ipdl
js/ipc/PJavaScript.ipdl
--- a/content/media/webspeech/synth/ipc/PSpeechSynthesis.ipdl
+++ b/content/media/webspeech/synth/ipc/PSpeechSynthesis.ipdl
@@ -12,17 +12,17 @@ namespace dom {
 
 struct RemoteVoice {
   nsString voiceURI;
   nsString name;
   nsString lang;
   bool localService;
 };
 
-rpc protocol PSpeechSynthesis
+intr protocol PSpeechSynthesis
 {
   manager PContent;
   manages PSpeechSynthesisRequest;
 
 child:
 
     VoiceAdded(RemoteVoice aVoice);
 
--- a/content/media/webspeech/synth/ipc/PSpeechSynthesisRequest.ipdl
+++ b/content/media/webspeech/synth/ipc/PSpeechSynthesisRequest.ipdl
@@ -4,17 +4,17 @@
  * 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 PSpeechSynthesis;
 
 namespace mozilla {
 namespace dom {
 
-rpc protocol PSpeechSynthesisRequest
+intr protocol PSpeechSynthesisRequest
 {
   manager PSpeechSynthesis;
 
  parent:
 
   Pause();
 
   Resume();
--- a/dom/ipc/PBrowser.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -53,17 +53,17 @@ using mozilla::WidgetTouchEvent;
 using RemoteDOMEvent;
 using mozilla::dom::ScreenOrientation;
 using mozilla::layers::TextureFactoryIdentifier;
 using mozilla::CSSIntPoint;
 using mozilla::CSSToScreenScale;
 namespace mozilla {
 namespace dom {
 
-rpc protocol PBrowser
+intr protocol PBrowser
 {
     manager PContent;
 
     manages PContentDialog;
     manages PDocumentRenderer;
     manages PContentPermissionRequest;
     manages PRenderFrame;
     manages POfflineCacheUpdate;
@@ -76,17 +76,17 @@ parent:
     /**
      * When child sends this message, parent should move focus to
      * the next or previous focusable element.
      */
     MoveFocus(bool forward);
 
     Event(RemoteDOMEvent aEvent);
 
-    rpc CreateWindow() returns (PBrowser window);
+    intr CreateWindow() returns (PBrowser window);
 
     sync SyncMessage(nsString aMessage, ClonedMessageData aData, CpowEntry[] aCpows)
       returns (nsString[] retval);
 
     /**
      * The IME sequence number (seqno) parameter is used to make sure
      * that a notification is discarded if it arrives at the chrome process
      * too late. If the notification is late and we accept it, we will have
--- a/dom/ipc/PContent.ipdl
+++ b/dom/ipc/PContent.ipdl
@@ -176,17 +176,17 @@ union MaybePrefValue {
 };
 
 struct PrefSetting {
   nsCString name;
   MaybePrefValue defaultValue;
   MaybePrefValue userValue;
 };
 
-rpc protocol PContent
+intr protocol PContent
 {
     parent opens PCompositor;
     parent opens PImageBridge;
 
     manages PBlob;
     manages PBluetooth;
     manages PBrowser;
     manages PCrashReporter;
--- a/dom/ipc/PCrashReporter.ipdl
+++ b/dom/ipc/PCrashReporter.ipdl
@@ -13,17 +13,17 @@ namespace dom {
 struct Mapping {
   nsCString library_name;
   nsCString file_id;
   uintptr_t start_address;
   size_t mapping_length;
   size_t file_offset;
 };
 
-protocol PCrashReporter {
+intr protocol PCrashReporter {
   manager PContent or PPluginModule;
 parent:
   AnnotateCrashReport(nsCString key, nsCString data);
   AppendAppNotes(nsCString data);
   __delete__();
 };
 
 }
--- a/dom/plugins/ipc/COMMessageFilter.cpp
+++ b/dom/plugins/ipc/COMMessageFilter.cpp
@@ -61,17 +61,17 @@ COMMessageFilter::RetryRejectedCall(HTAS
   return -1;
 }
 
 DWORD
 COMMessageFilter::MessagePending(HTASK htaskCallee,
 				 DWORD dwTickCount,
 				 DWORD dwPendingType)
 {
-  mPlugin->FlushPendingRPCQueue();
+  mPlugin->FlushPendingInterruptQueue();
   if (mPreviousFilter)
     return mPreviousFilter->MessagePending(htaskCallee, dwTickCount,
 					   dwPendingType);
   return PENDINGMSG_WAITNOPROCESS;
 }
 
 void
 COMMessageFilter::Initialize(PluginModuleChild* module)
--- a/dom/plugins/ipc/PBrowserStream.ipdl
+++ b/dom/plugins/ipc/PBrowserStream.ipdl
@@ -15,34 +15,34 @@ using NPReason;
 
 namespace mozilla {
 namespace plugins {
 
 /**
  * NPBrowserStream represents a NPStream sent from the browser to the plugin.
  */
 
-rpc protocol PBrowserStream
+intr protocol PBrowserStream
 {
   manager PPluginInstance;
 
 child:
   async Write(int32_t offset, Buffer data,
               uint32_t newlength);
   async NPP_StreamAsFile(nsCString fname);
 
   /**
    * NPP_DestroyStream may race with other messages: the child acknowledges
    * the message with StreamDestroyed before this actor is deleted.
    */
   async NPP_DestroyStream(NPReason reason);
   async __delete__();
 
 parent:
-  rpc NPN_RequestRead(IPCByteRanges ranges)
+  intr NPN_RequestRead(IPCByteRanges ranges)
     returns (NPError result);
   async NPN_DestroyStream(NPReason reason);
   async StreamDestroyed();
 
 /*
   TODO: turn on state machine.
 
   // need configurable start state: if the constructor
--- a/dom/plugins/ipc/PPluginInstance.ipdl
+++ b/dom/plugins/ipc/PPluginInstance.ipdl
@@ -71,56 +71,56 @@ struct NPRemoteAsyncSurface
   uint32_t version;
   gfxIntSize size;
   NPImageFormat format;
   uint32_t      stride;
   AsyncSurfaceDescriptor data;
   uintptr_t hostPtr;
 };
 
-rpc protocol PPluginInstance
+intr protocol PPluginInstance
 {
   manager PPluginModule;
 
   manages PPluginBackgroundDestroyer;
   manages PPluginScriptableObject;
   manages PBrowserStream;
   manages PPluginStream;
   manages PStreamNotify;
   manages PPluginSurface;
 
 child:
-  rpc __delete__();
+  intr __delete__();
 
-  rpc NPP_SetWindow(NPRemoteWindow window);
+  intr NPP_SetWindow(NPRemoteWindow window);
 
-  rpc NPP_GetValue_NPPVpluginWantsAllNetworkStreams()
+  intr NPP_GetValue_NPPVpluginWantsAllNetworkStreams()
     returns (bool value, NPError result);
 
   // this message is not used on non-X platforms
-  rpc NPP_GetValue_NPPVpluginNeedsXEmbed()
+  intr NPP_GetValue_NPPVpluginNeedsXEmbed()
     returns (bool value, NPError result);
 
-  rpc NPP_GetValue_NPPVpluginScriptableNPObject()
+  intr NPP_GetValue_NPPVpluginScriptableNPObject()
     returns (nullable PPluginScriptableObject value, NPError result);
 
-  rpc NPP_SetValue_NPNVprivateModeBool(bool value) returns (NPError result);
-  rpc NPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId()
+  intr NPP_SetValue_NPNVprivateModeBool(bool value) returns (NPError result);
+  intr NPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId()
     returns (nsCString plug_id, NPError result);
 
-  rpc NPP_HandleEvent(NPRemoteEvent event)
+  intr NPP_HandleEvent(NPRemoteEvent event)
     returns (int16_t handled);
   // special cases where we need to a shared memory buffer
-  rpc NPP_HandleEvent_Shmem(NPRemoteEvent event, Shmem buffer)
+  intr NPP_HandleEvent_Shmem(NPRemoteEvent event, Shmem buffer)
     returns (int16_t handled, Shmem rtnbuffer);
   // special cases where we need an iosurface
-  rpc NPP_HandleEvent_IOSurface(NPRemoteEvent event, uint32_t surfaceid)
+  intr NPP_HandleEvent_IOSurface(NPRemoteEvent event, uint32_t surfaceid)
     returns (int16_t handled);
   // special cases of HandleEvent to make mediating races simpler
-  rpc Paint(NPRemoteEvent event)
+  intr Paint(NPRemoteEvent event)
     returns (int16_t handled);
   // this is only used on windows to forward WM_WINDOWPOSCHANGE
   async WindowPosChanged(NPRemoteEvent event);
   // used on OS X to tell the child the contents scale factor
   // of its parent has changed
   async ContentsScaleFactorChanged(double aContentsScaleFactor);
 
   // ********************** Async plugins rendering
@@ -137,55 +137,55 @@ child:
   // background was updated).  The changed area is |rect|.  The
   // browser owns the background surface, and it's read-only from
   // within the plugin process.  |background| is either null_t to
   // refer to the existing background or a fresh descriptor.
   async UpdateBackground(SurfaceDescriptor background, nsIntRect rect);
 
   async NPP_DidComposite();
 
-  rpc NPP_Destroy()
+  intr NPP_Destroy()
     returns (NPError rv);
 
 parent:
-  rpc NPN_GetValue_NPNVWindowNPObject()
+  intr NPN_GetValue_NPNVWindowNPObject()
     returns (nullable PPluginScriptableObject value, NPError result);
-  rpc NPN_GetValue_NPNVPluginElementNPObject()
+  intr NPN_GetValue_NPNVPluginElementNPObject()
     returns (nullable PPluginScriptableObject value, NPError result);
-  rpc NPN_GetValue_NPNVprivateModeBool()
+  intr NPN_GetValue_NPNVprivateModeBool()
     returns (bool value, NPError result);
-  rpc NPN_GetValue_NPNVnetscapeWindow()
+  intr NPN_GetValue_NPNVnetscapeWindow()
     returns (NativeWindowHandle value, NPError result);
-  rpc NPN_GetValue_NPNVdocumentOrigin()
+  intr NPN_GetValue_NPNVdocumentOrigin()
     returns (nsCString value, NPError result);
-  rpc NPN_GetValue_DrawingModelSupport(NPNVariable model)
+  intr NPN_GetValue_DrawingModelSupport(NPNVariable model)
     returns (bool value);
 
-  rpc NPN_SetValue_NPPVpluginWindow(bool windowed)
+  intr NPN_SetValue_NPPVpluginWindow(bool windowed)
     returns (NPError result);
-  rpc NPN_SetValue_NPPVpluginTransparent(bool transparent)
+  intr NPN_SetValue_NPPVpluginTransparent(bool transparent)
     returns (NPError result);
-  rpc NPN_SetValue_NPPVpluginUsesDOMForCursor(bool useDOMForCursor)
+  intr NPN_SetValue_NPPVpluginUsesDOMForCursor(bool useDOMForCursor)
     returns (NPError result);
-  rpc NPN_SetValue_NPPVpluginDrawingModel(int drawingModel)
+  intr NPN_SetValue_NPPVpluginDrawingModel(int drawingModel)
     returns (OptionalShmem remoteImageData, CrossProcessMutexHandle mutex, NPError result);
-  rpc NPN_SetValue_NPPVpluginEventModel(int eventModel)
+  intr NPN_SetValue_NPPVpluginEventModel(int eventModel)
     returns (NPError result);
 
-  rpc NPN_GetURL(nsCString url, nsCString target)
+  intr NPN_GetURL(nsCString url, nsCString target)
     returns (NPError result);
-  rpc NPN_PostURL(nsCString url, nsCString target, nsCString buffer, bool file)
+  intr NPN_PostURL(nsCString url, nsCString target, nsCString buffer, bool file)
     returns (NPError result);
 
   /**
    * Covers both NPN_GetURLNotify and NPN_PostURLNotify.
    * @TODO This would be more readable as an overloaded method,
    *       but IPDL doesn't allow that for constructors.
    */
-  rpc PStreamNotify(nsCString url, nsCString target, bool post,
+  intr PStreamNotify(nsCString url, nsCString target, bool post,
                     nsCString buffer, bool file)
     returns (NPError result);
 
   async NPN_InvalidateRect(NPRect rect);
 
   // Give |newSurface|, containing this instance's updated pixels, to
   // the browser for compositing.  When this method returns, any surface 
   // previously passed to Show may be destroyed.
@@ -197,74 +197,74 @@ parent:
   //                      the shmem for reuse
   sync Show(NPRect updatedRect, SurfaceDescriptor newSurface)
     returns (SurfaceDescriptor prevSurface);
 
   async PPluginSurface(WindowsSharedMemoryHandle handle,
                        gfxIntSize size,
                        bool transparent);
 
-  rpc NPN_PushPopupsEnabledState(bool aState);
+  intr NPN_PushPopupsEnabledState(bool aState);
 
-  rpc NPN_PopPopupsEnabledState();
+  intr NPN_PopPopupsEnabledState();
 
-  rpc NPN_GetValueForURL(NPNURLVariable variable, nsCString url)
+  intr NPN_GetValueForURL(NPNURLVariable variable, nsCString url)
     returns (nsCString value, NPError result);
 
-  rpc NPN_SetValueForURL(NPNURLVariable variable, nsCString url,
+  intr NPN_SetValueForURL(NPNURLVariable variable, nsCString url,
                          nsCString value)
     returns (NPError result);
 
-  rpc NPN_GetAuthenticationInfo(nsCString protocol_, nsCString host,
+  intr NPN_GetAuthenticationInfo(nsCString protocol_, nsCString host,
                                 int32_t port, nsCString scheme,
                                 nsCString realm)
     returns (nsCString username, nsCString password, NPError result);
 
-  rpc NPN_ConvertPoint(double sourceX, bool ignoreDestX, double sourceY, bool ignoreDestY, NPCoordinateSpace sourceSpace,
+  intr NPN_ConvertPoint(double sourceX, bool ignoreDestX, double sourceY, bool ignoreDestY, NPCoordinateSpace sourceSpace,
                        NPCoordinateSpace destSpace)
     returns (double destX, double destY, bool result);
 
   async RedrawPlugin();
 
-  rpc NPN_InitAsyncSurface(gfxIntSize size, NPImageFormat format)
+  intr NPN_InitAsyncSurface(gfxIntSize size, NPImageFormat format)
     returns (NPRemoteAsyncSurface surfData, bool result);
 
   // Send notification that a plugin tried to negotiate Carbon NPAPI so that
   // users can be notified that restarting the browser in i386 mode may allow
   // them to use the plugin.
   sync NegotiatedCarbon();
 
   // Notifies us we can release a Async Surface DXGI texture.
   async ReleaseDXGISharedSurface(DXGISharedSurfaceHandle handle);
 
 both:
   async PPluginScriptableObject();
 
 child:
   /* NPP_NewStream */
-  rpc PBrowserStream(nsCString url,
+  intr PBrowserStream(nsCString url,
                      uint32_t length,
                      uint32_t lastmodified,
                      nullable PStreamNotify notifyData,
                      nsCString headers,
                      nsCString mimeType,
                      bool seekable)
     returns (NPError rv,
              uint16_t stype);
 
 parent:
   /* NPN_NewStream */
-  rpc PPluginStream(nsCString mimeType,
+  intr PPluginStream(nsCString mimeType,
                     nsCString target)
     returns (NPError result);
 
 parent:
-  rpc PluginFocusChange(bool gotFocus);
+  intr PluginFocusChange(bool gotFocus);
 
 child:
-  rpc SetPluginFocus();
-  rpc UpdateWindow();
+  intr SetPluginFocus();
+  intr UpdateWindow();
 
   async PPluginBackgroundDestroyer();
 };
 
 } // namespace plugins
 } // namespace mozilla
--- a/dom/plugins/ipc/PPluginModule.ipdl
+++ b/dom/plugins/ipc/PPluginModule.ipdl
@@ -16,108 +16,108 @@ using NPError;
 using NPNVariable;
 using mozilla::dom::NativeThreadId;
 using mac_plugin_interposing::NSCursorInfo;
 using nsID;
 
 namespace mozilla {
 namespace plugins {
 
-rpc protocol PPluginModule
+intr protocol PPluginModule
 {
   manages PPluginInstance;
   manages PPluginIdentifier;
   manages PCrashReporter;
 
 both:
   /**
    * Sending a void string to this constructor creates an int identifier whereas
    * sending a non-void string will create a string identifier. This constructor
    * may be called by either child or parent. If a race occurs by calling the
    * constructor with the same string or int argument then we create two actors
    * and detect the second instance in the child. We prevent the parent's actor
    * from leaking out to plugin code and only allow the child's to be used.
    *
    * When calling into the plugin, the parent may create a "temporary"
-   * identifier which is only valid for the lifetime of the current RPC frame.
+   * identifier which is only valid for the lifetime of the current inerrupt frame.
    */
   async PPluginIdentifier(nsCString aString,
                           int32_t aInt,
                           bool temporary);
 
-  // Window-specific message which instructs the RPC mechanism to enter
-  // a nested event loop for the current RPC call.
-  async ProcessNativeEventsInRPCCall();
+  // Window-specific message which instructs the interrupt mechanism to enter
+  // a nested event loop for the current interrupt call.
+  async ProcessNativeEventsInInterruptCall();
 
 child:
   // Forces the child process to update its plugin function table.
-  rpc NP_GetEntryPoints()
+  intr NP_GetEntryPoints()
     returns (NPError rv);
 
-  rpc NP_Initialize(uint32_t aFlags)
+  intr NP_Initialize(uint32_t aFlags)
     returns (NPError rv);
 
-  rpc PPluginInstance(nsCString aMimeType,
+  intr PPluginInstance(nsCString aMimeType,
                       uint16_t aMode,
                       nsCString[] aNames,
                       nsCString[] aValues)
     returns (NPError rv);
 
-  rpc NP_Shutdown()
+  intr NP_Shutdown()
     returns (NPError rv);
 
-  rpc OptionalFunctionsSupported()
+  intr OptionalFunctionsSupported()
     returns (bool aURLRedirectNotify, bool aClearSiteData,
              bool aGetSitesWithData);
 
-  rpc NPP_ClearSiteData(nsCString site, uint64_t flags, uint64_t maxAge)
+  intr NPP_ClearSiteData(nsCString site, uint64_t flags, uint64_t maxAge)
     returns (NPError rv);
 
-  rpc NPP_GetSitesWithData()
+  intr NPP_GetSitesWithData()
     returns (nsCString[] sites);
 
   // Windows specific message to set up an audio session in the plugin process
   async SetAudioSessionData(nsID aID,
                             nsString aDisplayName,
                             nsString aIconPath);
 
   async SetParentHangTimeout(uint32_t seconds);
 
-  rpc PCrashReporter()
+  intr PCrashReporter()
     returns (NativeThreadId tid, uint32_t processType);
 
-  rpc GeckoGetProfile()
+  intr GeckoGetProfile()
     returns (nsCString aProfile);
 
 parent:
   /**
    * This message is only used on X11 platforms.
    *
    * Send a dup of the plugin process's X socket to the parent
    * process.  In theory, this scheme keeps the plugin's X resources
    * around until after both the plugin process shuts down *and* the
    * parent process closes the dup fd.  This is used to prevent the
    * parent process from crashing on X errors if, e.g., the plugin
    * crashes *just before* a repaint and the parent process tries to
    * use the newly-invalid surface.
    */
   async BackUpXResources(FileDescriptor aXSocketFd);
 
-  rpc NPN_UserAgent()
+  intr NPN_UserAgent()
     returns (nsCString userAgent);
 
-  rpc NPN_GetValue_WithBoolReturn(NPNVariable aVariable)
+  intr NPN_GetValue_WithBoolReturn(NPNVariable aVariable)
     returns (NPError aError,
              bool aBoolVal);
 
   // Wake up and process a few native events.  Periodically called by
   // Gtk-specific code upon detecting that the plugin process has
   // entered a nested event loop.  If the browser doesn't process
   // native events, then "livelock" and some other glitches can occur.
-  rpc ProcessSomeEvents();
+  intr ProcessSomeEvents();
 
   // OS X Specific calls to manage the plugin's window
   // when interposing system calls.
   async PluginShowWindow(uint32_t aWindowId, bool aModal,
                          int32_t aX, int32_t aY,
                          size_t aWidth, size_t aHeight);
   async PluginHideWindow(uint32_t aWindowId);
 
--- a/dom/plugins/ipc/PPluginScriptableObject.ipdl
+++ b/dom/plugins/ipc/PPluginScriptableObject.ipdl
@@ -21,60 +21,60 @@ union Variant {
   null_t;
   bool;
   int;
   double;
   nsCString;
   nullable PPluginScriptableObject;
 };
 
-rpc protocol PPluginScriptableObject
+intr protocol PPluginScriptableObject
 {
   manager PPluginInstance;
 
 both:
   async __delete__();
 
 parent:
-  rpc NPN_Evaluate(nsCString aScript)
+  intr NPN_Evaluate(nsCString aScript)
     returns (Variant aResult,
              bool aSuccess);
 
 child:
-  rpc Invalidate();
+  intr Invalidate();
 
 both:
   // NPClass methods
-  rpc HasMethod(PPluginIdentifier aId)
+  intr HasMethod(PPluginIdentifier aId)
     returns (bool aHasMethod);
 
-  rpc Invoke(PPluginIdentifier aId,
+  intr Invoke(PPluginIdentifier aId,
              Variant[] aArgs)
     returns (Variant aResult,
              bool aSuccess);
 
-  rpc InvokeDefault(Variant[] aArgs)
+  intr InvokeDefault(Variant[] aArgs)
     returns (Variant aResult,
              bool aSuccess);
 
-  rpc HasProperty(PPluginIdentifier aId)
+  intr HasProperty(PPluginIdentifier aId)
     returns (bool aHasProperty);
 
-  rpc SetProperty(PPluginIdentifier aId,
+  intr SetProperty(PPluginIdentifier aId,
                   Variant aValue)
     returns (bool aSuccess);
 
-  rpc RemoveProperty(PPluginIdentifier aId)
+  intr RemoveProperty(PPluginIdentifier aId)
     returns (bool aSuccess);
 
-  rpc Enumerate()
+  intr Enumerate()
     returns (PPluginIdentifier[] aProperties,
              bool aSuccess);
 
-  rpc Construct(Variant[] aArgs)
+  intr Construct(Variant[] aArgs)
     returns (Variant aResult,
              bool aSuccess);
 
   // Objects are initially unprotected, and the Protect and Unprotect functions
   // only affect protocol objects that represent NPObjects created in the same
   // process (rather than protocol objects that are a proxy for an NPObject
   // created in another process). Protocol objects representing local NPObjects
   // are protected after an NPObject has been associated with the protocol
@@ -85,22 +85,22 @@ both:
 
   /**
    * GetProperty is slightly wonky due to the way we support NPObjects that have
    * methods and properties with the same name. When child calls parent we
    * simply return a property. When parent calls child, however, we need to do
    * several checks at once and return all the results simultaneously.
    */
 parent:
-  rpc GetParentProperty(PPluginIdentifier aId)
+  intr GetParentProperty(PPluginIdentifier aId)
     returns (Variant aResult,
              bool aSuccess);
 
 child:
-  rpc GetChildProperty(PPluginIdentifier aId)
+  intr GetChildProperty(PPluginIdentifier aId)
     returns (bool aHasProperty,
              bool aHasMethod,
              Variant aResult,
              bool aSuccess);
 };
 
 } // namespace plugins
 } // namespace mozilla
--- a/dom/plugins/ipc/PPluginStream.ipdl
+++ b/dom/plugins/ipc/PPluginStream.ipdl
@@ -13,26 +13,26 @@ using NPReason;
 
 namespace mozilla {
 namespace plugins {
 
 /**
  * PPluginStream represents an NPStream sent from the plugin to the browser.
  */
 
-rpc protocol PPluginStream
+intr protocol PPluginStream
 {
   manager PPluginInstance;
 
 parent:
-  rpc NPN_Write(Buffer data) returns (int32_t written);
+  intr NPN_Write(Buffer data) returns (int32_t written);
 
 both:
   /**
    * ~PPluginStream is for both NPN_DestroyStream and NPP_DestroyStream.
    * @param artificial True when the stream is closed as a by-product of
    *                        some other call (such as a failure in NPN_Write).
    */
-  rpc __delete__(NPReason reason, bool artificial);
+  intr __delete__(NPReason reason, bool artificial);
 };
 
 } // namespace plugins
 } // namespace mozilla
--- a/dom/plugins/ipc/PStreamNotify.ipdl
+++ b/dom/plugins/ipc/PStreamNotify.ipdl
@@ -8,17 +8,17 @@ include protocol PPluginInstance;
 
 include "npapi.h";
 
 using NPReason;
 
 namespace mozilla {
 namespace plugins {
 
-rpc protocol PStreamNotify
+intr protocol PStreamNotify
 {
   manager PPluginInstance;
 
 parent:
 
   /**
    * Represents NPN_URLRedirectResponse
    */
--- a/dom/plugins/ipc/PluginMessageUtils.cpp
+++ b/dom/plugins/ipc/PluginMessageUtils.cpp
@@ -62,31 +62,31 @@ NPRemoteWindow::NPRemoteWindow() :
 #endif
 {
   clipRect.top = 0;
   clipRect.left = 0;
   clipRect.bottom = 0;
   clipRect.right = 0;
 }
 
-ipc::RacyRPCPolicy
+ipc::RacyInterruptPolicy
 MediateRace(const MessageChannel::Message& parent,
             const MessageChannel::Message& child)
 {
   switch (parent.type()) {
   case PPluginInstance::Msg_Paint__ID:
   case PPluginInstance::Msg_NPP_SetWindow__ID:
   case PPluginInstance::Msg_NPP_HandleEvent_Shmem__ID:
   case PPluginInstance::Msg_NPP_HandleEvent_IOSurface__ID:
     // our code relies on the frame list not changing during paints and
     // reflows
-    return ipc::RRPParentWins;
+    return ipc::RIPParentWins;
 
   default:
-    return ipc::RRPChildWins;
+    return ipc::RIPChildWins;
   }
 }
 
 #if defined(OS_LINUX)
 static string
 ReplaceAll(const string& haystack, const string& needle, const string& with)
 {
   string munged = haystack;
--- a/dom/plugins/ipc/PluginMessageUtils.h
+++ b/dom/plugins/ipc/PluginMessageUtils.h
@@ -38,17 +38,17 @@ namespace plugins {
 using layers::SurfaceDescriptorX11;
 
 enum ScriptableObjectType
 {
   LocalObject,
   Proxy
 };
 
-mozilla::ipc::RacyRPCPolicy
+mozilla::ipc::RacyInterruptPolicy
 MediateRace(const mozilla::ipc::MessageChannel::Message& parent,
             const mozilla::ipc::MessageChannel::Message& child);
 
 std::string
 MungePluginDsoPath(const std::string& path);
 std::string
 UnmungePluginDsoPath(const std::string& munged);
 
--- a/dom/plugins/ipc/PluginModuleChild.cpp
+++ b/dom/plugins/ipc/PluginModuleChild.cpp
@@ -578,17 +578,17 @@ bool
 PluginModuleChild::AnswerNP_Shutdown(NPError *rv)
 {
     AssertPluginThread();
 
 #if defined XP_WIN
     mozilla::widget::StopAudioSession();
 #endif
 
-    // the PluginModuleParent shuts down this process after this RPC
+    // the PluginModuleParent shuts down this process after this interrupt
     // call pops off its stack
 
     *rv = mShutdownFunc ? mShutdownFunc() : NPERR_NO_ERROR;
 
     // weakly guard against re-entry after NP_Shutdown
     memset(&mFunctions, 0, sizeof(mFunctions));
 
 #ifdef OS_WIN
@@ -2345,17 +2345,17 @@ PluginModuleChild::CallWindowProcHook(in
 
 LRESULT CALLBACK
 PluginModuleChild::NestedInputEventHook(int nCode, WPARAM wParam, LPARAM lParam)
 {
     PluginModuleChild* self = current();
     uint32_t len = self->mIncallPumpingStack.Length();
     if (nCode >= 0 && len && !self->mIncallPumpingStack[len - 1]._spinning) {
         MessageLoop* loop = MessageLoop::current();
-        self->SendProcessNativeEventsInRPCCall();
+        self->SendProcessNativeEventsInInterruptCall();
         IncallFrame& f = self->mIncallPumpingStack[len - 1];
         f._spinning = true;
         f._savedNestableTasksAllowed = loop->NestableTasksAllowed();
         loop->SetNestableTasksAllowed(true);
         loop->set_os_modal_loop(true);
     }
 
     return CallNextHookEx(NULL, nCode, wParam, lParam);
@@ -2394,25 +2394,25 @@ PluginModuleChild::ResetEventHooks()
     mNestedEventHook = NULL;
     if (mGlobalCallWndProcHook)
         UnhookWindowsHookEx(mGlobalCallWndProcHook);
     mGlobalCallWndProcHook = NULL;
 }
 #endif
 
 bool
-PluginModuleChild::RecvProcessNativeEventsInRPCCall()
+PluginModuleChild::RecvProcessNativeEventsInInterruptCall()
 {
     PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));
 #if defined(OS_WIN)
-    ProcessNativeEventsInRPCCall();
+    ProcessNativeEventsInInterruptCall();
     return true;
 #else
     NS_RUNTIMEABORT(
-        "PluginModuleChild::RecvProcessNativeEventsInRPCCall not implemented!");
+        "PluginModuleChild::RecvProcessNativeEventsInInterruptCall not implemented!");
     return false;
 #endif
 }
 
 #ifdef MOZ_WIDGET_COCOA
 void
 PluginModuleChild::ProcessNativeEvents() {
     CallProcessSomeEvents();    
--- a/dom/plugins/ipc/PluginModuleChild.h
+++ b/dom/plugins/ipc/PluginModuleChild.h
@@ -69,18 +69,18 @@ static const int kNestedLoopDetectorInte
 
 class PluginScriptableObjectChild;
 class PluginInstanceChild;
 
 class PluginModuleChild : public PPluginModuleChild
 {
     typedef mozilla::dom::PCrashReporterChild PCrashReporterChild;
 protected:
-    virtual mozilla::ipc::RacyRPCPolicy
-    MediateRPCRace(const Message& parent, const Message& child) MOZ_OVERRIDE
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const Message& parent, const Message& child) MOZ_OVERRIDE
     {
         return MediateRace(parent, child);
     }
 
     virtual bool ShouldContinueFromReplyTimeout() MOZ_OVERRIDE;
 
     // Implement the PPluginModuleChild interface
     virtual bool AnswerNP_GetEntryPoints(NPError* rv);
@@ -153,17 +153,17 @@ protected:
                                     uint32_t* processType);
 
     virtual void
     ActorDestroy(ActorDestroyReason why);
 
     MOZ_NORETURN void QuickExit();
 
     virtual bool
-    RecvProcessNativeEventsInRPCCall() MOZ_OVERRIDE;
+    RecvProcessNativeEventsInInterruptCall() MOZ_OVERRIDE;
 
     virtual bool
     AnswerGeckoGetProfile(nsCString* aProfile);
 
 public:
     PluginModuleChild();
     virtual ~PluginModuleChild();
 
@@ -426,17 +426,17 @@ public: // called by PluginInstanceChild
 private:
     static PLDHashOperator CollectForInstance(NPObjectData* d, void* userArg);
 
 #if defined(OS_WIN)
     virtual void EnteredCall() MOZ_OVERRIDE;
     virtual void ExitedCall() MOZ_OVERRIDE;
 
     // Entered/ExitedCall notifications keep track of whether the plugin has
-    // entered a nested event loop within this RPC call.
+    // entered a nested event loop within this interrupt call.
     struct IncallFrame
     {
         IncallFrame()
             : _spinning(false)
             , _savedNestableTasksAllowed(false)
         { }
 
         bool _spinning;
--- a/dom/plugins/ipc/PluginModuleParent.cpp
+++ b/dom/plugins/ipc/PluginModuleParent.cpp
@@ -1236,17 +1236,17 @@ PluginModuleParent::NP_Shutdown(NPError*
 
     if (mShutdown) {
         *error = NPERR_GENERIC_ERROR;
         return NS_ERROR_FAILURE;
     }
 
     bool ok = CallNP_Shutdown(error);
 
-    // if NP_Shutdown() is nested within another RPC call, this will
+    // if NP_Shutdown() is nested within another interrupt call, this will
     // break things.  but lord help us if we're doing that anyway; the
     // plugin dso will have been unloaded on the other side by the
     // CallNP_Shutdown() message
     Close();
 
     return ok ? NS_OK : NS_ERROR_FAILURE;
 }
 
@@ -1461,38 +1461,38 @@ PluginModuleParent::AnswerProcessSomeEve
 
     PLUGIN_LOG_DEBUG(("... quitting mini nested loop; processed %i tasks", i));
 
     return true;
 }
 #endif
 
 bool
-PluginModuleParent::RecvProcessNativeEventsInRPCCall()
+PluginModuleParent::RecvProcessNativeEventsInInterruptCall()
 {
     PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));
 #if defined(OS_WIN)
-    ProcessNativeEventsInRPCCall();
+    ProcessNativeEventsInInterruptCall();
     return true;
 #else
     NS_NOTREACHED(
-        "PluginModuleParent::RecvProcessNativeEventsInRPCCall not implemented!");
+        "PluginModuleParent::RecvProcessNativeEventsInInterruptCall not implemented!");
     return false;
 #endif
 }
 
 void
-PluginModuleParent::ProcessRemoteNativeEventsInRPCCall()
+PluginModuleParent::ProcessRemoteNativeEventsInInterruptCall()
 {
 #if defined(OS_WIN)
-    unused << SendProcessNativeEventsInRPCCall();
+    unused << SendProcessNativeEventsInInterruptCall();
     return;
 #endif
     NS_NOTREACHED(
-        "PluginModuleParent::ProcessRemoteNativeEventsInRPCCall not implemented!");
+        "PluginModuleParent::ProcessRemoteNativeEventsInInterruptCall not implemented!");
 }
 
 bool
 PluginModuleParent::RecvPluginShowWindow(const uint32_t& aWindowId, const bool& aModal,
                                          const int32_t& aX, const int32_t& aY,
                                          const size_t& aWidth, const size_t& aHeight)
 {
     PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));
--- a/dom/plugins/ipc/PluginModuleParent.h
+++ b/dom/plugins/ipc/PluginModuleParent.h
@@ -119,28 +119,28 @@ public:
      * Get an identifier actor for this NPIdentifier. If this is a temporary
      * identifier, the temporary refcount is increased by one. This method
      * is intended only for use by StackIdentifier and the scriptable
      * Enumerate hook.
      */
     PluginIdentifierParent*
     GetIdentifierForNPIdentifier(NPP npp, NPIdentifier aIdentifier);
 
-    void ProcessRemoteNativeEventsInRPCCall();
+    void ProcessRemoteNativeEventsInInterruptCall();
 
     void TerminateChildProcess(MessageLoop* aMsgLoop);
 
 #ifdef XP_WIN
     void
     ExitedCxxStack() MOZ_OVERRIDE;
 #endif // XP_WIN
 
 protected:
-    virtual mozilla::ipc::RacyRPCPolicy
-    MediateRPCRace(const Message& parent, const Message& child) MOZ_OVERRIDE
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const Message& parent, const Message& child) MOZ_OVERRIDE
     {
         return MediateRace(parent, child);
     }
 
     virtual bool RecvXXX_HACK_FIXME_cjones(Shmem& mem) { NS_RUNTIMEABORT("not reached"); return false; }
 
     virtual bool ShouldContinueFromReplyTimeout() MOZ_OVERRIDE;
 
@@ -153,17 +153,17 @@ protected:
     virtual bool
     AnswerNPN_GetValue_WithBoolReturn(const NPNVariable& aVariable,
                                       NPError* aError,
                                       bool* aBoolVal);
 
     virtual bool AnswerProcessSomeEvents() MOZ_OVERRIDE;
 
     virtual bool
-    RecvProcessNativeEventsInRPCCall() MOZ_OVERRIDE;
+    RecvProcessNativeEventsInInterruptCall() MOZ_OVERRIDE;
 
     virtual bool
     RecvPluginShowWindow(const uint32_t& aWindowId, const bool& aModal,
                          const int32_t& aX, const int32_t& aY,
                          const size_t& aWidth, const size_t& aHeight) MOZ_OVERRIDE;
 
     virtual bool
     RecvPluginHideWindow(const uint32_t& aWindowId) MOZ_OVERRIDE;
--- a/gfx/layers/ipc/PCompositor.ipdl
+++ b/gfx/layers/ipc/PCompositor.ipdl
@@ -21,17 +21,17 @@ namespace layers {
 
 /**
  * The PCompositor protocol is used to manage communication between
  * the main thread and the compositor thread context. It's primary
  * purpose is to manage the PLayerTransaction sub protocol.
  */
 // This should really be 'sync', but we're using 'rpc' as a workaround
 // for Bug 716631.
-rpc protocol PCompositor
+intr protocol PCompositor
 {
   // A Compositor manages a single Layer Manager (PLayerTransaction)
   manages PLayerTransaction;
 
 parent:
 
   // The child is about to be destroyed, so perform any necessary cleanup.
   sync WillStop();
--- a/gfx/layers/ipc/PImageBridge.ipdl
+++ b/gfx/layers/ipc/PImageBridge.ipdl
@@ -18,17 +18,17 @@ using mozilla::layers::TextureInfo;
 namespace mozilla {
 namespace layers {
 
 /**
  * The PImageBridge protocol is used to allow isolated threads or processes to push
  * frames directly to the compositor thread/process without relying on the main thread
  * which might be too busy dealing with content script.
  */
-/*FIXME: sync*/ rpc protocol PImageBridge
+intr protocol PImageBridge
 {
   manages PCompositable;
   manages PGrallocBuffer;
 
 parent:
 
   sync Update(CompositableOperation[] ops) returns (EditReply[] reply);
   async UpdateNoSwap(CompositableOperation[] ops);
--- a/ipc/chromium/src/chrome/common/ipc_message.cc
+++ b/ipc/chromium/src/chrome/common/ipc_message.cc
@@ -33,18 +33,18 @@ Message::Message(int32_t routing_id, msg
   header()->routing = routing_id;
   header()->type = type;
   header()->flags = priority;
   if (compression == COMPRESSION_ENABLED)
     header()->flags |= COMPRESS_BIT;
 #if defined(OS_POSIX)
   header()->num_fds = 0;
 #endif
-  header()->rpc_remote_stack_depth_guess = static_cast<uint32_t>(-1);
-  header()->rpc_local_stack_depth = static_cast<uint32_t>(-1);
+  header()->interrupt_remote_stack_depth_guess = static_cast<uint32_t>(-1);
+  header()->interrupt_local_stack_depth = static_cast<uint32_t>(-1);
   header()->seqno = 0;
 #if defined(OS_MACOSX)
   header()->cookie = 0;
 #endif
   InitLoggingVariables(name);
 }
 
 Message::Message(const char* data, int data_len) : Pickle(data, data_len) {
--- a/ipc/chromium/src/chrome/common/ipc_message.h
+++ b/ipc/chromium/src/chrome/common/ipc_message.h
@@ -82,18 +82,18 @@ class Message : public Pickle {
   }
 
   // True if this is a synchronous message.
   bool is_sync() const {
     return (header()->flags & SYNC_BIT) != 0;
   }
 
   // True if this is a synchronous message.
-  bool is_rpc() const {
-    return (header()->flags & RPC_BIT) != 0;
+  bool is_interrupt() const {
+    return (header()->flags & INTERRUPT_BIT) != 0;
   }
 
   // True if this is an urgent message.
   bool is_urgent() const {
     return (header()->flags & URGENT_BIT) != 0;
   }
 
   // True if compression is enabled for this message.
@@ -148,32 +148,32 @@ class Message : public Pickle {
   int32_t routing_id() const {
     return header()->routing;
   }
 
   void set_routing_id(int32_t new_id) {
     header()->routing = new_id;
   }
 
-  uint32_t rpc_remote_stack_depth_guess() const {
-    return header()->rpc_remote_stack_depth_guess;
+  uint32_t interrupt_remote_stack_depth_guess() const {
+    return header()->interrupt_remote_stack_depth_guess;
   }
 
-  void set_rpc_remote_stack_depth_guess(uint32_t depth) {
-    DCHECK(is_rpc());
-    header()->rpc_remote_stack_depth_guess = depth;
+  void set_interrupt_remote_stack_depth_guess(uint32_t depth) {
+    DCHECK(is_interrupt());
+    header()->interrupt_remote_stack_depth_guess = depth;
   }
 
-  uint32_t rpc_local_stack_depth() const {
-    return header()->rpc_local_stack_depth;
+  uint32_t interrupt_local_stack_depth() const {
+    return header()->interrupt_local_stack_depth;
   }
 
-  void set_rpc_local_stack_depth(uint32_t depth) {
-    DCHECK(is_rpc());
-    header()->rpc_local_stack_depth = depth;
+  void set_interrupt_local_stack_depth(uint32_t depth) {
+    DCHECK(is_interrupt());
+    header()->interrupt_local_stack_depth = depth;
   }
 
   int32_t seqno() const {
     return header()->seqno;
   }
 
   void set_seqno(int32_t seqno) {
     header()->seqno = seqno;
@@ -266,18 +266,18 @@ class Message : public Pickle {
   friend class Channel;
   friend class MessageReplyDeserializer;
   friend class SyncMessage;
 
   void set_sync() {
     header()->flags |= SYNC_BIT;
   }
 
-  void set_rpc() {
-    header()->flags |= RPC_BIT;
+  void set_interrupt() {
+    header()->flags |= INTERRUPT_BIT;
   }
 
   void set_urgent() {
     header()->flags |= URGENT_BIT;
   }
 
 #if !defined(OS_MACOSX)
  protected:
@@ -287,35 +287,35 @@ class Message : public Pickle {
   enum {
     PRIORITY_MASK   = 0x0003,
     SYNC_BIT        = 0x0004,
     REPLY_BIT       = 0x0008,
     REPLY_ERROR_BIT = 0x0010,
     UNBLOCK_BIT     = 0x0020,
     PUMPING_MSGS_BIT= 0x0040,
     HAS_SENT_TIME_BIT = 0x0080,
-    RPC_BIT         = 0x0100,
+    INTERRUPT_BIT   = 0x0100,
     COMPRESS_BIT    = 0x0200,
     URGENT_BIT      = 0x0400
   };
 
   struct Header : Pickle::Header {
     int32_t routing;  // ID of the view that this message is destined for
     msgid_t type;   // specifies the user-defined message type
     uint32_t flags;   // specifies control flags for the message
 #if defined(OS_POSIX)
     uint32_t num_fds; // the number of descriptors included with this message
 # if defined(OS_MACOSX)
     uint32_t cookie;  // cookie to ACK that the descriptors have been read.
 # endif
 #endif
     // For RPC messages, a guess at what the *other* side's stack depth is.
-    uint32_t rpc_remote_stack_depth_guess;
+    uint32_t interrupt_remote_stack_depth_guess;
     // The actual local stack depth.
-    uint32_t rpc_local_stack_depth;
+    uint32_t interrupt_local_stack_depth;
     // Sequence number
     int32_t seqno;
   };
 
   Header* header() {
     return headerT<Header>();
   }
   const Header* header() const {
--- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -48,17 +48,17 @@ MessageChannel::MessageChannel(MessageLi
     mWorkerLoopID(-1),
     mTimeoutMs(kNoTimeout),
     mInTimeoutSecondHalf(false),
     mNextSeqno(0),
     mPendingSyncReplies(0),
     mPendingUrgentReplies(0),
     mDispatchingSyncMessage(false),
     mRemoteStackDepthGuess(false),
-    mSawRPCOutMsg(false)
+    mSawInterruptOutMsg(false)
 {
     MOZ_COUNT_CTOR(ipc::MessageChannel);
 
 #ifdef OS_WIN
     mTopFrame = nullptr;
 #endif
 
     mDequeueOneTask = new RefCountedTask(NewRunnableMethod(
@@ -265,17 +265,17 @@ void
 MessageChannel::OnMessageReceivedFromLink(const Message& aMsg)
 {
     AssertLinkThread();
     mMonitor->AssertCurrentThreadOwns();
 
     if (MaybeInterceptSpecialIOMessage(aMsg))
         return;
 
-    // Regardless of the RPC stack, if we're awaiting a sync or urgent reply,
+    // Regardless of the Interrupt stack, if we're awaiting a sync or urgent reply,
     // we know that it needs to be immediately handled to unblock us.
     if ((AwaitingSyncReply() && aMsg.is_sync()) ||
         (AwaitingUrgentReply() && aMsg.is_urgent()))
     {
         mRecvd = new Message(aMsg);
         NotifyWorkerThread();
         return;
     }
@@ -305,33 +305,33 @@ MessageChannel::OnMessageReceivedFromLin
     // main thread:
     //
     // (1) We are waiting on a sync reply - main thread is blocked on the IPC monitor.
     //   - If the message is high priority, we wake up the main thread to
     //     deliver the message. Otherwise, we leave it in the mPending queue,
     //     posting a task to the main event loop, where it will be processed
     //     once the synchronous reply has been received.
     //
-    // (2) We are waiting on an RPC reply - main thread is blocked on the IPC monitor.
+    // (2) We are waiting on an Interrupt reply - main thread is blocked on the IPC monitor.
     //   - Always notify and wake up the main thread.
     //
     // (3) We are not waiting on a reply.
     //   - We post a task to the main event loop.
     //
     // Note that, we may notify the main thread even though the monitor is not
     // blocked. This is okay, since we always check for pending events before
     // blocking again.
     //
-    if (AwaitingRPCReply() || (AwaitingSyncReply() && aMsg.is_urgent())) {
-        // Always wake up our RPC waiter, and wake up sync waiters for urgent
+    if (AwaitingInterruptReply() || (AwaitingSyncReply() && aMsg.is_urgent())) {
+        // Always wake up our Interrupt waiter, and wake up sync waiters for urgent
         // messages.
         NotifyWorkerThread();
     } else {
         // Worker thread is either not blocked on a reply, or this is an
-        // incoming RPC that raced with outgoing sync, and needs to be
+        // incoming Interrupt that raced with outgoing sync, and needs to be
         // deferred to a later event-loop iteration.
         if (!compress) {
             // If we compressed away the previous message, we'll re-use
             // its pending task.
             mWorkerLoop->PostTask(FROM_HERE, new DequeueTask(mDequeueOneTask));
         }
     }
 }
@@ -352,17 +352,17 @@ MessageChannel::Send(Message* aMsg, Mess
 
     MonitorAutoLock lock(*mMonitor);
 
     IPC_ASSERT(aMsg->is_sync(), "can only Send() sync messages here");
     IPC_ASSERT(!DispatchingSyncMessage(), "violation of sync handler invariant");
 
     if (AwaitingSyncReply()) {
         // This is a temporary hack in place, for e10s CPOWs, until bug 901789
-        // and the new followup RPC protocol land. Eventually this will become
+        // and the new followup Interrupt protocol land. Eventually this will become
         // an assert again. See bug 900062 for details.
         NS_ERROR("Nested sync messages are not supported");
         return false;
     }
 
     AutoEnterPendingReply replies(mPendingSyncReplies);
     if (!SendAndWait(aMsg, aReply))
         return false;
@@ -385,17 +385,17 @@ MessageChannel::UrgentCall(Message* aMsg
     Message copy = *aMsg;
     CxxStackFrame f(*this, OUT_MESSAGE, &copy);
 
     MonitorAutoLock lock(*mMonitor);
 
     // At the moment, we don't allow urgent outcalls to nest, though this will
     // change soon.
     IPC_ASSERT(!AwaitingUrgentReply(), "urgent calls cannot nest");
-    IPC_ASSERT(!AwaitingRPCReply(), "urgent calls cannot be issued within RPC calls");
+    IPC_ASSERT(!AwaitingInterruptReply(), "urgent calls cannot be issued within Interrupt calls");
     IPC_ASSERT(!AwaitingSyncReply(), "urgent calls cannot be issued within sync sends");
 
     AutoEnterPendingReply replies(mPendingUrgentReplies);
     if (!SendAndWait(aMsg, aReply))
         return false;
 
     NS_ABORT_IF_FALSE(aReply->is_urgent(), "reply is not urgent");
     return true;
@@ -480,21 +480,21 @@ MessageChannel::SendAndWait(Message* aMs
     return true;
 }
 
 bool
 MessageChannel::Call(Message* aMsg, Message* aReply)
 {
     if (aMsg->is_urgent())
         return UrgentCall(aMsg, aReply);
-    return RPCCall(aMsg, aReply);
+    return InterruptCall(aMsg, aReply);
 }
 
 bool
-MessageChannel::RPCCall(Message* aMsg, Message* aReply)
+MessageChannel::InterruptCall(Message* aMsg, Message* aReply)
 {
     AssertWorkerThread();
     mMonitor->AssertNotCurrentThreadOwns();
 
 #ifdef OS_WIN
     SyncStackFrame frame(this, true);
 #endif
 
@@ -506,110 +506,110 @@ MessageChannel::RPCCall(Message* aMsg, M
     MonitorAutoLock lock(*mMonitor);
     if (!Connected()) {
         ReportConnectionError("MessageChannel::Call");
         return false;
     }
 
     // Sanity checks.
     IPC_ASSERT(!AwaitingSyncReply() && !AwaitingUrgentReply(),
-               "cannot issue RPC call whiel blocked on sync or urgent");
+               "cannot issue Interrupt call whiel blocked on sync or urgent");
     IPC_ASSERT(!DispatchingSyncMessage() || aMsg->priority() == IPC::Message::PRIORITY_HIGH,
                "violation of sync handler invariant");
-    IPC_ASSERT(aMsg->is_rpc(), "can only Call() RPC messages here");
+    IPC_ASSERT(aMsg->is_interrupt(), "can only Call() Interrupt messages here");
 
 
     nsAutoPtr<Message> msg(aMsg);
 
     msg->set_seqno(NextSeqno());
-    msg->set_rpc_remote_stack_depth_guess(mRemoteStackDepthGuess);
-    msg->set_rpc_local_stack_depth(1 + RPCStackDepth());
-    mRPCStack.push(*msg);
+    msg->set_interrupt_remote_stack_depth_guess(mRemoteStackDepthGuess);
+    msg->set_interrupt_local_stack_depth(1 + InterruptStackDepth());
+    mInterruptStack.push(*msg);
     mLink->SendMessage(msg.forget());
 
     while (true) {
         // if a handler invoked by *Dispatch*() spun a nested event
         // loop, and the connection was broken during that loop, we
         // might have already processed the OnError event. if so,
         // trying another loop iteration will be futile because
         // channel state will have been cleared
         if (!Connected()) {
-            ReportConnectionError("MessageChannel::RPCCall");
+            ReportConnectionError("MessageChannel::InterruptCall");
             return false;
         }
 
         // Now might be the time to process a message deferred because of race
         // resolution.
         MaybeUndeferIncall();
 
         // Wait for an event to occur.
-        while (!RPCEventOccurred()) {
-            bool maybeTimedOut = !WaitForRPCNotify();
+        while (!InterruptEventOccurred()) {
+            bool maybeTimedOut = !WaitForInterruptNotify();
 
             // We might have received a "subtly deferred" message in a nested
             // loop that it's now time to process.
-            if (RPCEventOccurred() ||
+            if (InterruptEventOccurred() ||
                 (!maybeTimedOut && (!mDeferred.empty() || !mOutOfTurnReplies.empty())))
             {
                 break;
             }
 
             if (maybeTimedOut && !ShouldContinueFromTimeout())
                 return false;
         }
 
         Message recvd;
         MessageMap::iterator it;
 
         if (mPendingUrgentRequest) {
             recvd = *mPendingUrgentRequest;
             mPendingUrgentRequest = nullptr;
-        } else if ((it = mOutOfTurnReplies.find(mRPCStack.top().seqno()))
+        } else if ((it = mOutOfTurnReplies.find(mInterruptStack.top().seqno()))
                     != mOutOfTurnReplies.end())
         {
             recvd = it->second;
             mOutOfTurnReplies.erase(it);
         } else if (!mPending.empty()) {
             recvd = mPending.front();
             mPending.pop_front();
         } else {
             // because of subtleties with nested event loops, it's possible
             // that we got here and nothing happened.  or, we might have a
             // deferred in-call that needs to be processed.  either way, we
             // won't break the inner while loop again until something new
             // happens.
             continue;
         }
 
-        // If the message is not RPC, we can dispatch it as normal.
-        if (!recvd.is_rpc()) {
+        // If the message is not Interrupt, we can dispatch it as normal.
+        if (!recvd.is_interrupt()) {
             // Other side should be blocked.
             IPC_ASSERT(!recvd.is_sync() || mPending.empty(), "other side should be blocked");
 
             {
                 MonitorAutoUnlock unlock(*mMonitor);
                 CxxStackFrame frame(*this, IN_MESSAGE, &recvd);
                 DispatchMessage(recvd);
             }
             if (!Connected()) {
                 ReportConnectionError("MessageChannel::DispatchMessage");
                 return false;
             }
             continue;
         }
 
-        // If the message is an RPC reply, either process it as a reply to our
+        // If the message is an Interrupt reply, either process it as a reply to our
         // call, or add it to the list of out-of-turn replies we've received.
         if (recvd.is_reply()) {
-            IPC_ASSERT(!mRPCStack.empty(), "invalid RPC stack");
+            IPC_ASSERT(!mInterruptStack.empty(), "invalid Interrupt stack");
 
             // If this is not a reply the call we've initiated, add it to our
             // out-of-turn replies and keep polling for events.
             {
-                const Message &outcall = mRPCStack.top();
+                const Message &outcall = mInterruptStack.top();
 
                 // Note, In the parent, sequence numbers increase from 0, and
                 // in the child, they decrease from 0.
                 if ((mSide == ChildSide && recvd.seqno() > outcall.seqno()) ||
                     (mSide != ChildSide && recvd.seqno() < outcall.seqno()))
                 {
                     mOutOfTurnReplies[recvd.seqno()] = recvd;
                     continue;
@@ -618,61 +618,61 @@ MessageChannel::RPCCall(Message* aMsg, M
                 IPC_ASSERT(recvd.is_reply_error() ||
                            (recvd.type() == (outcall.type() + 1) &&
                             recvd.seqno() == outcall.seqno()),
                            "somebody's misbehavin'", true);
             }
 
             // We received a reply to our most recent outstanding call. Pop
             // this frame and return the reply.
-            mRPCStack.pop();
+            mInterruptStack.pop();
 
             if (!recvd.is_reply_error()) {
                 *aReply = recvd;
             }
 
             // If we have no more pending out calls waiting on replies, then
             // the reply queue should be empty.
-            IPC_ASSERT(!mRPCStack.empty() || mOutOfTurnReplies.empty(),
+            IPC_ASSERT(!mInterruptStack.empty() || mOutOfTurnReplies.empty(),
                        "still have pending replies with no pending out-calls",
                        true);
 
             return !recvd.is_reply_error();
         }
 
-        // Dispatch an RPC in-call. Snapshot the current stack depth while we
+        // Dispatch an Interrupt in-call. Snapshot the current stack depth while we
         // own the monitor.
-        size_t stackDepth = RPCStackDepth();
+        size_t stackDepth = InterruptStackDepth();
         {
             MonitorAutoUnlock unlock(*mMonitor);
 
             CxxStackFrame frame(*this, IN_MESSAGE, &recvd);
-            DispatchRPCMessage(recvd, stackDepth);
+            DispatchInterruptMessage(recvd, stackDepth);
         }
         if (!Connected()) {
-            ReportConnectionError("MessageChannel::DispatchRPCMessage");
+            ReportConnectionError("MessageChannel::DispatchInterruptMessage");
             return false;
         }
     }
 
     return true;
 }
 
 bool
-MessageChannel::RPCEventOccurred()
+MessageChannel::InterruptEventOccurred()
 {
     AssertWorkerThread();
     mMonitor->AssertCurrentThreadOwns();
-    IPC_ASSERT(RPCStackDepth() > 0, "not in wait loop");
+    IPC_ASSERT(InterruptStackDepth() > 0, "not in wait loop");
 
     return (!Connected() ||
             !mPending.empty() ||
             mPendingUrgentRequest ||
             (!mOutOfTurnReplies.empty() &&
-             mOutOfTurnReplies.find(mRPCStack.top().seqno()) !=
+             mOutOfTurnReplies.find(mInterruptStack.top().seqno()) !=
              mOutOfTurnReplies.end()));
 }
 
 bool
 MessageChannel::OnMaybeDequeueOne()
 {
     AssertWorkerThread();
     mMonitor->AssertNotCurrentThreadOwns();
@@ -697,37 +697,37 @@ MessageChannel::OnMaybeDequeueOne()
 
         if (mPending.empty())
             return false;
 
         recvd = mPending.front();
         mPending.pop_front();
     } while (0);
 
-    if (IsOnCxxStack() && recvd.is_rpc() && recvd.is_reply()) {
+    if (IsOnCxxStack() && recvd.is_interrupt() && recvd.is_reply()) {
         // We probably just received a reply in a nested loop for an
-        // RPC call sent before entering that loop.
+        // Interrupt call sent before entering that loop.
         mOutOfTurnReplies[recvd.seqno()] = recvd;
         return false;
     }
 
     CxxStackFrame frame(*this, IN_MESSAGE, &recvd);
     DispatchMessage(recvd);
     return true;
 }
 
 void
 MessageChannel::DispatchMessage(const Message &aMsg)
 {
     if (aMsg.is_sync())
         DispatchSyncMessage(aMsg);
     else if (aMsg.is_urgent())
         DispatchUrgentMessage(aMsg);
-    else if (aMsg.is_rpc())
-        DispatchRPCMessage(aMsg, 0);
+    else if (aMsg.is_interrupt())
+        DispatchInterruptMessage(aMsg, 0);
     else
         DispatchAsyncMessage(aMsg);
 }
 
 void
 MessageChannel::DispatchSyncMessage(const Message& aMsg)
 {
     AssertWorkerThread();
@@ -773,54 +773,54 @@ MessageChannel::DispatchUrgentMessage(co
     if (ChannelConnected == mChannelState)
         mLink->SendMessage(reply);
 }
 
 void
 MessageChannel::DispatchAsyncMessage(const Message& aMsg)
 {
     AssertWorkerThread();
-    MOZ_ASSERT(!aMsg.is_rpc() && !aMsg.is_sync() && !aMsg.is_urgent());
+    MOZ_ASSERT(!aMsg.is_interrupt() && !aMsg.is_sync() && !aMsg.is_urgent());
 
     if (aMsg.routing_id() == MSG_ROUTING_NONE) {
         NS_RUNTIMEABORT("unhandled special message!");
     }
 
     MaybeHandleError(mListener->OnMessageReceived(aMsg), "DispatchAsyncMessage");
 }
 
 void
-MessageChannel::DispatchRPCMessage(const Message& aMsg, size_t stackDepth)
+MessageChannel::DispatchInterruptMessage(const Message& aMsg, size_t stackDepth)
 {
     AssertWorkerThread();
     mMonitor->AssertNotCurrentThreadOwns();
 
-    IPC_ASSERT(aMsg.is_rpc() && !aMsg.is_reply(), "wrong message type");
+    IPC_ASSERT(aMsg.is_interrupt() && !aMsg.is_reply(), "wrong message type");
 
     // Race detection: see the long comment near mRemoteStackDepthGuess in
-    // RPCChannel.h. "Remote" stack depth means our side, and "local" means
+    // MessageChannel.h. "Remote" stack depth means our side, and "local" means
     // the other side.
-    if (aMsg.rpc_remote_stack_depth_guess() != RemoteViewOfStackDepth(stackDepth)) {
-        // RPC in-calls have raced. The winner, if there is one, gets to defer
+    if (aMsg.interrupt_remote_stack_depth_guess() != RemoteViewOfStackDepth(stackDepth)) {
+        // Interrupt in-calls have raced. The winner, if there is one, gets to defer
         // processing of the other side's in-call.
         bool defer;
         const char* winner;
-        switch (mListener->MediateRPCRace((mSide == ChildSide) ? aMsg : mRPCStack.top(),
-                                          (mSide != ChildSide) ? mRPCStack.top() : aMsg))
+        switch (mListener->MediateInterruptRace((mSide == ChildSide) ? aMsg : mInterruptStack.top(),
+                                          (mSide != ChildSide) ? mInterruptStack.top() : aMsg))
         {
-          case RRPChildWins:
+          case RIPChildWins:
             winner = "child";
             defer = (mSide == ChildSide);
             break;
-          case RRPParentWins:
+          case RIPParentWins:
             winner = "parent";
             defer = (mSide != ChildSide);
             break;
-          case RRPError:
-            NS_RUNTIMEABORT("NYI: 'Error' RPC race policy");
+          case RIPError:
+            NS_RUNTIMEABORT("NYI: 'Error' Interrupt race policy");
             return;
           default:
             NS_RUNTIMEABORT("not reached");
             return;
         }
 
         if (LoggingEnabled()) {
             printf_stderr("  (%s: %s won, so we're%sdeferring)\n",
@@ -847,20 +847,20 @@ MessageChannel::DispatchRPCMessage(const
 #endif
 
     Message* reply = nullptr;
 
     ++mRemoteStackDepthGuess;
     Result rv = mListener->OnCallReceived(aMsg, reply);
     --mRemoteStackDepthGuess;
 
-    if (!MaybeHandleError(rv, "DispatchRPCMessage")) {
+    if (!MaybeHandleError(rv, "DispatchInterruptMessage")) {
         delete reply;
         reply = new Message();
-        reply->set_rpc();
+        reply->set_interrupt();
         reply->set_reply();
         reply->set_reply_error();
     }
     reply->set_seqno(aMsg.seqno());
 
     MonitorAutoLock lock(*mMonitor);
     if (ChannelConnected == mChannelState)
         mLink->SendMessage(reply);
@@ -870,67 +870,67 @@ void
 MessageChannel::MaybeUndeferIncall()
 {
     AssertWorkerThread();
     mMonitor->AssertCurrentThreadOwns();
 
     if (mDeferred.empty())
         return;
 
-    size_t stackDepth = RPCStackDepth();
+    size_t stackDepth = InterruptStackDepth();
 
     // the other side can only *under*-estimate our actual stack depth
-    IPC_ASSERT(mDeferred.top().rpc_remote_stack_depth_guess() <= stackDepth,
+    IPC_ASSERT(mDeferred.top().interrupt_remote_stack_depth_guess() <= stackDepth,
                "fatal logic error");
 
-    if (mDeferred.top().rpc_remote_stack_depth_guess() < RemoteViewOfStackDepth(stackDepth))
+    if (mDeferred.top().interrupt_remote_stack_depth_guess() < RemoteViewOfStackDepth(stackDepth))
         return;
 
     // maybe time to process this message
     Message call = mDeferred.top();
     mDeferred.pop();
 
     // fix up fudge factor we added to account for race
     IPC_ASSERT(0 < mRemoteStackDepthGuess, "fatal logic error");
     --mRemoteStackDepthGuess;
 
     mPending.push_back(call);
 }
 
 void
-MessageChannel::FlushPendingRPCQueue()
+MessageChannel::FlushPendingInterruptQueue()
 {
     AssertWorkerThread();
     mMonitor->AssertNotCurrentThreadOwns();
 
     {
         MonitorAutoLock lock(*mMonitor);
 
         if (mDeferred.empty()) {
             if (mPending.empty())
                 return;
 
             const Message& last = mPending.back();
-            if (!last.is_rpc() || last.is_reply())
+            if (!last.is_interrupt() || last.is_reply())
                 return;
         }
     }
 
     while (OnMaybeDequeueOne());
 }
 
 void
 MessageChannel::ExitedCxxStack()
 {
     mListener->OnExitedCxxStack();
-    if (mSawRPCOutMsg) {
+    if (mSawInterruptOutMsg) {
         MonitorAutoLock lock(*mMonitor);
         // see long comment in OnMaybeDequeueOne()
         EnqueuePendingMessages();
-        mSawRPCOutMsg = false;
+        mSawInterruptOutMsg = false;
     }
 }
 
 void
 MessageChannel::EnqueuePendingMessages()
 {
     AssertWorkerThread();
     mMonitor->AssertCurrentThreadOwns();
@@ -985,17 +985,17 @@ MessageChannel::WaitForSyncNotify()
     mMonitor->Wait(timeout);
 
     // If the timeout didn't expire, we know we received an event. The
     // converse is not true.
     return WaitResponse(IsTimeoutExpired(waitStart, timeout));
 }
 
 bool
-MessageChannel::WaitForRPCNotify()
+MessageChannel::WaitForInterruptNotify()
 {
     return WaitForSyncNotify();
 }
 
 void
 MessageChannel::NotifyWorkerThread()
 {
     mMonitor->Notify();
@@ -1025,18 +1025,18 @@ MessageChannel::ShouldContinueFromTimeou
 
     if (!cont) {
         // NB: there's a sublety here.  If parents were allowed to send sync
         // messages to children, then it would be possible for this
         // synchronous close-on-timeout to race with async |OnMessageReceived|
         // tasks arriving from the child, posted to the worker thread's event
         // loop.  This would complicate cleanup of the *Channel.  But since
         // IPDL forbids this (and since it doesn't support children timing out
-        // on parents), the parent can only block on RPC messages to the child,
-        // and in that case arriving async messages are enqueued to the RPC
+        // on parents), the parent can only block on interrupt messages to the child,
+        // and in that case arriving async messages are enqueued to the interrupt 
         // channel's special queue.  They're then ignored because the channel
         // state changes to ChannelTimeout (i.e. !Connected).
         SynchronouslyClose();
         mChannelState = ChannelTimeout;
     }
 
     return cont;
 }
@@ -1149,17 +1149,17 @@ MessageChannel::MaybeHandleError(Result 
 }
 
 void
 MessageChannel::OnChannelErrorFromLink()
 {
     AssertLinkThread();
     mMonitor->AssertCurrentThreadOwns();
 
-    if (RPCStackDepth() > 0)
+    if (InterruptStackDepth() > 0)
         NotifyWorkerThread();
 
     if (AwaitingSyncReply())
         NotifyWorkerThread();
 
     if (ChannelClosing != mChannelState) {
         mChannelState = ChannelError;
         mMonitor->Notify();
@@ -1322,52 +1322,52 @@ MessageChannel::NotifyChannelClosed()
     Clear();
 }
 
 void
 MessageChannel::DebugAbort(const char* file, int line, const char* cond,
                            const char* why,
                            bool reply) const
 {
-    printf_stderr("###!!! [RPCChannel][%s][%s:%d] "
+    printf_stderr("###!!! [MessageChannel][%s][%s:%d] "
                   "Assertion (%s) failed.  %s %s\n",
                   mSide == ChildSide ? "Child" : "Parent",
                   file, line, cond,
                   why,
                   reply ? "(reply)" : "");
     // technically we need the mutex for this, but we're dying anyway
-    DumpRPCStack("  ");
-    printf_stderr("  remote RPC stack guess: %lu\n",
+    DumpInterruptStack("  ");
+    printf_stderr("  remote Interrupt stack guess: %lu\n",
                   mRemoteStackDepthGuess);
     printf_stderr("  deferred stack size: %lu\n",
                   mDeferred.size());
-    printf_stderr("  out-of-turn RPC replies stack size: %lu\n",
+    printf_stderr("  out-of-turn Interrupt replies stack size: %lu\n",
                   mOutOfTurnReplies.size());
     printf_stderr("  Pending queue size: %lu, front to back:\n",
                   mPending.size());
 
     MessageQueue pending = mPending;
     while (!pending.empty()) {
         printf_stderr("    [ %s%s ]\n",
-                      pending.front().is_rpc() ? "rpc" :
+                      pending.front().is_interrupt() ? "intr" :
                       (pending.front().is_sync() ? "sync" : "async"),
                       pending.front().is_reply() ? "reply" : "");
         pending.pop_front();
     }
 
     NS_RUNTIMEABORT(why);
 }
 
 void
-MessageChannel::DumpRPCStack(const char* const pfx) const
+MessageChannel::DumpInterruptStack(const char* const pfx) const
 {
     NS_WARN_IF_FALSE(MessageLoop::current() != mWorkerLoop,
                      "The worker thread had better be paused in a debugger!");
 
-    printf_stderr("%sRPCChannel 'backtrace':\n", pfx);
+    printf_stderr("%sMessageChannel 'backtrace':\n", pfx);
 
     // print a python-style backtrace, first frame to last
     for (uint32_t i = 0; i < mCxxStackFrames.size(); ++i) {
         int32_t id;
         const char* dir, *sems, *name;
         mCxxStackFrames[i].Describe(&id, &dir, &sems, &name);
 
         printf_stderr("%s[(%u) %s %s %s(actor=%d) ]\n", pfx,
--- a/ipc/glue/MessageChannel.h
+++ b/ipc/glue/MessageChannel.h
@@ -83,26 +83,26 @@ class MessageChannel : HasResultCodes
 
     // Asynchronously deliver a message back to this side of the
     // channel
     bool Echo(Message* aMsg);
 
     // Synchronously send |msg| (i.e., wait for |reply|)
     bool Send(Message* aMsg, Message* aReply);
 
-    // Make an RPC to the other side of the channel
+    // Make an Interrupt call to the other side of the channel
     bool Call(Message* aMsg, Message* aReply);
 
     void SetReplyTimeoutMs(int32_t aTimeoutMs);
 
     bool IsOnCxxStack() const {
         return !mCxxStackFrames.empty();
     }
 
-    void FlushPendingRPCQueue();
+    void FlushPendingInterruptQueue();
 
     // Unsound_IsClosed and Unsound_NumQueuedMessages are safe to call from any
     // thread, but they make no guarantees about whether you'll get an
     // up-to-date value; the values are written on one thread and read without
     // locking, on potentially different threads.  Thus you should only use
     // them when you don't particularly care about getting a recent value (e.g.
     // in a memory report).
     bool Unsound_IsClosed() const {
@@ -117,20 +117,20 @@ class MessageChannel : HasResultCodes
     }
     static void SetIsPumpingMessages(bool aIsPumping) {
         sIsPumpingMessages = aIsPumping;
     }
 
 #ifdef OS_WIN
     struct MOZ_STACK_CLASS SyncStackFrame
     {
-        SyncStackFrame(MessageChannel* channel, bool rpc);
+        SyncStackFrame(MessageChannel* channel, bool interrupt);
         ~SyncStackFrame();
 
-        bool mRPC;
+        bool mInterrupt;
         bool mSpinNestedEvents;
         bool mListenerNotified;
         MessageChannel* mChannel;
 
         // The previous stack frame for this channel.
         SyncStackFrame* mPrev;
 
         // The previous stack frame on any channel.
@@ -149,17 +149,17 @@ class MessageChannel : HasResultCodes
   protected:
     // The deepest sync stack frame for this channel.
     SyncStackFrame* mTopFrame;
 
     // The deepest sync stack frame on any channel.
     static SyncStackFrame* sStaticTopFrame;
 
   public:
-    void ProcessNativeEventsInRPCCall();
+    void ProcessNativeEventsInInterruptCall();
     static void NotifyGeckoEventDispatch();
 
   private:
     void SpinInternalEventLoop();
 #endif
 
   private:
     void CommonThreadOpenInit(MessageChannel *aTargetChan, Side aSide);
@@ -184,57 +184,57 @@ class MessageChannel : HasResultCodes
     // SendAndWait() expects that the worker thread owns the monitor, and that
     // the message has been prepared to be sent over the link. It returns as
     // soon as a reply has been received, or an error has occurred.
     //
     // Note that while the child is blocked waiting for a sync reply, it can wake
     // up to process urgent calls from the parent.
     bool SendAndWait(Message* aMsg, Message* aReply);
 
-    bool RPCCall(Message* aMsg, Message* aReply);
+    bool InterruptCall(Message* aMsg, Message* aReply);
     bool UrgentCall(Message* aMsg, Message* aReply);
 
-    bool RPCEventOccurred();
+    bool InterruptEventOccurred();
 
     void MaybeUndeferIncall();
     void EnqueuePendingMessages();
 
     // Executed on the worker thread. Dequeues one pending message.
     bool OnMaybeDequeueOne();
 
     // Dispatches an incoming message to its appropriate handler.
     void DispatchMessage(const Message &aMsg);
 
     // DispatchMessage will route to one of these functions depending on the
     // protocol type of the message.
     void DispatchSyncMessage(const Message &aMsg);
     void DispatchUrgentMessage(const Message &aMsg);
     void DispatchAsyncMessage(const Message &aMsg);
-    void DispatchRPCMessage(const Message &aMsg, size_t aStackDepth);
+    void DispatchInterruptMessage(const Message &aMsg, size_t aStackDepth);
 
     // Return true if the wait ended because a notification was received.
     //
     // Return false if the time elapsed from when we started the process of
     // waiting until afterwards exceeded the currently allotted timeout.
     // That *DOES NOT* mean false => "no event" (== timeout); there are many
     // circumstances that could cause the measured elapsed time to exceed the
     // timeout EVEN WHEN we were notified.
     //
     // So in sum: true is a meaningful return value; false isn't,
     // necessarily.
     bool WaitForSyncNotify();
-    bool WaitForRPCNotify();
+    bool WaitForInterruptNotify();
 
     bool WaitResponse(bool aWaitTimedOut);
 
     bool ShouldContinueFromTimeout();
 
     // The "remote view of stack depth" can be different than the
     // actual stack depth when there are out-of-turn replies.  When we
-    // receive one, our actual RPC stack depth doesn't decrease, but
+    // receive one, our actual Interrupt stack depth doesn't decrease, but
     // the other side (that sent the reply) thinks it has.  So, the
     // "view" returned here is |stackDepth| minus the number of
     // out-of-turn replies.
     //
     // Only called from the worker thread.
     size_t RemoteViewOfStackDepth(size_t stackDepth) const {
         AssertWorkerThread();
         return stackDepth - mOutOfTurnReplies.size();
@@ -242,18 +242,17 @@ class MessageChannel : HasResultCodes
 
     int32_t NextSeqno() {
         AssertWorkerThread();
         return (mSide == ChildSide) ? --mNextSeqno : ++mNextSeqno;
     }
 
     // This helper class manages mCxxStackDepth on behalf of MessageChannel.
     // When the stack depth is incremented from zero to non-zero, it invokes
-    // an RPCChannel callback, and similarly for when the depth goes from
-    // non-zero to zero.
+    // a callback, and similarly for when the depth goes from non-zero to zero.
     void EnteredCxxStack() {
        mListener->OnEnteredCxxStack();
     }
 
     void ExitedCxxStack();
 
     void EnteredCall() {
         mListener->OnEnteredCall();
@@ -263,34 +262,34 @@ class MessageChannel : HasResultCodes
         mListener->OnExitedCall();
     }
 
     MessageListener *Listener() const {
         return mListener.get();
     }
 
     enum Direction { IN_MESSAGE, OUT_MESSAGE };
-    struct RPCFrame {
-        RPCFrame(Direction direction, const Message* msg)
+    struct InterruptFrame {
+        InterruptFrame(Direction direction, const Message* msg)
           : mDirection(direction), mMsg(msg)
         { }
 
-        bool IsRPCIncall() const {
-            return mMsg->is_rpc() && IN_MESSAGE == mDirection;
+        bool IsInterruptIncall() const {
+            return mMsg->is_interrupt() && IN_MESSAGE == mDirection;
         }
-        bool IsRPCOutcall() const {
-            return mMsg->is_rpc() && OUT_MESSAGE == mDirection;
+        bool IsInterruptOutcall() const {
+            return mMsg->is_interrupt() && OUT_MESSAGE == mDirection;
         }
 
         void Describe(int32_t* id, const char** dir, const char** sems,
                       const char** name) const
         {
             *id = mMsg->routing_id();
             *dir = (IN_MESSAGE == mDirection) ? "in" : "out";
-            *sems = mMsg->is_rpc() ? "rpc" : mMsg->is_sync() ? "sync" : "async";
+            *sems = mMsg->is_interrupt() ? "intr" : mMsg->is_sync() ? "sync" : "async";
             *name = mMsg->name();
         }
 
         Direction mDirection;
         const Message* mMsg;
     };
 
     class MOZ_STACK_CLASS CxxStackFrame
@@ -299,27 +298,27 @@ class MessageChannel : HasResultCodes
         CxxStackFrame(MessageChannel& that, Direction direction, const Message* msg)
           : mThat(that)
         {
             mThat.AssertWorkerThread();
 
             if (mThat.mCxxStackFrames.empty())
                 mThat.EnteredCxxStack();
 
-            mThat.mCxxStackFrames.push_back(RPCFrame(direction, msg));
-            const RPCFrame& frame = mThat.mCxxStackFrames.back();
+            mThat.mCxxStackFrames.push_back(InterruptFrame(direction, msg));
+            const InterruptFrame& frame = mThat.mCxxStackFrames.back();
 
-            if (frame.IsRPCIncall())
+            if (frame.IsInterruptIncall())
                 mThat.EnteredCall();
 
-            mThat.mSawRPCOutMsg |= frame.IsRPCOutcall();
+            mThat.mSawInterruptOutMsg |= frame.IsInterruptOutcall();
         }
 
         ~CxxStackFrame() {
-            bool exitingCall = mThat.mCxxStackFrames.back().IsRPCIncall();
+            bool exitingCall = mThat.mCxxStackFrames.back().IsInterruptIncall();
             mThat.mCxxStackFrames.pop_back();
             bool exitingStack = mThat.mCxxStackFrames.empty();
 
             // mListener could have gone away if Close() was called while
             // MessageChannel code was still on the stack
             if (!mThat.mListener)
                 return;
 
@@ -340,37 +339,37 @@ class MessageChannel : HasResultCodes
     };
 
     void DebugAbort(const char* file, int line, const char* cond,
                     const char* why,
                     bool reply=false) const;
 
     // This method is only safe to call on the worker thread, or in a
     // debugger with all threads paused.
-    void DumpRPCStack(const char* const pfx="") const;
+    void DumpInterruptStack(const char* const pfx="") const;
 
   private:
     // Called from both threads
-    size_t RPCStackDepth() const {
+    size_t InterruptStackDepth() const {
         mMonitor->AssertCurrentThreadOwns();
-        return mRPCStack.size();
+        return mInterruptStack.size();
     }
 
     // Returns true if we're blocking waiting for a reply.
     bool AwaitingSyncReply() const {
         mMonitor->AssertCurrentThreadOwns();
         return mPendingSyncReplies > 0;
     }
     bool AwaitingUrgentReply() const {
         mMonitor->AssertCurrentThreadOwns();
         return mPendingUrgentReplies > 0;
     }
-    bool AwaitingRPCReply() const {
+    bool AwaitingInterruptReply() const {
         mMonitor->AssertCurrentThreadOwns();
-        return !mRPCStack.empty();
+        return !mInterruptStack.empty();
     }
 
     // Returns true if we're dispatching a sync message's callback.
     bool DispatchingSyncMessage() const {
         return mDispatchingSyncMessage;
     }
 
     bool Connected() const;
@@ -512,67 +511,67 @@ class MessageChannel : HasResultCodes
     // messages, which are delivered directly to mRecvd, and any pending urgent
     // incall, which is stored in mPendingUrgentRequest.
     //
     // If both this side and the other side are functioning correctly, the queue
     // can only be in certain configurations.  Let
     //
     //   |A<| be an async in-message,
     //   |S<| be a sync in-message,
-    //   |C<| be an RPC in-call,
-    //   |R<| be an RPC reply.
+    //   |C<| be an Interrupt in-call,
+    //   |R<| be an Interrupt reply.
     //
     // The queue can only match this configuration
     //
     //  A<* (S< | C< | R< (?{mStack.size() == 1} A<* (S< | C<)))
     //
     // The other side can send as many async messages |A<*| as it wants before
     // sending us a blocking message.
     //
     // The first case is |S<|, a sync in-msg.  The other side must be blocked,
     // and thus can't send us any more messages until we process the sync
     // in-msg.
     //
-    // The second case is |C<|, an RPC in-call; the other side must be blocked.
+    // The second case is |C<|, an Interrupt in-call; the other side must be blocked.
     // (There's a subtlety here: this in-call might have raced with an
     // out-call, but we detect that with the mechanism below,
     // |mRemoteStackDepth|, and races don't matter to the queue.)
     //
     // Final case, the other side replied to our most recent out-call |R<|.
     // If that was the *only* out-call on our stack, |?{mStack.size() == 1}|,
     // then other side "finished with us," and went back to its own business.
     // That business might have included sending any number of async message
     // |A<*| until sending a blocking message |(S< | C<)|.  If we had more than
-    // one RPC call on our stack, the other side *better* not have sent us
+    // one Interrupt call on our stack, the other side *better* not have sent us
     // another blocking message, because it's blocked on a reply from us.
     //
     MessageQueue mPending;
     nsAutoPtr<Message> mPendingUrgentRequest;
 
     // Stack of all the out-calls on which this channel is awaiting responses.
     // Each stack refers to a different protocol and the stacks are mutually
     // exclusive: multiple outcalls of the same kind cannot be initiated while
     // another is active.
-    std::stack<Message> mRPCStack;
+    std::stack<Message> mInterruptStack;
 
-    // This is what we think the RPC stack depth is on the "other side" of this
-    // RPC channel.  We maintain this variable so that we can detect racy RPC
-    // calls.  With each RPC out-call sent, we send along what *we* think the
-    // stack depth of the remote side is *before* it will receive the RPC call.
+    // This is what we think the Interrupt stack depth is on the "other side" of this
+    // Interrupt channel.  We maintain this variable so that we can detect racy Interrupt
+    // calls.  With each Interrupt out-call sent, we send along what *we* think the
+    // stack depth of the remote side is *before* it will receive the Interrupt call.
     //
     // After sending the out-call, our stack depth is "incremented" by pushing
     // that pending message onto mPending.
     //
     // Then when processing an in-call |c|, it must be true that
     //
     //   mStack.size() == c.remoteDepth
     //
     // I.e., my depth is actually the same as what the other side thought it
     // was when it sent in-call |c|.  If this fails to hold, we have detected
-    // racy RPC calls.
+    // racy Interrupt calls.
     //
     // We then increment mRemoteStackDepth *just before* processing the
     // in-call, since we know the other side is waiting on it, and decrement
     // it *just after* finishing processing that in-call, since our response
     // will pop the top of the other side's |mPending|.
     //
     // One nice aspect of this race detection is that it is symmetric; if one
     // side detects a race, then the other side must also detect the same race.
@@ -581,28 +580,28 @@ class MessageChannel : HasResultCodes
     // Approximation of code frames on the C++ stack. It can only be
     // interpreted as the implication:
     //
     //  !mCxxStackFrames.empty() => MessageChannel code on C++ stack
     //
     // This member is only accessed on the worker thread, and so is not
     // protected by mMonitor.  It is managed exclusively by the helper
     // |class CxxStackFrame|.
-    std::vector<RPCFrame> mCxxStackFrames;
+    std::vector<InterruptFrame> mCxxStackFrames;
 
-    // Did we process an RPC out-call during this stack?  Only meaningful in
+    // Did we process an Interrupt out-call during this stack?  Only meaningful in
     // ExitedCxxStack(), from which this variable is reset.
-    bool mSawRPCOutMsg;
+    bool mSawInterruptOutMsg;
 
-    // Map of replies received "out of turn", because of RPC
+    // Map of replies received "out of turn", because of Interrupt
     // in-calls racing with replies to outstanding in-calls.  See
     // https://bugzilla.mozilla.org/show_bug.cgi?id=521929.
     MessageMap mOutOfTurnReplies;
 
-    // Stack of RPC in-calls that were deferred because of race
+    // Stack of Interrupt in-calls that were deferred because of race
     // conditions.
     std::stack<Message> mDeferred;
 
 #ifdef OS_WIN
     HANDLE mEvent;
 #endif
 };
 
--- a/ipc/glue/MessageLink.h
+++ b/ipc/glue/MessageLink.h
@@ -43,21 +43,21 @@ enum ChannelState {
     ChannelClosed,
     ChannelOpening,
     ChannelConnected,
     ChannelTimeout,
     ChannelClosing,
     ChannelError
 };
 
-// What happens if RPC calls race?
-enum RacyRPCPolicy {
-    RRPError,
-    RRPChildWins,
-    RRPParentWins
+// What happens if Interrupt calls race?
+enum RacyInterruptPolicy {
+    RIPError,
+    RIPChildWins,
+    RIPParentWins
 };
 
 class MessageListener
   : protected HasResultCodes,
     public mozilla::SupportsWeakPtr<MessageListener>
 {
   public:
     typedef IPC::Message Message;
@@ -82,23 +82,23 @@ class MessageListener
         NS_RUNTIMEABORT("default impl shouldn't be invoked");
     }
     virtual void OnEnteredCall() {
         NS_RUNTIMEABORT("default impl shouldn't be invoked");
     }
     virtual void OnExitedCall() {
         NS_RUNTIMEABORT("default impl shouldn't be invoked");
     }
-    virtual RacyRPCPolicy MediateRPCRace(const Message& parent,
-                                         const Message& child)
+    virtual RacyInterruptPolicy MediateInterruptRace(const Message& parent,
+                                                     const Message& child)
     {
-        return RRPChildWins;
+        return RIPChildWins;
     }
 
-    virtual void ProcessRemoteNativeEventsInRPCCall() {
+    virtual void ProcessRemoteNativeEventsInInterruptCall() {
     }
 
     // FIXME/bug 792652: this doesn't really belong here, but a
     // large refactoring is needed to put it where it belongs.
     virtual int32_t GetProtocolTypeId() = 0;
 };
 
 class MessageLink
--- a/ipc/glue/WindowsMessageLoop.cpp
+++ b/ipc/glue/WindowsMessageLoop.cpp
@@ -56,18 +56,18 @@ using namespace mozilla::ipc::windows;
  * miniature message loop during a sync IPC call. We avoid processing any
  * queued messages during the loop (with one exception, see below), but 
  * "nonqueued" messages (see 
  * http://msdn.microsoft.com/en-us/library/ms644927(VS.85).aspx under the
  * section "Nonqueued messages") cannot be avoided. Those messages are trapped
  * in a special window procedure where we can either ignore the message or
  * process it in some fashion.
  *
- * Queued and "non-queued" messages will be processed during RPC calls if
- * modal UI related api calls block an RPC in-call in the child. To prevent
+ * Queued and "non-queued" messages will be processed during Interrupt calls if
+ * modal UI related api calls block an Interrupt in-call in the child. To prevent
  * windows from freezing, and to allow concurrent processing of critical
  * events (such as painting), we spin a native event dispatch loop while
  * these in-calls are blocked.
  */
 
 #if defined(ACCESSIBILITY)
 // pulled from accessibility's win utils
 extern const PRUnichar* kPropNameTabContent;
@@ -582,18 +582,18 @@ TimeoutHasExpired(const TimeoutData& aDa
     // Overflow
     return now < aData.startTicks && now >= aData.targetTicks;
   }
   return now >= aData.targetTicks;
 }
 
 } // anonymous namespace
 
-MessageChannel::SyncStackFrame::SyncStackFrame(MessageChannel* channel, bool rpc)
-  : mRPC(rpc)
+MessageChannel::SyncStackFrame::SyncStackFrame(MessageChannel* channel, bool interrupt)
+  : mInterrupt(interrupt)
   , mSpinNestedEvents(false)
   , mListenerNotified(false)
   , mChannel(channel)
   , mPrev(mChannel->mTopFrame)
   , mStaticPrev(sStaticTopFrame)
 {
   mChannel->mTopFrame = this;
   sStaticTopFrame = this;
@@ -603,66 +603,66 @@ MessageChannel::SyncStackFrame::SyncStac
     gNeuteredWindows = new nsAutoTArray<HWND, 20>();
     NS_ASSERTION(gNeuteredWindows, "Out of memory!");
   }
 }
 
 MessageChannel::SyncStackFrame::~SyncStackFrame()
 {
   NS_ASSERTION(this == mChannel->mTopFrame,
-               "Mismatched RPC stack frames");
+               "Mismatched interrupt stack frames");
   NS_ASSERTION(this == sStaticTopFrame,
-               "Mismatched static RPC stack frames");
+               "Mismatched static Interrupt stack frames");
 
   mChannel->mTopFrame = mPrev;
   sStaticTopFrame = mStaticPrev;
 
   if (!mStaticPrev) {
     NS_ASSERTION(gNeuteredWindows, "Bad pointer!");
     delete gNeuteredWindows;
     gNeuteredWindows = nullptr;
   }
 }
 
 MessageChannel::SyncStackFrame* MessageChannel::sStaticTopFrame;
 
 // nsAppShell's notification that gecko events are being processed.
-// If we are here and there is an RPC Incall active, we are spinning
+// If we are here and there is an Interrupt Incall active, we are spinning
 // a nested gecko event loop. In which case the remote process needs
 // to know about it.
 void /* static */
 MessageChannel::NotifyGeckoEventDispatch()
 {
-  // sStaticTopFrame is only valid for RPC channels
+  // sStaticTopFrame is only valid for Interrupt channels
   if (!sStaticTopFrame || sStaticTopFrame->mListenerNotified)
     return;
 
   sStaticTopFrame->mListenerNotified = true;
   MessageChannel* channel = static_cast<MessageChannel*>(sStaticTopFrame->mChannel);
-  channel->Listener()->ProcessRemoteNativeEventsInRPCCall();
+  channel->Listener()->ProcessRemoteNativeEventsInInterruptCall();
 }
 
 // invoked by the module that receives the spin event loop
 // message.
 void
-MessageChannel::ProcessNativeEventsInRPCCall()
+MessageChannel::ProcessNativeEventsInInterruptCall()
 {
   if (!mTopFrame) {
-    NS_ERROR("Spin logic error: no RPC frame");
+    NS_ERROR("Spin logic error: no Interrupt frame");
     return;
   }
 
   mTopFrame->mSpinNestedEvents = true;
 }
 
 // Spin loop is called in place of WaitFor*Notify when modal ui is being shown
 // in a child. There are some intricacies in using it however. Spin loop is
-// enabled for a particular RPC frame by the client calling
-// MessageChannel::ProcessNativeEventsInRPCCall().
-// This call can be nested for multiple RPC frames in a single plugin or 
+// enabled for a particular Interrupt frame by the client calling
+// MessageChannel::ProcessNativeEventsInInterrupt().
+// This call can be nested for multiple Interrupt frames in a single plugin or 
 // multiple unrelated plugins.
 void
 MessageChannel::SpinInternalEventLoop()
 {
   if (mozilla::PaintTracker::IsPainting()) {
     NS_RUNTIMEABORT("Don't spin an event loop while painting.");
   }
 
@@ -717,17 +717,17 @@ MessageChannel::SpinInternalEventLoop()
 bool
 MessageChannel::WaitForSyncNotify()
 {
   mMonitor->AssertCurrentThreadOwns();
 
   // Initialize global objects used in deferred messaging.
   Init();
 
-  NS_ASSERTION(mTopFrame && !mTopFrame->mRPC,
+  NS_ASSERTION(mTopFrame && !mTopFrame->mInterrupt,
                "Top frame is not a sync frame!");
 
   MonitorAutoUnlock unlock(*mMonitor);
 
   bool timedout = false;
 
   UINT_PTR timerId = 0;
   TimeoutData timeoutData = { 0 };
@@ -832,29 +832,29 @@ MessageChannel::WaitForSyncNotify()
   }
 
   MessageChannel::SetIsPumpingMessages(false);
 
   return WaitResponse(timedout);
 }
 
 bool
-MessageChannel::WaitForRPCNotify()
+MessageChannel::WaitForInterruptNotify()
 {
   mMonitor->AssertCurrentThreadOwns();
 
-  if (!RPCStackDepth()) {
+  if (!InterruptStackDepth()) {
     // There is currently no way to recover from this condition.
     NS_RUNTIMEABORT("StackDepth() is 0 in call to MessageChannel::WaitForNotify!");
   }
 
   // Initialize global objects used in deferred messaging.
   Init();
 
-  NS_ASSERTION(mTopFrame && mTopFrame->mRPC,
+  NS_ASSERTION(mTopFrame && mTopFrame->mInterrupt,
                "Top frame is not a sync frame!");
 
   MonitorAutoUnlock unlock(*mMonitor);
 
   bool timedout = false;
 
   UINT_PTR timerId = 0;
   TimeoutData timeoutData = { 0 };
--- a/ipc/ipdl/ipdl/ast.py
+++ b/ipc/ipdl/ipdl/ast.py
@@ -192,18 +192,18 @@ class UsingStmt(Node):
 
 # "singletons"
 class ASYNC:
     pretty = 'async'
     @classmethod
     def __hash__(cls): return hash(cls.pretty)
     @classmethod
     def __str__(cls):  return cls.pretty
-class RPC:
-    pretty = 'rpc'
+class INTR:
+    pretty = 'intr'
     @classmethod
     def __hash__(cls): return hash(cls.pretty)
     @classmethod
     def __str__(cls):  return cls.pretty
 class SYNC:
     pretty = 'sync'
     @classmethod
     def __hash__(cls): return hash(cls.pretty)
@@ -237,21 +237,21 @@ class OUT:
     @classmethod
     def __str__(cls):  return cls.pretty
     @staticmethod
     def prettySS(ss): return _prettyTable['out'][ss.pretty]
 
 _prettyTable = {
     IN  : { 'async': 'AsyncRecv',
             'sync': 'SyncRecv',
-            'rpc': 'RpcAnswer',
+            'intr': 'IntrAnswer',
             'urgent': 'UrgentAnswer' },
     OUT : { 'async': 'AsyncSend',
             'sync': 'SyncSend',
-            'rpc': 'RpcCall',
+            'intr': 'IntrCall',
             'urgent': 'UrgentCall' }
     # inout doesn't make sense here
 }
 
 
 class Namespace(Node):
     def __init__(self, loc, namespace):
         Node.__init__(self, loc)
@@ -327,17 +327,17 @@ class MessageDecl(Node):
 
     def addInParams(self, inParamsList):
         self.inParams += inParamsList
 
     def addOutParams(self, outParamsList):
         self.outParams += outParamsList
 
     def hasReply(self):
-        return self.sendSemantics is SYNC or self.sendSemantics is RPC
+        return self.sendSemantics is SYNC or self.sendSemantics is INTR
 
 class Transition(Node):
     def __init__(self, loc, trigger, msg, toStates):
         Node.__init__(self, loc)
         self.trigger = trigger
         self.msg = msg
         self.toStates = toStates
 
--- a/ipc/ipdl/ipdl/cgen.py
+++ b/ipc/ipdl/ipdl/cgen.py
@@ -1,16 +1,16 @@
 # 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/.
 
 import os, sys
 
 from ipdl.ast import Visitor
-from ipdl.ast import IN, OUT, INOUT, ASYNC, SYNC, RPC, URGENT
+from ipdl.ast import IN, OUT, INOUT, ASYNC, SYNC, INTR, URGENT
 
 class CodePrinter:
     def __init__(self, outf=sys.stdout, indentCols=4):
         self.outf = outf
         self.col = 0
         self.indentCols = indentCols
 
     def write(self, str):
--- a/ipc/ipdl/ipdl/lower.py
+++ b/ipc/ipdl/ipdl/lower.py
@@ -272,23 +272,23 @@ def _putInNamespaces(cxxthing, namespace
         newns = Namespace(ns.name)
         innerns.addstmt(newns)
         innerns = newns
     innerns.addstmt(cxxthing)
     return outerns
 
 def _sendPrefix(msgtype):
     """Prefix of the name of the C++ method that sends |msgtype|."""
-    if msgtype.isRpc() or msgtype.isUrgent():
+    if msgtype.isInterrupt() or msgtype.isUrgent():
         return 'Call'
     return 'Send'
 
 def _recvPrefix(msgtype):
     """Prefix of the name of the C++ method that handles |msgtype|."""
-    if msgtype.isRpc() or msgtype.isUrgent():
+    if msgtype.isInterrupt() or msgtype.isUrgent():
         return 'Answer'
     return 'Recv'
 
 def _flatTypeName(ipdltype):
     """Return a 'flattened' IPDL type name that can be used as an
 identifier.
 E.g., |Foo[]| --> |ArrayOfFoo|."""
     # NB: this logic depends heavily on what IPDL types are allowed to
@@ -2879,17 +2879,17 @@ class _GenerateProtocolActorCode(ipdl.as
                 Whitespace.NL ])
 
             # Close()
             closemeth = MethodDefn(MethodDecl('Close'))
             closemeth.addstmt(StmtExpr(
                 ExprCall(ExprSelect(p.channelVar(), '.', 'Close'))))
             self.cls.addstmts([ closemeth, Whitespace.NL ])
 
-            if ptype.talksSync() or ptype.talksRpc():
+            if ptype.talksSync() or ptype.talksInterrupt():
                 # SetReplyTimeoutMs()
                 timeoutvar = ExprVar('aTimeoutMs')
                 settimeout = MethodDefn(MethodDecl(
                     'SetReplyTimeoutMs',
                     params=[ Decl(Type.INT32, timeoutvar.name) ]))
                 settimeout.addstmt(StmtExpr(
                     ExprCall(
                         ExprSelect(p.channelVar(), '.', 'SetReplyTimeoutMs'),
@@ -2950,18 +2950,18 @@ class _GenerateProtocolActorCode(ipdl.as
         # actor handle instead
         handlevar = ExprVar('__handle')
         self.handlevar = handlevar
 
         msgtype = ExprCall(ExprSelect(msgvar, '.', 'type'), [ ])
         self.asyncSwitch = StmtSwitch(msgtype)
         if toplevel.talksSync():
             self.syncSwitch = StmtSwitch(msgtype)
-            if toplevel.talksRpc():
-                self.rpcSwitch = StmtSwitch(msgtype)
+            if toplevel.talksInterrupt():
+                self.interruptSwitch = StmtSwitch(msgtype)
 
         # implement Send*() methods and add dispatcher cases to
         # message switch()es
         for md in p.messageDecls:
             self.visitMessageDecl(md)
 
         # Handlers for the creation of actors when a new channel is
         # opened
@@ -2969,18 +2969,18 @@ class _GenerateProtocolActorCode(ipdl.as
             self.makeChannelOpenedHandlers(channelOpenedActors)
 
         # add default cases
         default = StmtBlock()
         default.addstmt(StmtReturn(_Result.NotKnown))
         self.asyncSwitch.addcase(DefaultLabel(), default)
         if toplevel.talksSync():
             self.syncSwitch.addcase(DefaultLabel(), default)
-            if toplevel.talksRpc():
-                self.rpcSwitch.addcase(DefaultLabel(), default)
+            if toplevel.talksInterrupt():
+                self.interruptSwitch.addcase(DefaultLabel(), default)
 
         # FIXME/bug 535053: only manager protocols and non-manager
         # protocols with union types need Lookup().  we'll give it to
         # all for the time being (simpler)
         if 1 or ptype.isManager():
             self.cls.addstmts(self.implementManagerIface())
 
         def makeHandlerMethod(name, switch, hasReply, dispatches=0):
@@ -3016,27 +3016,27 @@ class _GenerateProtocolActorCode(ipdl.as
                 routeif.ifb.addstmt(failif)
 
                 routeif.ifb.addstmt(StmtReturn(ExprCall(
                     ExprSelect(routedvar, '->', name),
                     args=[ ExprVar(p.name) for p in params ])))
 
                 method.addstmts([ routedecl, routeif, Whitespace.NL ])
 
-            # in the event of an RPC delete message, we want to loudly complain about
+            # in the event of an Interrupt delete message, we want to loudly complain about
             # messages that are received that are not a reply to the original message
             if ptype.hasReentrantDelete:
                 msgVar = ExprVar(params[0].name)
                 ifdying = StmtIf(ExprBinary(
                     ExprBinary(ExprVar('mState'), '==', _dyingState(ptype)),
                     '&&',
                     ExprBinary(
                         ExprBinary(ExprCall(ExprSelect(msgVar, '.', 'is_reply')), '!=', ExprLiteral.TRUE),
                         '||',
-                        ExprBinary(ExprCall(ExprSelect(msgVar, '.', 'is_rpc')), '!=', ExprLiteral.TRUE))))
+                        ExprBinary(ExprCall(ExprSelect(msgVar, '.', 'is_interrupt')), '!=', ExprLiteral.TRUE))))
                 ifdying.addifstmts([_fatalError('incoming message racing with actor deletion'),
                                     StmtReturn(_Result.Processed)])
                 method.addstmt(ifdying)
 
             # bug 509581: don't generate the switch stmt if there
             # is only the default case; MSVC doesn't like that
             if switch.nr_cases > 1:
                 method.addstmt(switch)
@@ -3046,27 +3046,27 @@ class _GenerateProtocolActorCode(ipdl.as
             return method
 
         dispatches = (ptype.isToplevel() and ptype.isManager())
         self.cls.addstmts([
             makeHandlerMethod('OnMessageReceived', self.asyncSwitch,
                               hasReply=0, dispatches=dispatches),
             Whitespace.NL
         ])
-        if not toplevel.talksRpc():
-          self.rpcSwitch = None
+        if not toplevel.talksInterrupt():
+          self.interruptSwitch = None
           if not toplevel.talksSync():
             self.syncSwitch = None
         self.cls.addstmts([
             makeHandlerMethod('OnMessageReceived', self.syncSwitch,
                               hasReply=1, dispatches=dispatches),
             Whitespace.NL
         ])
         self.cls.addstmts([
-            makeHandlerMethod('OnCallReceived', self.rpcSwitch,
+            makeHandlerMethod('OnCallReceived', self.interruptSwitch,
                               hasReply=1, dispatches=dispatches),
             Whitespace.NL
         ])
 
         destroysubtreevar = ExprVar('DestroySubtree')
         deallocsubtreevar = ExprVar('DeallocSubtree')
         deallocshmemvar = ExprVar('DeallocShmems')
 
@@ -3085,17 +3085,17 @@ class _GenerateProtocolActorCode(ipdl.as
 
         # int32_t GetProtocolTypeId() { return PFoo; }
         gettypetag = MethodDefn(
             MethodDecl('GetProtocolTypeId', ret=_actorTypeTagType()))
         gettypetag.addstmt(StmtReturn(_protocolId(ptype)))
         self.cls.addstmts([ gettypetag, Whitespace.NL ])
 
         # OnReplyTimeout()
-        if toplevel.talksSync() or toplevel.talksRpc():
+        if toplevel.talksSync() or toplevel.talksInterrupt():
             ontimeout = MethodDefn(
                 MethodDecl('OnReplyTimeout', ret=Type.BOOL))
 
             if ptype.isToplevel():
                 ontimeout.addstmt(StmtReturn(
                     ExprCall(p.shouldContinueFromTimeoutVar())))
             else:
                 ontimeout.addstmts([
@@ -3124,20 +3124,20 @@ class _GenerateProtocolActorCode(ipdl.as
             onexitedcall.addstmt(StmtReturn(ExprCall(p.exitedCallVar())))
 
             # bool IsOnCxxStack()
             onstack = MethodDefn(
                 MethodDecl(p.onCxxStackVar().name, ret=Type.BOOL, const=1))
             onstack.addstmt(StmtReturn(ExprCall(
                 ExprSelect(p.channelVar(), '.', p.onCxxStackVar().name))))
 
-            # void ProcessIncomingRacingRPCCall
+            # void ProcessIncomingRacingInterruptCall
             processincoming = MethodDefn(
-                MethodDecl('FlushPendingRPCQueue', ret=Type.VOID))
-            processincoming.addstmt(StmtExpr(ExprCall(ExprSelect(_actorChannel(ExprVar.THIS), '.', 'FlushPendingRPCQueue'))))
+                MethodDecl('FlushPendingInterruptQueue', ret=Type.VOID))
+            processincoming.addstmt(StmtExpr(ExprCall(ExprSelect(_actorChannel(ExprVar.THIS), '.', 'FlushPendingInterruptQueue'))))
 
             self.cls.addstmts([ onentered, onexited,
                                 onenteredcall, onexitedcall,
                                 onstack, processincoming, Whitespace.NL ])
 
         # OnChannelClose()
         onclose = MethodDefn(MethodDecl('OnChannelClose'))
         if ptype.isToplevel():
@@ -3173,26 +3173,26 @@ class _GenerateProtocolActorCode(ipdl.as
             onconnected.addstmt(
                 _runtimeAbort("'OnConnected' called on non-toplevel actor"))
 
         self.cls.addstmts([ onconnected, Whitespace.NL ])
 
         # User-facing shmem methods
         self.cls.addstmts(self.makeShmemIface())
 
-        if (ptype.isToplevel() and ptype.talksRpc()):
+        if (ptype.isToplevel() and ptype.talksInterrupt()):
 
             processnative = MethodDefn(
-                MethodDecl('ProcessNativeEventsInRPCCall', ret=Type.VOID))
+                MethodDecl('ProcessNativeEventsInInterruptCall', ret=Type.VOID))
 
             processnative.addstmts([
                     CppDirective('ifdef', 'OS_WIN'),
                     StmtExpr(ExprCall(
                             ExprSelect(p.channelVar(), '.',
-                                       'ProcessNativeEventsInRPCCall'))),
+                                       'ProcessNativeEventsInInterruptCall'))),
                     CppDirective('else'),
                     _runtimeAbort('This method is Windows-only'),
                     CppDirective('endif'),
                     ])
 
             self.cls.addstmts([ processnative, Whitespace.NL ])
 
         if ptype.isToplevel() and self.side is 'parent':
@@ -4635,18 +4635,18 @@ class _GenerateProtocolActorCode(ipdl.as
         helpermethod = None
         recvlbl, recvcase = None, None
 
         def addRecvCase(lbl, case):
             if sems is ipdl.ast.ASYNC:
                 self.asyncSwitch.addcase(lbl, case)
             elif sems is ipdl.ast.SYNC:
                 self.syncSwitch.addcase(lbl, case)
-            elif sems is ipdl.ast.RPC or sems is ipdl.ast.URGENT:
-                self.rpcSwitch.addcase(lbl, case)
+            elif sems is ipdl.ast.INTR or sems is ipdl.ast.URGENT:
+                self.interruptSwitch.addcase(lbl, case)
             else: assert 0
 
         if self.sendsMessage(md):
             isasync = (sems is ipdl.ast.ASYNC)
 
             if isctor:
                 self.cls.addstmts([ self.genHelperCtor(md), Whitespace.NL ])
 
@@ -5033,19 +5033,19 @@ class _GenerateProtocolActorCode(ipdl.as
             args=[ routingId ])) ]
 
         if md.decl.type.isSync():
             stmts.append(StmtExpr(ExprCall(
                 ExprSelect(var, '->', 'set_sync'))))
         elif md.decl.type.isUrgent():
             stmts.append(StmtExpr(ExprCall(
                 ExprSelect(var, '->', 'set_urgent'))))
-        elif md.decl.type.isRpc():
+        elif md.decl.type.isInterrupt():
             stmts.append(StmtExpr(ExprCall(
-                ExprSelect(var, '->', 'set_rpc'))))
+                ExprSelect(var, '->', 'set_interrupt'))))
 
         if reply:
             stmts.append(StmtExpr(ExprCall(
                 ExprSelect(var, '->', 'set_reply'))))
 
         return stmts + [ Whitespace.NL ]
 
 
--- a/ipc/ipdl/ipdl/parser.py
+++ b/ipc/ipdl/ipdl/parser.py
@@ -121,27 +121,27 @@ reserved = set((
         'bridges',
         'call',
         'child',
         'compress',
         '__delete__',
         'delete',                       # reserve 'delete' to prevent its use
         'goto',
         'include',
+        'intr',
         'manager',
         'manages',
         'namespace',
         'nullable',
         'opens',
         'or',
         'parent',
         'protocol',
         'recv',
         'returns',
-        'rpc',
         'send',
         'spawns',
         'start',
         'state',
         'struct',
         'sync',
         'union',
         'urgent',
@@ -211,16 +211,17 @@ def p_TranslationUnit(p):
 
     # The "canonical" namespace of the tu, what it's considered to be
     # in for the purposes of C++: |#include "foo/bar/TU.h"|
     if tu.protocol:
         assert tu.filetype == 'protocol'
         tu.namespaces = tu.protocol.namespaces
         tu.name = tu.protocol.name
     else:
+        print tu.filetype
         assert tu.filetype == 'header'
         # There's not really a canonical "thing" in headers.  So
         # somewhat arbitrarily use the namespace of the last
         # interesting thing that was declared.
         for thing in reversed(tu.structsAndUnions):
             tu.namespaces = thing.namespaces
             break
 
@@ -600,22 +601,22 @@ def p_State(p):
 def p_OptionalSendSemanticsQual(p):
     """OptionalSendSemanticsQual : SendSemanticsQual
                                  | """
     if 2 == len(p): p[0] = p[1]
     else:           p[0] = ASYNC
 
 def p_SendSemanticsQual(p):
     """SendSemanticsQual : ASYNC
-                         | RPC
+                         | INTR
                          | URGENT
                          | SYNC"""
     s = p[1]
     if 'async' == s: p[0] =    ASYNC
-    elif 'rpc' == s: p[0] =    RPC
+    elif 'intr' == s: p[0] =   INTR
     elif 'sync' == s: p[0] =   SYNC
     elif 'urgent' == s: p[0] = URGENT
     else:
         assert 0
 
 def p_ParamList(p):
     """ParamList : ParamList ',' Param
                  | Param
--- a/ipc/ipdl/ipdl/type.py
+++ b/ipc/ipdl/ipdl/type.py
@@ -1,16 +1,18 @@
 # vim: set ts=4 sw=4 tw=99 et:
 # 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/.
 
 import os, sys
 
-from ipdl.ast import CxxInclude, Decl, Loc, QualifiedId, State, StructDecl, TransitionStmt, TypeSpec, UnionDecl, UsingStmt, Visitor, ASYNC, SYNC, RPC, IN, OUT, INOUT, ANSWER, CALL, RECV, SEND, URGENT
+from ipdl.ast import CxxInclude, Decl, Loc, QualifiedId, State, StructDecl, TransitionStmt
+from ipdl.ast import TypeSpec, UnionDecl, UsingStmt, Visitor, ASYNC, SYNC, INTR
+from ipdl.ast import IN, OUT, INOUT, ANSWER, CALL, RECV, SEND, URGENT
 import ipdl.builtin as builtin
 
 _DELETE_MSG = '__delete__'
 
 
 def _otherside(side):
     if side == 'parent':  return 'child'
     elif side == 'child': return 'parent'
@@ -199,28 +201,28 @@ class IPDLType(Type):
     def isAtom(self):  return True
     def isCompound(self): return False
     def isShmem(self): return False
     def isChmod(self): return False
     def isFD(self): return False
 
     def isAsync(self): return self.sendSemantics is ASYNC
     def isSync(self): return self.sendSemantics is SYNC
-    def isRpc(self): return self.sendSemantics is RPC
+    def isInterrupt(self): return self.sendSemantics is INTR
     def isUrgent(self): return self.sendSemantics is URGENT
 
     def talksAsync(self): return True
-    def talksSync(self): return self.isSync() or self.isRpc()
-    def talksRpc(self): return self.isRpc()
+    def talksSync(self): return self.isSync() or self.isInterrupt()
+    def talksInterrupt(self): return self.isInterrupt()
 
-    def hasReply(self):  return self.isSync() or self.isRpc() or self.isUrgent()
+    def hasReply(self):  return self.isSync() or self.isInterrupt() or self.isUrgent()
 
     def needsMoreJuiceThan(self, o):
         return (o.isAsync() and not self.isAsync()
-                or o.isSync() and self.isRpc())
+                or o.isSync() and self.isInterrupt())
 
 class StateType(IPDLType):
     def __init__(self, protocol, name, start=False):
         self.protocol = protocol
         self.name = name
         self.start = start
     def isState(self): return True
     def name(self):
@@ -866,17 +868,17 @@ class GatherDecls(TcheckVisitor):
 
         p.decl.type.hasDelete = (not not self.symtab.lookup(_DELETE_MSG))
         if not (p.decl.type.hasDelete or p.decl.type.isToplevel()):
             self.error(
                 p.loc,
                 "destructor declaration `%s(...)' required for managed protocol `%s'",
                 _DELETE_MSG, p.name)
 
-        p.decl.type.hasReentrantDelete = p.decl.type.hasDelete and self.symtab.lookup(_DELETE_MSG).type.isRpc()
+        p.decl.type.hasReentrantDelete = p.decl.type.hasDelete and self.symtab.lookup(_DELETE_MSG).type.isInterrupt()
 
         for managed in p.managesStmts:
             mgdname = managed.name
             ctordecl = self.symtab.lookup(mgdname +'Constructor')
 
             if not (ctordecl and ctordecl.type.isCtor()):
                 self.error(
                     managed.loc,
@@ -1492,23 +1494,23 @@ class CheckTypes(TcheckVisitor):
 
 
     def visitTransition(self, t):
         _YNC = [ ASYNC, SYNC ]
 
         loc = t.loc
         impliedDirection, impliedSems = {
             SEND: [ OUT, _YNC ], RECV: [ IN, _YNC ],
-            CALL: [ OUT, RPC ],  ANSWER: [ IN, RPC ],
+            CALL: [ OUT, INTR ],  ANSWER: [ IN, INTR ],
          } [t.trigger]
         
         if (OUT is impliedDirection and t.msg.type.isIn()
             or IN is impliedDirection and t.msg.type.isOut()
-            or _YNC is impliedSems and t.msg.type.isRpc()
-            or RPC is impliedSems and (not t.msg.type.isRpc())):
+            or _YNC is impliedSems and t.msg.type.isInterrupt()
+            or INTR is impliedSems and (not t.msg.type.isInterrupt())):
             mtype = t.msg.type
 
             self.error(
                 loc, "%s %s message `%s' is not `%s'd",
                 mtype.sendSemantics.pretty, mtype.direction.pretty,
                 t.msg.progname,
                 t.trigger.pretty)
 
--- a/ipc/ipdl/test/cxx/Makefile.in
+++ b/ipc/ipdl/test/cxx/Makefile.in
@@ -13,22 +13,22 @@ IPDLTESTS = \
   TestFailedCtor \
   TestHangs \
   TestJSON \
   TestLatency \
   TestManyChildAllocs  \
   TestMultiMgrs  \
   TestNestedLoops \
   TestOpens \
-  TestRPCErrorCleanup \
-  TestRPCRaces \
-  TestRPCShutdownRace \
+  TestInterruptErrorCleanup \
+  TestInterruptRaces \
+  TestInterruptShutdownRace \
   TestRaceDeferral \
   TestRacyReentry  \
-  TestRacyRPCReplies  \
+  TestRacyInterruptReplies  \
   TestRacyUndefer \
   TestSanity  \
   TestSelfManageRoot \
   TestShmem \
   TestShutdown \
   TestStackHooks \
   TestSyncError \
   TestSyncHang \
--- a/ipc/ipdl/test/cxx/PTestBadActor.ipdl
+++ b/ipc/ipdl/test/cxx/PTestBadActor.ipdl
@@ -1,17 +1,17 @@
 include protocol PTestBadActorSub;
 
 namespace mozilla {
 namespace _ipdltest {
 
 // Test that a parent sending a reentrant __delete__ message
 // is not killed if a child's message races with the reply.
 
-rpc protocol PTestBadActor {
+intr protocol PTestBadActor {
   manages PTestBadActorSub;
 
 child:
   PTestBadActorSub();
   __delete__();
 };
 
 } // namespace _ipdltest
--- a/ipc/ipdl/test/cxx/PTestBadActorSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestBadActorSub.ipdl
@@ -1,17 +1,17 @@
 include protocol PTestBadActor;
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestBadActorSub {
+intr protocol PTestBadActorSub {
   manager PTestBadActor;
 
 child:
-  rpc __delete__();
+  intr __delete__();
 
 parent:
   Ping();
 };
 
 } // namespace _ipdltest
 } // namespace mozilla
--- a/ipc/ipdl/test/cxx/PTestBridgeMainSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestBridgeMainSub.ipdl
@@ -1,27 +1,27 @@
 include protocol PTestBridgeMain;
 include protocol PTestBridgeSub;
 
 namespace mozilla {
 namespace _ipdltest {
 
 // (Bridge protocols can have different semantics than the endpoints
 // they bridge)
-rpc protocol PTestBridgeMainSub {
+intr protocol PTestBridgeMainSub {
     bridges PTestBridgeMain, PTestBridgeSub;
 
 child:
     Hi();
-    rpc HiRpc();
+    intr HiRpc();
 
 parent:
     Hello();
     sync HelloSync();
-    rpc HelloRpc();
+    intr HelloRpc();
     __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:
--- a/ipc/ipdl/test/cxx/PTestCrashCleanup.ipdl
+++ b/ipc/ipdl/test/cxx/PTestCrashCleanup.ipdl
@@ -2,19 +2,19 @@
 // the "connection error" notification comes in from the IO thread,
 // IPDL teardown never occurs, even if Channel::Close() is called
 // after the error.
 
 namespace mozilla {
 namespace _ipdltest {
 
 // NB: needs to be RPC so that the parent blocks on the child's crash.
-rpc protocol PTestCrashCleanup {
+intr protocol PTestCrashCleanup {
 child:
-    rpc DIEDIEDIE();
+    intr DIEDIEDIE();
     __delete__();
 
 state ALIVE:
     call DIEDIEDIE goto CRASH;
 state CRASH:
     send __delete__;
 };
 
--- a/ipc/ipdl/test/cxx/PTestDesc.ipdl
+++ b/ipc/ipdl/test/cxx/PTestDesc.ipdl
@@ -1,18 +1,18 @@
 include protocol PTestDescSub;
 include protocol PTestDescSubsub;
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestDesc {
+intr protocol PTestDesc {
     manages PTestDescSub; 
 child:
-    rpc PTestDescSub(nullable PTestDescSubsub dummy);
+    intr PTestDescSub(nullable PTestDescSubsub dummy);
 
     Test(PTestDescSubsub a);
 
     __delete__();
 
 parent:
     Ok(PTestDescSubsub a);
 
--- a/ipc/ipdl/test/cxx/PTestDescSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestDescSub.ipdl
@@ -1,18 +1,18 @@
 include protocol PTestDesc;
 include protocol PTestDescSubsub;
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestDescSub {
+intr protocol PTestDescSub {
     manager PTestDesc;
     manages PTestDescSubsub;
 
 child:
     __delete__();
 
-    rpc PTestDescSubsub();
+    intr PTestDescSubsub();
 };
 
 }
 }
--- a/ipc/ipdl/test/cxx/PTestDescSubsub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestDescSubsub.ipdl
@@ -1,15 +1,15 @@
 
 include protocol PTestDescSub;
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestDescSubsub {
+intr protocol PTestDescSubsub {
     manager PTestDescSub;
 
 child:
-    rpc __delete__();
+    intr __delete__();
 };
 
 }
 }
--- a/ipc/ipdl/test/cxx/PTestFailedCtor.ipdl
+++ b/ipc/ipdl/test/cxx/PTestFailedCtor.ipdl
@@ -1,17 +1,17 @@
 include protocol PTestFailedCtorSub;
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestFailedCtor {
+intr protocol PTestFailedCtor {
     manages PTestFailedCtorSub; 
 child:
-    rpc PTestFailedCtorSub();
+    intr PTestFailedCtorSub();
     __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
@@ -1,15 +1,15 @@
 include protocol PTestFailedCtor;
 include protocol PTestFailedCtorSubsub;
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestFailedCtorSub {
+intr protocol PTestFailedCtorSub {
     manager PTestFailedCtor;
     manages PTestFailedCtorSubsub;
 
 parent:
     async PTestFailedCtorSubsub();
     sync Sync();
     __delete__();
 };
--- a/ipc/ipdl/test/cxx/PTestFailedCtorSubsub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestFailedCtorSubsub.ipdl
@@ -1,15 +1,15 @@
 
 include protocol PTestFailedCtorSub;
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestFailedCtorSubsub {
+intr protocol PTestFailedCtorSubsub {
     manager PTestFailedCtorSub;
 
 parent:
      __delete__();
 };
 
 }
 }
--- a/ipc/ipdl/test/cxx/PTestHangs.ipdl
+++ b/ipc/ipdl/test/cxx/PTestHangs.ipdl
@@ -1,22 +1,22 @@
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestHangs {
+intr protocol PTestHangs {
 both:
-    rpc StackFrame();
+    intr StackFrame();
 
 parent:
     async Nonce();
 
 child:
     async Start();
-    rpc Hang();
+    intr Hang();
     __delete__();
 
 
 state START:
     send Start goto RACE;
 
 state RACE:
     recv Nonce goto RACE1;
rename from ipc/ipdl/test/cxx/PTestRPCErrorCleanup.ipdl
rename to ipc/ipdl/test/cxx/PTestInterruptErrorCleanup.ipdl
--- a/ipc/ipdl/test/cxx/PTestRPCErrorCleanup.ipdl
+++ b/ipc/ipdl/test/cxx/PTestInterruptErrorCleanup.ipdl
@@ -1,11 +1,11 @@
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestRPCErrorCleanup {
+intr protocol PTestInterruptErrorCleanup {
 child:
-    rpc Error();
-    rpc __delete__();
+    intr Error();
+    intr __delete__();
 };
 
 } // namespace _ipdltest
 } // namespace mozilla
rename from ipc/ipdl/test/cxx/PTestRPCRaces.ipdl
rename to ipc/ipdl/test/cxx/PTestInterruptRaces.ipdl
--- a/ipc/ipdl/test/cxx/PTestRPCRaces.ipdl
+++ b/ipc/ipdl/test/cxx/PTestInterruptRaces.ipdl
@@ -1,44 +1,44 @@
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestRPCRaces {
+intr protocol PTestInterruptRaces {
 both:
-    rpc Race() returns (bool hasReply);
-    rpc StackFrame() returns ();
-    rpc StackFrame3() returns ();
+    intr Race() returns (bool hasReply);
+    intr StackFrame() returns ();
+    intr StackFrame3() returns ();
 
 parent:
     sync StartRace();
-    rpc Parent();
+    intr Parent();
     sync GetAnsweredParent() returns (bool answeredParent);
 
 child:
     Start();
     Wakeup();
     Wakeup3();
-    rpc Child();
+    intr Child();
     __delete__();
 
 state START:
     send Start goto TEST1;
 
-// First test: race while no other messages are on the RPC stack
+// First test: race while no other messages are on the Interrupt stack
 state TEST1:
     recv StartRace goto RACE1;
 state RACE1:
     call Race goto DUMMY1_1;
     answer Race goto DUMMY1_2;
 state DUMMY1_1:
     answer Race goto TEST2;
 state DUMMY1_2:
     call Race goto TEST2;
 
-// Second test: race while other messages are on the RPC stack
+// Second test: race while other messages are on the Interrupt stack
 state TEST2:
     call StackFrame goto MORESTACK;
 state MORESTACK:
     answer StackFrame goto STARTRACE;
 state STARTRACE:
     send Wakeup goto RACE2;
 state RACE2:
     call Race goto DUMMY2_1;
rename from ipc/ipdl/test/cxx/PTestRPCShutdownRace.ipdl
rename to ipc/ipdl/test/cxx/PTestInterruptShutdownRace.ipdl
--- a/ipc/ipdl/test/cxx/PTestRPCShutdownRace.ipdl
+++ b/ipc/ipdl/test/cxx/PTestInterruptShutdownRace.ipdl
@@ -1,19 +1,19 @@
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestRPCShutdownRace {
+intr protocol PTestInterruptShutdownRace {
 parent:
     sync StartDeath();
     async Orphan();
 
 child:
     async Start();
-    rpc Exit();
+    intr Exit();
     async __delete__();
 
 state START:
     send Start goto START_DEATH;
 
 state START_DEATH:
     recv StartDeath goto EXITING;
 
--- a/ipc/ipdl/test/cxx/PTestLatency.ipdl
+++ b/ipc/ipdl/test/cxx/PTestLatency.ipdl
@@ -1,24 +1,24 @@
 
 namespace mozilla {
 namespace _ipdltest {
 
 
-rpc protocol PTestLatency {
+intr protocol PTestLatency {
 
 child:
     __delete__();
     Ping();
     Ping5();
-    rpc Rpc();
+    intr Rpc();
     Spam();
-    rpc Synchro();
+    intr Synchro();
     CompressedSpam(uint32_t seqno) compress;
-    rpc Synchro2() returns (uint32_t lastSeqno,
+    intr Synchro2() returns (uint32_t lastSeqno,
                             uint32_t numMessagesDispatched);
 
 parent:
     Pong();
     Pong5();
 
 state START:
     // if the timing resolution is too low, abort the test
--- a/ipc/ipdl/test/cxx/PTestNestedLoops.ipdl
+++ b/ipc/ipdl/test/cxx/PTestNestedLoops.ipdl
@@ -1,18 +1,18 @@
 
 namespace mozilla {
 namespace _ipdltest {
 
 
-rpc protocol PTestNestedLoops {
+intr protocol PTestNestedLoops {
 
 child:
     async Start();
-    rpc R();
+    intr R();
     __delete__();
 
 parent:
     async Nonce();
 
 
 state START:
     send Start goto RACE;
--- a/ipc/ipdl/test/cxx/PTestOpensOpened.ipdl
+++ b/ipc/ipdl/test/cxx/PTestOpensOpened.ipdl
@@ -1,22 +1,22 @@
 namespace mozilla {
 namespace _ipdltest2 {
 
 // (Opens protocols can have different semantics than the endpoints
 // that opened them)
-rpc protocol PTestOpensOpened {
+intr protocol PTestOpensOpened {
 child:
     Hi();
-    rpc HiRpc();
+    intr HiRpc();
 
 parent:
     Hello();
     sync HelloSync();
-    rpc HelloRpc();
+    intr HelloRpc();
     __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:
--- a/ipc/ipdl/test/cxx/PTestRaceDeferral.ipdl
+++ b/ipc/ipdl/test/cxx/PTestRaceDeferral.ipdl
@@ -1,19 +1,19 @@
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestRaceDeferral {
+intr protocol PTestRaceDeferral {
 parent:
-    rpc Lose();
+    intr Lose();
 
 child:
     async StartRace();
-    rpc Win();
-    rpc Rpc();
+    intr Win();
+    intr Rpc();
     async __delete__();
 
 // Test that messages deferred due to race resolution are
 // re-considered when the winner makes later RPCs
 
 // IPDL's type system can't express this protocol because the race
 // resolution causes state to diverge for multiple steps, so we'll
 // leave it "stateless"
rename from ipc/ipdl/test/cxx/PTestRacyRPCReplies.ipdl
rename to ipc/ipdl/test/cxx/PTestRacyInterruptReplies.ipdl
--- a/ipc/ipdl/test/cxx/PTestRacyRPCReplies.ipdl
+++ b/ipc/ipdl/test/cxx/PTestRacyInterruptReplies.ipdl
@@ -1,20 +1,20 @@
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestRacyRPCReplies {
+intr protocol PTestRacyInterruptReplies {
 child:
-    rpc R_() returns (int replyNum);
+    intr R_() returns (int replyNum);
     async _A();
     async ChildTest();
     async __delete__();
 
 parent:
-    rpc _R() returns (int replyNum);
+    intr _R() returns (int replyNum);
     async A_();
 
 state PARENT_START:
     call R_ goto PARENT_S1;
 
 state PARENT_S1:
     recv A_ goto PARENT_S2;
 
--- a/ipc/ipdl/test/cxx/PTestRacyReentry.ipdl
+++ b/ipc/ipdl/test/cxx/PTestRacyReentry.ipdl
@@ -1,21 +1,21 @@
 
 namespace mozilla {
 namespace _ipdltest {
 
 
-rpc protocol PTestRacyReentry {
+intr protocol PTestRacyReentry {
 
 parent:
-    rpc E();
+    intr E();
     __delete__();
 
 child:
     async Start();
 
     async N();
-    rpc H();
+    intr H();
 };
 
 
 } // namespace mozilla
 } // namespace _ipdltest
--- a/ipc/ipdl/test/cxx/PTestRacyUndefer.ipdl
+++ b/ipc/ipdl/test/cxx/PTestRacyUndefer.ipdl
@@ -1,28 +1,28 @@
 
 namespace mozilla {
 namespace _ipdltest {
 
 
-rpc protocol PTestRacyUndefer {
+intr protocol PTestRacyUndefer {
 
 child:
     async Start();
 
     async AwakenSpam();
     async AwakenRaceWinTwice();
 
-    rpc Race();
+    intr Race();
 
     async __delete__();
 
 parent:
 
-    rpc Spam();
-    rpc RaceWinTwice();
+    intr Spam();
+    intr RaceWinTwice();
 
     async Done();
 };
 
 
 } // namespace mozilla
 } // namespace _ipdltest
--- a/ipc/ipdl/test/cxx/PTestShutdown.ipdl
+++ b/ipc/ipdl/test/cxx/PTestShutdown.ipdl
@@ -1,14 +1,14 @@
 include protocol PTestShutdownSub;
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestShutdown {
+intr protocol PTestShutdown {
     manages PTestShutdownSub;
 
 child:
     Start();
 
 parent:
     // NB: we test deletion and crashing only, not shutdown, because
     // crashing is the same code path as shutdown, and other IPDL unit
--- a/ipc/ipdl/test/cxx/PTestShutdownSub.ipdl
+++ b/ipc/ipdl/test/cxx/PTestShutdownSub.ipdl
@@ -1,20 +1,20 @@
 include protocol PTestShutdown;
 include protocol PTestShutdownSubsub;
 
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestShutdownSub {
+intr protocol PTestShutdownSub {
     manager PTestShutdown;
     manages PTestShutdownSubsub;
 
 both:
-    rpc StackFrame();
+    intr StackFrame();
 
 parent:
     PTestShutdownSubsub(bool expectParentDeleted);
     sync __delete__();
 
 state CREATING:
     recv PTestShutdownSubsub goto CREATING;
     answer StackFrame goto DUMMYFRAME;
--- a/ipc/ipdl/test/cxx/PTestStackHooks.ipdl
+++ b/ipc/ipdl/test/cxx/PTestStackHooks.ipdl
@@ -1,26 +1,26 @@
 
 namespace mozilla {
 namespace _ipdltest {
 
 
-rpc protocol PTestStackHooks {
+intr protocol PTestStackHooks {
 child:
     async Start();
 
     // These tests are more fruitful running child->parent, because
     // children can send |sync| messages
 parent:
     async Async();
     sync Sync();
-    rpc Rpc();
+    intr Rpc();
 
 both:
-    rpc StackFrame();
+    intr StackFrame();
 
 parent:
     __delete__();
 
 
 state START:
     send Start goto TEST1;
 
--- a/ipc/ipdl/test/cxx/PTestSyncWakeup.ipdl
+++ b/ipc/ipdl/test/cxx/PTestSyncWakeup.ipdl
@@ -1,14 +1,14 @@
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestSyncWakeup {
+intr protocol PTestSyncWakeup {
 both:
-    rpc StackFrame();
+    intr StackFrame();
 
 child:
     async Start();
     async Note1();
     async Note2();
 
 parent:
     sync Sync1();
--- a/ipc/ipdl/test/cxx/PTestUrgency.ipdl
+++ b/ipc/ipdl/test/cxx/PTestUrgency.ipdl
@@ -1,12 +1,12 @@
 namespace mozilla {
 namespace _ipdltest {
 
-rpc protocol PTestUrgency
+intr protocol PTestUrgency
 {
 parent:
     sync Test1() returns (uint32_t result);
     async Test2();
     sync Test3() returns (uint32_t result);
     sync Test4_Begin();
     sync Test4_NestedSync();
     sync FinalTest_Begin();
rename from ipc/ipdl/test/cxx/TestRPCErrorCleanup.cpp
rename to ipc/ipdl/test/cxx/TestInterruptErrorCleanup.cpp
--- a/ipc/ipdl/test/cxx/TestRPCErrorCleanup.cpp
+++ b/ipc/ipdl/test/cxx/TestInterruptErrorCleanup.cpp
@@ -1,9 +1,9 @@
-#include "TestRPCErrorCleanup.h"
+#include "TestInterruptErrorCleanup.h"
 
 #include "mozilla/CondVar.h"
 #include "mozilla/Mutex.h"
 
 #include "IPDLUnitTests.h"      // fail etc.
 #include "IPDLUnitTestSubprocess.h"
 
 using mozilla::CondVar;
@@ -28,23 +28,23 @@ void DeleteSubprocess(Mutex* mutex, Cond
     delete gSubprocess;
     gSubprocess = nullptr;
 
     cvar->Notify();
 }
 
 void DeleteTheWorld()
 {
-    delete static_cast<TestRPCErrorCleanupParent*>(gParentActor);
+    delete static_cast<TestInterruptErrorCleanupParent*>(gParentActor);
     gParentActor = nullptr;
 
     // needs to be synchronous to avoid affecting event ordering on
     // the main thread
-    Mutex mutex("TestRPCErrorCleanup.DeleteTheWorld.mutex");
-    CondVar cvar(mutex, "TestRPCErrorCleanup.DeleteTheWorld.cvar");
+    Mutex mutex("TestInterruptErrorCleanup.DeleteTheWorld.mutex");
+    CondVar cvar(mutex, "TestInterruptErrorCleanup.DeleteTheWorld.cvar");
 
     MutexAutoLock lock(mutex);
 
     XRE_GetIOMessageLoop()->PostTask(
       FROM_HERE,
       NewRunnableFunction(DeleteSubprocess, &mutex, &cvar));
 
     cvar.Wait();
@@ -56,36 +56,36 @@ void Done()
   nsCOMPtr<nsIAppShell> appShell (do_GetService(kAppShellCID));
   appShell->Exit();
 
   passed(__FILE__);
 }
 
 } // namespace <anon>
 
-TestRPCErrorCleanupParent::TestRPCErrorCleanupParent()
+TestInterruptErrorCleanupParent::TestInterruptErrorCleanupParent()
     : mGotProcessingError(false)
 {
-    MOZ_COUNT_CTOR(TestRPCErrorCleanupParent);
+    MOZ_COUNT_CTOR(TestInterruptErrorCleanupParent);
 }
 
-TestRPCErrorCleanupParent::~TestRPCErrorCleanupParent()
+TestInterruptErrorCleanupParent::~TestInterruptErrorCleanupParent()
 {
-    MOZ_COUNT_DTOR(TestRPCErrorCleanupParent);
+    MOZ_COUNT_DTOR(TestInterruptErrorCleanupParent);
 }
 
 void
-TestRPCErrorCleanupParent::Main()
+TestInterruptErrorCleanupParent::Main()
 {
     // This test models the following sequence of events
     //
-    // (1) Parent: RPC out-call
+    // (1) Parent: Interrupt out-call
     // (2) Child: crash
     // --[Parent-only hereafter]--
-    // (3) RPC out-call return false
+    // (3) Interrupt out-call return false
     // (4) Close()
     // --[event loop]--
     // (5) delete parentActor
     // (6) delete childProcess
     // --[event loop]--
     // (7) Channel::OnError notification
     // --[event loop]--
     // (8) Done, quit
@@ -117,38 +117,38 @@ TestRPCErrorCleanupParent::Main()
     // we know that this event *must* be after the MaybeError
     // notification enqueued by AsyncChannel, because that event is
     // enqueued within the same mutex that ends up signaling the
     // wakeup-on-error of |CallError()| above
     MessageLoop::current()->PostTask(FROM_HERE, NewRunnableFunction(Done));
 }
 
 void
-TestRPCErrorCleanupParent::ProcessingError(Result what)
+TestInterruptErrorCleanupParent::ProcessingError(Result what)
 {
     if (what != MsgDropped)
         fail("unexpected processing error");
     mGotProcessingError = true;
 }
 
 //-----------------------------------------------------------------------------
 // child
 
-TestRPCErrorCleanupChild::TestRPCErrorCleanupChild()
+TestInterruptErrorCleanupChild::TestInterruptErrorCleanupChild()
 {
-    MOZ_COUNT_CTOR(TestRPCErrorCleanupChild);
+    MOZ_COUNT_CTOR(TestInterruptErrorCleanupChild);
 }
 
-TestRPCErrorCleanupChild::~TestRPCErrorCleanupChild()
+TestInterruptErrorCleanupChild::~TestInterruptErrorCleanupChild()
 {
-    MOZ_COUNT_DTOR(TestRPCErrorCleanupChild);
+    MOZ_COUNT_DTOR(TestInterruptErrorCleanupChild);
 }
 
 bool
-TestRPCErrorCleanupChild::AnswerError()
+TestInterruptErrorCleanupChild::AnswerError()
 {
     _exit(0);
     NS_RUNTIMEABORT("unreached");
     return false;
 }
 
 
 } // namespace _ipdltest
rename from ipc/ipdl/test/cxx/TestRPCErrorCleanup.h
rename to ipc/ipdl/test/cxx/TestInterruptErrorCleanup.h
--- a/ipc/ipdl/test/cxx/TestRPCErrorCleanup.h
+++ b/ipc/ipdl/test/cxx/TestInterruptErrorCleanup.h
@@ -1,26 +1,26 @@
-#ifndef mozilla__ipdltest_TestRPCErrorCleanup_h
-#define mozilla__ipdltest_TestRPCErrorCleanup_h 1
+#ifndef mozilla__ipdltest_TestInterruptErrorCleanup_h
+#define mozilla__ipdltest_TestInterruptErrorCleanup_h 1
 
 #include "mozilla/_ipdltest/IPDLUnitTests.h"
 
-#include "mozilla/_ipdltest/PTestRPCErrorCleanupParent.h"
-#include "mozilla/_ipdltest/PTestRPCErrorCleanupChild.h"
+#include "mozilla/_ipdltest/PTestInterruptErrorCleanupParent.h"
+#include "mozilla/_ipdltest/PTestInterruptErrorCleanupChild.h"
 
 namespace mozilla {
 namespace _ipdltest {
 
 
-class TestRPCErrorCleanupParent :
-    public PTestRPCErrorCleanupParent
+class TestInterruptErrorCleanupParent :
+    public PTestInterruptErrorCleanupParent
 {
 public:
-    TestRPCErrorCleanupParent();
-    virtual ~TestRPCErrorCleanupParent();
+    TestInterruptErrorCleanupParent();
+    virtual ~TestInterruptErrorCleanupParent();
 
     static bool RunTestInProcesses() { return true; }
     // FIXME/bug 703323 Could work if modified
     static bool RunTestInThreads() { return false; }
 
     void Main();
 
 protected:    
@@ -31,30 +31,30 @@ protected:
     }
 
     virtual void ProcessingError(Result what) MOZ_OVERRIDE;
 
     bool mGotProcessingError;
 };
 
 
-class TestRPCErrorCleanupChild :
-    public PTestRPCErrorCleanupChild
+class TestInterruptErrorCleanupChild :
+    public PTestInterruptErrorCleanupChild
 {
 public:
-    TestRPCErrorCleanupChild();
-    virtual ~TestRPCErrorCleanupChild();
+    TestInterruptErrorCleanupChild();
+    virtual ~TestInterruptErrorCleanupChild();
 
 protected:
     virtual bool AnswerError() MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         fail("should have 'crashed'!");
     }
 };
 
 
 } // namespace _ipdltest
 } // namespace mozilla
 
 
-#endif // ifndef mozilla__ipdltest_TestRPCErrorCleanup_h
+#endif // ifndef mozilla__ipdltest_TestInterruptErrorCleanup_h
rename from ipc/ipdl/test/cxx/TestRPCRaces.cpp
rename to ipc/ipdl/test/cxx/TestInterruptRaces.cpp
--- a/ipc/ipdl/test/cxx/TestRPCRaces.cpp
+++ b/ipc/ipdl/test/cxx/TestInterruptRaces.cpp
@@ -1,223 +1,223 @@
-#include "TestRPCRaces.h"
+#include "TestInterruptRaces.h"
 
 #include "IPDLUnitTests.h"      // fail etc.
 
 using mozilla::ipc::MessageChannel;
 
 template<>
-struct RunnableMethodTraits<mozilla::_ipdltest::TestRPCRacesParent>
+struct RunnableMethodTraits<mozilla::_ipdltest::TestInterruptRacesParent>
 {
-    static void RetainCallee(mozilla::_ipdltest::TestRPCRacesParent* obj) { }
-    static void ReleaseCallee(mozilla::_ipdltest::TestRPCRacesParent* obj) { }
+    static void RetainCallee(mozilla::_ipdltest::TestInterruptRacesParent* obj) { }
+    static void ReleaseCallee(mozilla::_ipdltest::TestInterruptRacesParent* obj) { }
 };
 
 
 namespace mozilla {
 namespace _ipdltest {
 
-ipc::RacyRPCPolicy
+ipc::RacyInterruptPolicy
 MediateRace(const MessageChannel::Message& parent,
             const MessageChannel::Message& child)
 {
-    return (PTestRPCRaces::Msg_Child__ID == parent.type()) ?
-        ipc::RRPParentWins : ipc::RRPChildWins;
+    return (PTestInterruptRaces::Msg_Child__ID == parent.type()) ?
+        ipc::RIPParentWins : ipc::RIPChildWins;
 }
 
 //-----------------------------------------------------------------------------
 // parent
 void
-TestRPCRacesParent::Main()
+TestInterruptRacesParent::Main()
 {
     if (!SendStart())
         fail("sending Start()");
 }
 
 bool
-TestRPCRacesParent::RecvStartRace()
+TestInterruptRacesParent::RecvStartRace()
 {
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        NewRunnableMethod(this, &TestRPCRacesParent::OnRaceTime));
+        NewRunnableMethod(this, &TestInterruptRacesParent::OnRaceTime));
     return true;
 }
 
 void
-TestRPCRacesParent::OnRaceTime()
+TestInterruptRacesParent::OnRaceTime()
 {
     if (!CallRace(&mChildHasReply))
         fail("problem calling Race()");
 
     if (!mChildHasReply)
         fail("child should have got a reply already");
 
     mHasReply = true;
 
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        NewRunnableMethod(this, &TestRPCRacesParent::Test2));
+        NewRunnableMethod(this, &TestInterruptRacesParent::Test2));
 }
 
 bool
-TestRPCRacesParent::AnswerRace(bool* hasReply)
+TestInterruptRacesParent::AnswerRace(bool* hasReply)
 {
     if (mHasReply)
-        fail("apparently the parent won the RPC race!");
+        fail("apparently the parent won the Interrupt race!");
     *hasReply = hasReply;
     return true;
 }
 
 void
-TestRPCRacesParent::Test2()
+TestInterruptRacesParent::Test2()
 {
     puts("  passed");
     puts("Test 2");
 
     mHasReply = false;
     mChildHasReply = false;
 
     if (!CallStackFrame())
         fail("can't set up a stack frame");
 
     puts("  passed");
 
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        NewRunnableMethod(this, &TestRPCRacesParent::Test3));
+        NewRunnableMethod(this, &TestInterruptRacesParent::Test3));
 }
 
 bool
-TestRPCRacesParent::AnswerStackFrame()
+TestInterruptRacesParent::AnswerStackFrame()
 {
     if (!SendWakeup())
         fail("can't wake up the child");
 
     if (!CallRace(&mChildHasReply))
         fail("can't set up race condition");
     mHasReply = true;
 
     if (!mChildHasReply)
         fail("child should have got a reply already");
 
     return true;
 }
 
 void
-TestRPCRacesParent::Test3()
+TestInterruptRacesParent::Test3()
 {
     puts("Test 3");
 
     if (!CallStackFrame3())
         fail("can't set up a stack frame");
 
     puts("  passed");
 
     Close();
 }
 
 bool
-TestRPCRacesParent::AnswerStackFrame3()
+TestInterruptRacesParent::AnswerStackFrame3()
 {
     if (!SendWakeup3())
         fail("can't wake up the child");
 
     if (!CallChild())
         fail("can't set up race condition");
 
     return true;
 }
 
 bool
-TestRPCRacesParent::AnswerParent()
+TestInterruptRacesParent::AnswerParent()
 {
     mAnsweredParent = true;
     return true;
 }
 
 bool
-TestRPCRacesParent::RecvGetAnsweredParent(bool* answeredParent)
+TestInterruptRacesParent::RecvGetAnsweredParent(bool* answeredParent)
 {
     *answeredParent = mAnsweredParent;
     return true;
 }
 
 //-----------------------------------------------------------------------------
 // child
 bool
-TestRPCRacesChild::RecvStart()
+TestInterruptRacesChild::RecvStart()
 {
     puts("Test 1");
 
     if (!SendStartRace())
         fail("problem sending StartRace()");
 
     bool dontcare;
     if (!CallRace(&dontcare))
         fail("problem calling Race()");
 
     mHasReply = true;
     return true;
 }
 
 bool
-TestRPCRacesChild::AnswerRace(bool* hasReply)
+TestInterruptRacesChild::AnswerRace(bool* hasReply)
 {
     if (!mHasReply)
-        fail("apparently the child lost the RPC race!");
+        fail("apparently the child lost the Interrupt race!");
 
     *hasReply = mHasReply;
 
     return true;
 }
 
 bool
-TestRPCRacesChild::AnswerStackFrame()
+TestInterruptRacesChild::AnswerStackFrame()
 {
     // reset for the second test
     mHasReply = false;
 
     if (!CallStackFrame())
         fail("can't set up stack frame");
 
     if (!mHasReply)
         fail("should have had reply by now");
 
     return true;
 }
 
 bool
-TestRPCRacesChild::RecvWakeup()
+TestInterruptRacesChild::RecvWakeup()
 {
     bool dontcare;
     if (!CallRace(&dontcare))
         fail("can't set up race condition");
 
     mHasReply = true;
     return true;
 }
 
 bool
-TestRPCRacesChild::AnswerStackFrame3()
+TestInterruptRacesChild::AnswerStackFrame3()
 {
     if (!CallStackFrame3())
         fail("can't set up stack frame");
     return true;
 }
 
 bool
-TestRPCRacesChild::RecvWakeup3()
+TestInterruptRacesChild::RecvWakeup3()
 {
     if (!CallParent())
         fail("can't set up race condition");
     return true;
 }
 
 bool
-TestRPCRacesChild::AnswerChild()
+TestInterruptRacesChild::AnswerChild()
 {
     bool parentAnsweredParent;
     // the parent is supposed to win the race, which means its
     // message, Child(), is supposed to be processed before the
     // child's message, Parent()
     if (!SendGetAnsweredParent(&parentAnsweredParent))
         fail("sending GetAnsweredParent");
 
rename from ipc/ipdl/test/cxx/TestRPCRaces.h
rename to ipc/ipdl/test/cxx/TestInterruptRaces.h
--- a/ipc/ipdl/test/cxx/TestRPCRaces.h
+++ b/ipc/ipdl/test/cxx/TestInterruptRaces.h
@@ -1,32 +1,32 @@
-#ifndef mozilla__ipdltest_TestRPCRaces_h
-#define mozilla__ipdltest_TestRPCRaces_h
+#ifndef mozilla__ipdltest_TestInterruptRaces_h
+#define mozilla__ipdltest_TestInterruptRaces_h
 
 #include "mozilla/_ipdltest/IPDLUnitTests.h"
 
-#include "mozilla/_ipdltest/PTestRPCRacesParent.h"
-#include "mozilla/_ipdltest/PTestRPCRacesChild.h"
+#include "mozilla/_ipdltest/PTestInterruptRacesParent.h"
+#include "mozilla/_ipdltest/PTestInterruptRacesChild.h"
 
 namespace mozilla {
 namespace _ipdltest {
 
-mozilla::ipc::RacyRPCPolicy
+mozilla::ipc::RacyInterruptPolicy
 MediateRace(const mozilla::ipc::MessageChannel::Message& parent,
             const mozilla::ipc::MessageChannel::Message& child);
 
-class TestRPCRacesParent :
-    public PTestRPCRacesParent
+class TestInterruptRacesParent :
+    public PTestInterruptRacesParent
 {
 public:
-    TestRPCRacesParent() : mHasReply(false),
+    TestInterruptRacesParent() : mHasReply(false),
                            mChildHasReply(false),
                            mAnsweredParent(false)
     { }
-    virtual ~TestRPCRacesParent() { }
+    virtual ~TestInterruptRacesParent() { }
 
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return true; }
 
     void Main();
 
 protected:
     virtual bool
@@ -42,18 +42,18 @@ protected:
     AnswerStackFrame3() MOZ_OVERRIDE;
 
     virtual bool
     AnswerParent() MOZ_OVERRIDE;
 
     virtual bool
     RecvGetAnsweredParent(bool* answeredParent) MOZ_OVERRIDE;
 
-    virtual mozilla::ipc::RacyRPCPolicy
-    MediateRPCRace(const Message& parent, const Message& child) MOZ_OVERRIDE
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const Message& parent, const Message& child) MOZ_OVERRIDE
     {
         return MediateRace(parent, child);
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
             fail("unexpected destruction!");
@@ -70,22 +70,22 @@ private:
     void Test3();
 
     bool mHasReply;
     bool mChildHasReply;
     bool mAnsweredParent;
 };
 
 
-class TestRPCRacesChild :
-    public PTestRPCRacesChild
+class TestInterruptRacesChild :
+    public PTestInterruptRacesChild
 {
 public:
-    TestRPCRacesChild() : mHasReply(false) { }
-    virtual ~TestRPCRacesChild() { }
+    TestInterruptRacesChild() : mHasReply(false) { }
+    virtual ~TestInterruptRacesChild() { }
 
 protected:
     virtual bool
     RecvStart() MOZ_OVERRIDE;
 
     virtual bool
     AnswerRace(bool* hasRace) MOZ_OVERRIDE;
 
@@ -99,18 +99,18 @@ protected:
     RecvWakeup() MOZ_OVERRIDE;
 
     virtual bool
     RecvWakeup3() MOZ_OVERRIDE;
 
     virtual bool
     AnswerChild() MOZ_OVERRIDE;
 
-    virtual mozilla::ipc::RacyRPCPolicy
-    MediateRPCRace(const Message& parent, const Message& child) MOZ_OVERRIDE
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const Message& parent, const Message& child) MOZ_OVERRIDE
     {
         return MediateRace(parent, child);
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
             fail("unexpected destruction!");
@@ -121,9 +121,9 @@ private:
     bool mHasReply;
 };
 
 
 } // namespace _ipdltest
 } // namespace mozilla
 
 
-#endif // ifndef mozilla__ipdltest_TestRPCRaces_h
+#endif // ifndef mozilla__ipdltest_TestInterruptRaces_h
rename from ipc/ipdl/test/cxx/TestRPCShutdownRace.cpp
rename to ipc/ipdl/test/cxx/TestInterruptShutdownRace.cpp
--- a/ipc/ipdl/test/cxx/TestRPCShutdownRace.cpp
+++ b/ipc/ipdl/test/cxx/TestInterruptShutdownRace.cpp
@@ -1,18 +1,18 @@
-#include "TestRPCShutdownRace.h"
+#include "TestInterruptShutdownRace.h"
 
 #include "IPDLUnitTests.h"      // fail etc.
 #include "IPDLUnitTestSubprocess.h"
 
 template<>
-struct RunnableMethodTraits<mozilla::_ipdltest::TestRPCShutdownRaceParent>
+struct RunnableMethodTraits<mozilla::_ipdltest::TestInterruptShutdownRaceParent>
 {
-    static void RetainCallee(mozilla::_ipdltest::TestRPCShutdownRaceParent* obj) { }
-    static void ReleaseCallee(mozilla::_ipdltest::TestRPCShutdownRaceParent* obj) { }
+    static void RetainCallee(mozilla::_ipdltest::TestInterruptShutdownRaceParent* obj) { }
+    static void ReleaseCallee(mozilla::_ipdltest::TestInterruptShutdownRaceParent* obj) { }
 };
 
 
 namespace mozilla {
 namespace _ipdltest {
 
 //-----------------------------------------------------------------------------
 // parent
@@ -31,113 +31,113 @@ void DeleteSubprocess()
 void Done()
 {
     passed(__FILE__);
     QuitParent();
 }
 
 } // namespace <anon>
 
-TestRPCShutdownRaceParent::TestRPCShutdownRaceParent()
+TestInterruptShutdownRaceParent::TestInterruptShutdownRaceParent()
 {
-    MOZ_COUNT_CTOR(TestRPCShutdownRaceParent);
+    MOZ_COUNT_CTOR(TestInterruptShutdownRaceParent);
 }
 
-TestRPCShutdownRaceParent::~TestRPCShutdownRaceParent()
+TestInterruptShutdownRaceParent::~TestInterruptShutdownRaceParent()
 {
-    MOZ_COUNT_DTOR(TestRPCShutdownRaceParent);
+    MOZ_COUNT_DTOR(TestInterruptShutdownRaceParent);
 }
 
 void
-TestRPCShutdownRaceParent::Main()
+TestInterruptShutdownRaceParent::Main()
 {
     if (!SendStart())
         fail("sending Start");
 }
 
 bool
-TestRPCShutdownRaceParent::RecvStartDeath()
+TestInterruptShutdownRaceParent::RecvStartDeath()
 {
     // this will be ordered before the OnMaybeDequeueOne event of
     // Orphan in the queue
     MessageLoop::current()->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
-                          &TestRPCShutdownRaceParent::StartShuttingDown));
+                          &TestInterruptShutdownRaceParent::StartShuttingDown));
     return true;
 }
 
 void
-TestRPCShutdownRaceParent::StartShuttingDown()
+TestInterruptShutdownRaceParent::StartShuttingDown()
 {
     // NB: we sleep here to try and avoid receiving the Orphan message
     // while waiting for the CallExit() reply.  if we fail at that, it
     // will cause the test to pass spuriously, because there won't be
     // an OnMaybeDequeueOne task for Orphan
     PR_Sleep(2000);
 
     if (CallExit())
         fail("connection was supposed to be interrupted");
 
     Close();
 
-    delete static_cast<TestRPCShutdownRaceParent*>(gParentActor);
+    delete static_cast<TestInterruptShutdownRaceParent*>(gParentActor);
     gParentActor = nullptr;
 
     XRE_GetIOMessageLoop()->PostTask(FROM_HERE,
                                      NewRunnableFunction(DeleteSubprocess));
 
     // this is ordered after the OnMaybeDequeueOne event in the queue
     MessageLoop::current()->PostTask(FROM_HERE,
                                      NewRunnableFunction(Done));
 
     // |this| has been deleted, be mindful
 }
 
 bool
-TestRPCShutdownRaceParent::RecvOrphan()
+TestInterruptShutdownRaceParent::RecvOrphan()
 {
     // it would be nice to fail() here, but we'll process this message
     // while waiting for the reply CallExit().  The OnMaybeDequeueOne
     // task will still be in the queue, it just wouldn't have had any
     // work to do, if we hadn't deleted ourself
     return true;
 }
 
 //-----------------------------------------------------------------------------
 // child
 
-TestRPCShutdownRaceChild::TestRPCShutdownRaceChild()
+TestInterruptShutdownRaceChild::TestInterruptShutdownRaceChild()
 {
-    MOZ_COUNT_CTOR(TestRPCShutdownRaceChild);
+    MOZ_COUNT_CTOR(TestInterruptShutdownRaceChild);
 }
 
-TestRPCShutdownRaceChild::~TestRPCShutdownRaceChild()
+TestInterruptShutdownRaceChild::~TestInterruptShutdownRaceChild()
 {
-    MOZ_COUNT_DTOR(TestRPCShutdownRaceChild);
+    MOZ_COUNT_DTOR(TestInterruptShutdownRaceChild);
 }
 
 bool
-TestRPCShutdownRaceChild::RecvStart()
+TestInterruptShutdownRaceChild::RecvStart()
 {
     if (!SendStartDeath())
         fail("sending StartDeath");
 
     // See comment in StartShuttingDown(): we want to send Orphan()
     // while the parent is in its PR_Sleep()
     PR_Sleep(1000);
 
     if (!SendOrphan())
         fail("sending Orphan");
 
     return true;
 }
 
 bool
-TestRPCShutdownRaceChild::AnswerExit()
+TestInterruptShutdownRaceChild::AnswerExit()
 {
     _exit(0);
     NS_RUNTIMEABORT("unreached");
     return false;
 }
 
 
 } // namespace _ipdltest
rename from ipc/ipdl/test/cxx/TestRPCShutdownRace.h
rename to ipc/ipdl/test/cxx/TestInterruptShutdownRace.h
--- a/ipc/ipdl/test/cxx/TestRPCShutdownRace.h
+++ b/ipc/ipdl/test/cxx/TestInterruptShutdownRace.h
@@ -1,26 +1,26 @@
-#ifndef mozilla__ipdltest_TestRPCShutdownRace_h
-#define mozilla__ipdltest_TestRPCShutdownRace_h 1
+#ifndef mozilla__ipdltest_TestInterruptShutdownRace_h
+#define mozilla__ipdltest_TestInterruptShutdownRace_h 1
 
 #include "mozilla/_ipdltest/IPDLUnitTests.h"
 
-#include "mozilla/_ipdltest/PTestRPCShutdownRaceParent.h"
-#include "mozilla/_ipdltest/PTestRPCShutdownRaceChild.h"
+#include "mozilla/_ipdltest/PTestInterruptShutdownRaceParent.h"
+#include "mozilla/_ipdltest/PTestInterruptShutdownRaceChild.h"
 
 namespace mozilla {
 namespace _ipdltest {
 
 
-class TestRPCShutdownRaceParent :
-    public PTestRPCShutdownRaceParent
+class TestInterruptShutdownRaceParent :
+    public PTestInterruptShutdownRaceParent
 {
 public:
-    TestRPCShutdownRaceParent();
-    virtual ~TestRPCShutdownRaceParent();
+    TestInterruptShutdownRaceParent();
+    virtual ~TestInterruptShutdownRaceParent();
 
     static bool RunTestInProcesses() { return true; }
     // FIXME/bug 703323 Could work if modified
     static bool RunTestInThreads() { return false; }
 
     void Main();
 
     virtual bool RecvStartDeath() MOZ_OVERRIDE;
@@ -33,22 +33,22 @@ protected:
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (AbnormalShutdown != why)
             fail("unexpected destruction!");  
     }
 };
 
 
-class TestRPCShutdownRaceChild :
-    public PTestRPCShutdownRaceChild
+class TestInterruptShutdownRaceChild :
+    public PTestInterruptShutdownRaceChild
 {
 public:
-    TestRPCShutdownRaceChild();
-    virtual ~TestRPCShutdownRaceChild();
+    TestInterruptShutdownRaceChild();
+    virtual ~TestInterruptShutdownRaceChild();
 
 protected:
     virtual bool RecvStart() MOZ_OVERRIDE;
 
     virtual bool AnswerExit() MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
@@ -56,9 +56,9 @@ protected:
     }
 };
 
 
 } // namespace _ipdltest
 } // namespace mozilla
 
 
-#endif // ifndef mozilla__ipdltest_TestRPCShutdownRace_h
+#endif // ifndef mozilla__ipdltest_TestInterruptShutdownRace_h
--- a/ipc/ipdl/test/cxx/TestRaceDeferral.cpp
+++ b/ipc/ipdl/test/cxx/TestRaceDeferral.cpp
@@ -3,21 +3,21 @@
 #include "IPDLUnitTests.h"      // fail etc.
 
 using namespace mozilla::ipc;
 typedef mozilla::ipc::MessageChannel::Message Message;
 
 namespace mozilla {
 namespace _ipdltest {
 
-static RacyRPCPolicy
+static RacyInterruptPolicy
 MediateRace(const Message& parent, const Message& child)
 {
     return (PTestRaceDeferral::Msg_Win__ID == parent.type()) ?
-        RRPParentWins : RRPChildWins;
+        RIPParentWins : RIPChildWins;
 }
 
 //-----------------------------------------------------------------------------
 // parent
 
 TestRaceDeferralParent::TestRaceDeferralParent()
     : mProcessedLose(false)
 {
@@ -61,18 +61,18 @@ bool
 TestRaceDeferralParent::AnswerLose()
 {
     if (mProcessedLose)
         fail("processed Lose twice");
     mProcessedLose = true;
     return true;
 }
 
-RacyRPCPolicy
-TestRaceDeferralParent::MediateRPCRace(const Message& parent,
+RacyInterruptPolicy
+TestRaceDeferralParent::MediateInterruptRace(const Message& parent,
                                        const Message& child)
 {
     return MediateRace(parent, child);
 }
 
 //-----------------------------------------------------------------------------
 // child
 
@@ -101,17 +101,17 @@ TestRaceDeferralChild::AnswerWin()
 }
 
 bool
 TestRaceDeferralChild::AnswerRpc()
 {
     return true;
 }
 
-RacyRPCPolicy
-TestRaceDeferralChild::MediateRPCRace(const Message& parent,
+RacyInterruptPolicy
+TestRaceDeferralChild::MediateInterruptRace(const Message& parent,
                                       const Message& child)
 {
     return MediateRace(parent, child);
 }
 
 } // namespace _ipdltest
 } // namespace mozilla
--- a/ipc/ipdl/test/cxx/TestRaceDeferral.h
+++ b/ipc/ipdl/test/cxx/TestRaceDeferral.h
@@ -21,18 +21,18 @@ public:
 
     void Main();
 
 protected:
     void Test1();
 
     virtual bool AnswerLose() MOZ_OVERRIDE;
 
-    virtual mozilla::ipc::RacyRPCPolicy
-    MediateRPCRace(const Message& parent, const Message& child) MOZ_OVERRIDE;
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const Message& parent, const Message& child) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
             fail("unexpected destruction!");  
         passed("ok");
         QuitParent();
     }
@@ -50,18 +50,18 @@ public:
 
 protected:
     virtual bool RecvStartRace() MOZ_OVERRIDE;
 
     virtual bool AnswerWin() MOZ_OVERRIDE;
 
     virtual bool AnswerRpc() MOZ_OVERRIDE;
 
-    virtual mozilla::ipc::RacyRPCPolicy
-    MediateRPCRace(const Message& parent, const Message& child) MOZ_OVERRIDE;
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const Message& parent, const Message& child) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
             fail("unexpected destruction!");
         QuitChild();
     }
 };
rename from ipc/ipdl/test/cxx/TestRacyRPCReplies.cpp
rename to ipc/ipdl/test/cxx/TestRacyInterruptReplies.cpp
--- a/ipc/ipdl/test/cxx/TestRacyRPCReplies.cpp
+++ b/ipc/ipdl/test/cxx/TestRacyInterruptReplies.cpp
@@ -1,44 +1,44 @@
-#include "TestRacyRPCReplies.h"
+#include "TestRacyInterruptReplies.h"
 
 #include "IPDLUnitTests.h"      // fail etc.
 
 namespace mozilla {
 namespace _ipdltest {
 
 //-----------------------------------------------------------------------------
 // parent
 
-TestRacyRPCRepliesParent::TestRacyRPCRepliesParent() : mReplyNum(0)
+TestRacyInterruptRepliesParent::TestRacyInterruptRepliesParent() : mReplyNum(0)
 {
-    MOZ_COUNT_CTOR(TestRacyRPCRepliesParent);
+    MOZ_COUNT_CTOR(TestRacyInterruptRepliesParent);
 }
 
-TestRacyRPCRepliesParent::~TestRacyRPCRepliesParent()
+TestRacyInterruptRepliesParent::~TestRacyInterruptRepliesParent()
 {
-    MOZ_COUNT_DTOR(TestRacyRPCRepliesParent);
+    MOZ_COUNT_DTOR(TestRacyInterruptRepliesParent);
 }
 
 void
-TestRacyRPCRepliesParent::Main()
+TestRacyInterruptRepliesParent::Main()
 {
     int replyNum = -1;
     if (!CallR_(&replyNum))
         fail("calling R()");
 
     if (1 != replyNum)
         fail("this should have been the first reply to R()");
 
     if (!SendChildTest())
         fail("sending ChildStart");
 }
 
 bool
-TestRacyRPCRepliesParent::RecvA_()
+TestRacyInterruptRepliesParent::RecvA_()
 {
     int replyNum = -1;
     // this R() call races with the reply being generated by the other
     // side to the R() call from Main().  This is a pretty nasty edge
     // case for which one could argue we're breaking in-order message
     // delivery, since this side will process the second reply to R()
     // before the first.
     if (!CallR_(&replyNum))
@@ -46,68 +46,68 @@ TestRacyRPCRepliesParent::RecvA_()
 
     if (2 != replyNum)
         fail("this should have been the second reply to R()");
 
     return true;
 }
 
 bool
-TestRacyRPCRepliesParent::Answer_R(int* replyNum)
+TestRacyInterruptRepliesParent::Answer_R(int* replyNum)
 {
     *replyNum = ++mReplyNum;
 
     if (1 == *replyNum)
         if (!Send_A())
             fail("sending _A()");
 
     return true;
 }
 
 //-----------------------------------------------------------------------------
 // child
 
-TestRacyRPCRepliesChild::TestRacyRPCRepliesChild() : mReplyNum(0)
+TestRacyInterruptRepliesChild::TestRacyInterruptRepliesChild() : mReplyNum(0)
 {
-    MOZ_COUNT_CTOR(TestRacyRPCRepliesChild);
+    MOZ_COUNT_CTOR(TestRacyInterruptRepliesChild);
 }
 
-TestRacyRPCRepliesChild::~TestRacyRPCRepliesChild()
+TestRacyInterruptRepliesChild::~TestRacyInterruptRepliesChild()
 {
-    MOZ_COUNT_DTOR(TestRacyRPCRepliesChild);
+    MOZ_COUNT_DTOR(TestRacyInterruptRepliesChild);
 }
 
 bool
-TestRacyRPCRepliesChild::AnswerR_(int* replyNum)
+TestRacyInterruptRepliesChild::AnswerR_(int* replyNum)
 {
     *replyNum = ++mReplyNum;
 
     if (1 == *replyNum)
         SendA_();
 
     return true;
 }
 
 bool
-TestRacyRPCRepliesChild::RecvChildTest()
+TestRacyInterruptRepliesChild::RecvChildTest()
 {
     int replyNum = -1;
     if (!Call_R(&replyNum))
         fail("calling R()");
 
     if (1 != replyNum)
         fail("this should have been the first reply to R()");
 
     Close();
 
     return true;
 }
 
 bool
-TestRacyRPCRepliesChild::Recv_A()
+TestRacyInterruptRepliesChild::Recv_A()
 {
     int replyNum = -1;
 
     if (!Call_R(&replyNum))
         fail("calling _R()");
 
     if (2 != replyNum)
         fail("this should have been the second reply to R()");
rename from ipc/ipdl/test/cxx/TestRacyRPCReplies.h
rename to ipc/ipdl/test/cxx/TestRacyInterruptReplies.h
--- a/ipc/ipdl/test/cxx/TestRacyRPCReplies.h
+++ b/ipc/ipdl/test/cxx/TestRacyInterruptReplies.h
@@ -1,26 +1,26 @@
-#ifndef mozilla__ipdltest_TestRacyRPCReplies_h
-#define mozilla__ipdltest_TestRacyRPCReplies_h 1
+#ifndef mozilla__ipdltest_TestRacyInterruptReplies_h
+#define mozilla__ipdltest_TestRacyInterruptReplies_h 1
 
 #include "mozilla/_ipdltest/IPDLUnitTests.h"
 
-#include "mozilla/_ipdltest/PTestRacyRPCRepliesParent.h"
-#include "mozilla/_ipdltest/PTestRacyRPCRepliesChild.h"
+#include "mozilla/_ipdltest/PTestRacyInterruptRepliesParent.h"
+#include "mozilla/_ipdltest/PTestRacyInterruptRepliesChild.h"
 
 namespace mozilla {
 namespace _ipdltest {
 
 
-class TestRacyRPCRepliesParent :
-    public PTestRacyRPCRepliesParent
+class TestRacyInterruptRepliesParent :
+    public PTestRacyInterruptRepliesParent
 {
 public:
-    TestRacyRPCRepliesParent();
-    virtual ~TestRacyRPCRepliesParent();
+    TestRacyInterruptRepliesParent();
+    virtual ~TestRacyInterruptRepliesParent();
 
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return true; }
 
     void Main();
 
 protected:    
     virtual bool RecvA_() MOZ_OVERRIDE;
@@ -35,22 +35,22 @@ protected:
         QuitParent();
     }
 
 private:
     int mReplyNum;
 };
 
 
-class TestRacyRPCRepliesChild :
-    public PTestRacyRPCRepliesChild
+class TestRacyInterruptRepliesChild :
+    public PTestRacyInterruptRepliesChild
 {
 public:
-    TestRacyRPCRepliesChild();
-    virtual ~TestRacyRPCRepliesChild();
+    TestRacyInterruptRepliesChild();
+    virtual ~TestRacyInterruptRepliesChild();
 
 protected:
     virtual bool AnswerR_(int* replyNum) MOZ_OVERRIDE;
 
     virtual bool RecvChildTest() MOZ_OVERRIDE;
 
     virtual bool Recv_A() MOZ_OVERRIDE;
 
@@ -65,9 +65,9 @@ private:
     int mReplyNum;
 };
 
 
 } // namespace _ipdltest
 } // namespace mozilla
 
 
-#endif // ifndef mozilla__ipdltest_TestRacyRPCReplies_h
+#endif // ifndef mozilla__ipdltest_TestRacyInterruptReplies_h
--- a/ipc/ipdl/test/cxx/moz.build
+++ b/ipc/ipdl/test/cxx/moz.build
@@ -43,32 +43,32 @@ IPDL_SOURCES += [
     'PTestFailedCtorSub.ipdl',
     'PTestFailedCtorSubsub.ipdl',
     'PTestHandle.ipdl',
     'PTestHangs.ipdl',
     'PTestIndirectProtocolParam.ipdlh',
     'PTestIndirectProtocolParamFirst.ipdl',
     'PTestIndirectProtocolParamManage.ipdl',
     'PTestIndirectProtocolParamSecond.ipdl',
+    'PTestInterruptErrorCleanup.ipdl',
+    'PTestInterruptRaces.ipdl',
+    'PTestInterruptShutdownRace.ipdl',
     'PTestJSON.ipdl',
     'PTestLatency.ipdl',
     'PTestManyChildAllocs.ipdl',
     'PTestManyChildAllocsSub.ipdl',
     'PTestMultiMgrs.ipdl',
     'PTestMultiMgrsBottom.ipdl',
     'PTestMultiMgrsLeft.ipdl',
     'PTestMultiMgrsRight.ipdl',
     'PTestNestedLoops.ipdl',
     'PTestOpens.ipdl',
     'PTestOpensOpened.ipdl',
-    'PTestRPCErrorCleanup.ipdl',
-    'PTestRPCRaces.ipdl',
-    'PTestRPCShutdownRace.ipdl',
     'PTestRaceDeferral.ipdl',
-    'PTestRacyRPCReplies.ipdl',
+    'PTestRacyInterruptReplies.ipdl',
     'PTestRacyReentry.ipdl',
     'PTestRacyUndefer.ipdl',
     'PTestSanity.ipdl',
     'PTestSelfManage.ipdl',
     'PTestSelfManageRoot.ipdl',
     'PTestShmem.ipdl',
     'PTestShutdown.ipdl',
     'PTestShutdownSub.ipdl',
--- a/ipc/ipdl/test/ipdl/error/compressCtor.ipdl
+++ b/ipc/ipdl/test/ipdl/error/compressCtor.ipdl
@@ -1,8 +1,8 @@
 include protocol compressCtorManagee;
 
-rpc protocol compressCtor {
+intr protocol compressCtor {
     manages compressCtorManagee;
 
 parent:
     async compressCtorManagee() compress;
 };
--- a/ipc/ipdl/test/ipdl/error/compressCtorManagee.ipdl
+++ b/ipc/ipdl/test/ipdl/error/compressCtorManagee.ipdl
@@ -1,8 +1,8 @@
 include protocol compressCtor;
 
-rpc protocol compressCtorManagee {
+intr protocol compressCtorManagee {
     manager compressCtor;
 
 child:
     async __delete__() compress;
 };
rename from ipc/ipdl/test/ipdl/error/rpcMessageCompress.ipdl
rename to ipc/ipdl/test/ipdl/error/intrMessageCompress.ipdl
--- a/ipc/ipdl/test/ipdl/error/rpcMessageCompress.ipdl
+++ b/ipc/ipdl/test/ipdl/error/intrMessageCompress.ipdl
@@ -1,6 +1,6 @@
-rpc protocol rpcMessageCompress {
+intr protocol intrMessageCompress {
 parent:
-    rpc foo() compress;
+    intr foo() compress;
 child:
-    rpc bar() compress;
+    intr bar() compress;
 };
--- a/ipc/ipdl/test/ipdl/error/syncParentToChild.ipdl
+++ b/ipc/ipdl/test/ipdl/error/syncParentToChild.ipdl
@@ -1,6 +1,6 @@
-rpc protocol syncParentToChild {
+intr protocol syncParentToChild {
 
     // can't declare sync parent-to-child messages
 child: sync Msg();
 
 };
rename from ipc/ipdl/test/ipdl/error/tooWeakRPCAsync.ipdl
rename to ipc/ipdl/test/ipdl/error/tooWeakInterruptAsync.ipdl
--- a/ipc/ipdl/test/ipdl/error/tooWeakRPCAsync.ipdl
+++ b/ipc/ipdl/test/ipdl/error/tooWeakInterruptAsync.ipdl
@@ -1,7 +1,7 @@
 protocol tooWeakRPCAsync {
 
-    // it's an error to declare an async protocol with an rpc message
+    // it's an error to declare an async protocol with an intr message
 
-parent:  rpc Msg();
+parent:  intr Msg();
 
 };
--- a/ipc/ipdl/test/ipdl/error/trans_WrongDirection4.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongDirection4.ipdl
@@ -1,12 +1,12 @@
-rpc protocol trans_WrongDirection4 {
+intr protocol trans_WrongDirection4 {
 
 child:
-    rpc Msg();
+    intr Msg();
     __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 @@
-rpc protocol trans_WrongDirection5 {
+intr protocol trans_WrongDirection5 {
 
 parent:
-    rpc Msg();
+    intr Msg();
     __delete__()
 
 state S1:
     call Msg goto S1;
 
 start state_:
     recv __delete__;
 };
--- a/ipc/ipdl/test/ipdl/error/trans_WrongName4.ipdl
+++ b/ipc/ipdl/test/ipdl/error/trans_WrongName4.ipdl
@@ -1,10 +1,10 @@
-rpc protocol trans_WrongName4 {
+intr protocol trans_WrongName4 {
 
 child:
-    rpc Msg();
+    intr Msg();
     __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 @@
-rpc protocol trans_WrongName5 {
+intr protocol trans_WrongName5 {
 
 parent:
-    rpc Msg();
+    intr Msg();
     __delete__();
 
 state S1:
     recv Msg goto S1;
     recv __delete__;
 };
rename from ipc/ipdl/test/ipdl/ok/rpcProtocol.ipdl
rename to ipc/ipdl/test/ipdl/ok/intrProtocol.ipdl
--- a/ipc/ipdl/test/ipdl/ok/rpcProtocol.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/intrProtocol.ipdl
@@ -1,13 +1,13 @@
-rpc protocol rpcProtocol {
+intr protocol intrProtocol {
 
-    // sanity check of RPC protocols
+    // sanity check of Interrupt protocols
 child:
     AsyncMsg();
 
 parent:
     sync SyncMsg(int i) returns (int r);
 
 both:
-    rpc RPCMsg(int x) returns (int y);
+    intr InterruptMsg(int x) returns (int y);
 
 };
--- 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;
 
-rpc protocol jetpackContent {
+intr protocol jetpackContent {
     bridges jetpack, content;
 
 child:
     __delete__();
 
 state DEAD:
     send __delete__;
 };
--- a/ipc/ipdl/test/ipdl/ok/messageCompress.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/messageCompress.ipdl
@@ -1,4 +1,4 @@
-rpc protocol messageCompress {
+intr protocol messageCompress {
 child:
     async foo() compress;
 };
--- a/ipc/ipdl/test/ipdl/ok/plugin.ipdl
+++ b/ipc/ipdl/test/ipdl/ok/plugin.ipdl
@@ -1,7 +1,7 @@
-rpc protocol plugin {
+intr protocol plugin {
 child:
     __delete__();
 
 state DEAD:
     send __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;
 };
 
-rpc protocol shmem {
+intr protocol shmem {
 parent:
     Msg(Shmem s, Foo f);
     sync SyncMsg(Shmem s, Foo f)
         returns (Shmem t, Foo g);
-    rpc RPCMsg(Shmem s, Foo f)
+    intr InterruptMsg(Shmem s, Foo f)
         returns (Shmem t, Foo g);
 };
--- a/ipc/testshell/PTestShell.ipdl
+++ b/ipc/testshell/PTestShell.ipdl
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 include protocol PContent;
 include protocol PTestShellCommand;
 
 namespace mozilla {
 namespace ipc {
 
-rpc protocol PTestShell
+intr protocol PTestShell
 {
   manager PContent;
 
   manages PTestShellCommand;
 
 child:
   __delete__();
 
--- a/js/ipc/PJavaScript.ipdl
+++ b/js/ipc/PJavaScript.ipdl
@@ -9,17 +9,17 @@ include protocol PContent;
 include DOMTypes;
 include JavaScriptTypes;
 
 using mozilla::void_t;
 
 namespace mozilla {
 namespace jsipc {
 
-rpc protocol PJavaScript
+intr protocol PJavaScript
 {
     manager PContent;
 
 child:
     // The parent process no longer holds any references to the child object.
     async DropObject(uint64_t objId);
 
     // These roughly map to the ProxyHandler hooks that CPOWs need.