--- 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