Remove 'Protocol' suffix from IPDL-generated files
authorBen Turner <bent.mozilla@gmail.com>
Wed, 09 Sep 2009 15:59:06 -0700
changeset 35898 9a228540021640970ac119cd38dbb92a681a3fa7
parent 35897 e5bab733fbd147591421a0340147da6fbc2e8cf4
child 35899 d0d751ed8c3e82aa203fc1775411b52835728a85
push idunknown
push userunknown
push dateunknown
milestone1.9.3a1pre
Remove 'Protocol' suffix from IPDL-generated files
dom/ipc/ContentProcessChild.cpp
dom/ipc/ContentProcessChild.h
dom/ipc/ContentProcessParent.cpp
dom/ipc/ContentProcessParent.h
dom/ipc/TabChild.h
dom/ipc/TabParent.h
dom/plugins/BrowserStreamChild.h
dom/plugins/BrowserStreamParent.h
dom/plugins/PluginInstanceChild.cpp
dom/plugins/PluginInstanceChild.h
dom/plugins/PluginInstanceParent.cpp
dom/plugins/PluginInstanceParent.h
dom/plugins/PluginModuleChild.cpp
dom/plugins/PluginModuleChild.h
dom/plugins/PluginModuleParent.cpp
dom/plugins/PluginModuleParent.h
dom/plugins/PluginScriptableObjectChild.h
dom/plugins/PluginScriptableObjectParent.h
ipc/ipdl/ipdl.py
ipc/ipdl/ipdl/lower.py
ipc/test-harness/TestChild.h
ipc/test-harness/TestParent.h
ipc/testshell/TestShellChild.cpp
ipc/testshell/TestShellChild.h
ipc/testshell/TestShellParent.cpp
ipc/testshell/TestShellParent.h
--- a/dom/ipc/ContentProcessChild.cpp
+++ b/dom/ipc/ContentProcessChild.cpp
@@ -68,47 +68,47 @@ ContentProcessChild::Init(MessageLoop* a
     NS_ASSERTION(!sSingleton, "only one ContentProcessChild per child");
   
     Open(aChannel, aIOLoop);
     sSingleton = this;
 
     return true;
 }
 
-PIFrameEmbeddingProtocolChild*
+PIFrameEmbeddingChild*
 ContentProcessChild::PIFrameEmbeddingConstructor(const MagicWindowHandle& hwnd)
 {
-    PIFrameEmbeddingProtocolChild* iframe = new TabChild(hwnd);
+    PIFrameEmbeddingChild* iframe = new TabChild(hwnd);
     if (iframe && mIFrames.AppendElement(iframe)) {
         return iframe;
     }
     delete iframe;
     return nsnull;
 }
 
 nsresult
-ContentProcessChild::PIFrameEmbeddingDestructor(PIFrameEmbeddingProtocolChild* iframe)
+ContentProcessChild::PIFrameEmbeddingDestructor(PIFrameEmbeddingChild* iframe)
 {
     mIFrames.RemoveElement(iframe);
     return NS_OK;
 }
 
-PTestShellProtocolChild*
+PTestShellChild*
 ContentProcessChild::PTestShellConstructor()
 {
-    PTestShellProtocolChild* testshell = new TestShellChild();
+    PTestShellChild* testshell = new TestShellChild();
     if (testshell && mTestShells.AppendElement(testshell)) {
         return testshell;
     }
     delete testshell;
     return nsnull;
 }
 
 nsresult
-ContentProcessChild::PTestShellDestructor(PTestShellProtocolChild* shell)
+ContentProcessChild::PTestShellDestructor(PTestShellChild* shell)
 {
     mTestShells.RemoveElement(shell);
     return NS_OK;
 }
 
 void
 ContentProcessChild::Quit()
 {
--- a/dom/ipc/ContentProcessChild.h
+++ b/dom/ipc/ContentProcessChild.h
@@ -34,52 +34,51 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_dom_ContentProcessChild_h
 #define mozilla_dom_ContentProcessChild_h
 
-#include "mozilla/dom/PContentProcessProtocolChild.h"
+#include "mozilla/dom/PContentProcessChild.h"
 
 #include "nsTArray.h"
 #include "nsAutoPtr.h"
 
 namespace mozilla {
 namespace dom {
 
-class ContentProcessChild
-    : public PContentProcessProtocolChild
+class ContentProcessChild : public PContentProcessChild
 {
 public:
     ContentProcessChild();
     virtual ~ContentProcessChild();
 
     bool Init(MessageLoop* aIOLoop, IPC::Channel* aChannel);
 
     static ContentProcessChild* GetSingleton() {
         NS_ASSERTION(sSingleton, "not initialized");
         return sSingleton;
     }
 
-    virtual PIFrameEmbeddingProtocolChild* PIFrameEmbeddingConstructor(const MagicWindowHandle& hwnd);
-    virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingProtocolChild*);
+    virtual PIFrameEmbeddingChild* PIFrameEmbeddingConstructor(const MagicWindowHandle& hwnd);
+    virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingChild*);
 
-    virtual PTestShellProtocolChild* PTestShellConstructor();
-    virtual nsresult PTestShellDestructor(PTestShellProtocolChild*);
+    virtual PTestShellChild* PTestShellConstructor();
+    virtual nsresult PTestShellDestructor(PTestShellChild*);
 
     void Quit();
     virtual nsresult RecvQuit();
 
 private:
     static ContentProcessChild* sSingleton;
 
-    nsTArray<nsAutoPtr<PIFrameEmbeddingProtocolChild> > mIFrames;
-    nsTArray<nsAutoPtr<PTestShellProtocolChild> > mTestShells;
+    nsTArray<nsAutoPtr<PIFrameEmbeddingChild> > mIFrames;
+    nsTArray<nsAutoPtr<PTestShellChild> > mTestShells;
 
     PRBool mQuit;
 
     DISALLOW_EVIL_CONSTRUCTORS(ContentProcessChild);
 };
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/ipc/ContentProcessParent.cpp
+++ b/dom/ipc/ContentProcessParent.cpp
@@ -135,36 +135,36 @@ ContentProcessParent::OnWaitableEventSig
 {
     // The child process has died! Sadly we're on the wrong thread to do much.
     NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
     MonitorAutoEnter mon(mMonitor);
     mSubprocess = nsnull;
     mon.Notify();
 }
 
-PIFrameEmbeddingProtocolParent*
+PIFrameEmbeddingParent*
 ContentProcessParent::PIFrameEmbeddingConstructor(const MagicWindowHandle& parentWidget)
 {
     return new TabParent();
 }
 
 nsresult
-ContentProcessParent::PIFrameEmbeddingDestructor(PIFrameEmbeddingProtocolParent* frame)
+ContentProcessParent::PIFrameEmbeddingDestructor(PIFrameEmbeddingParent* frame)
 {
   delete frame;
   return NS_OK;
 }
 
-PTestShellProtocolParent*
+PTestShellParent*
 ContentProcessParent::PTestShellConstructor()
 {
   return new TestShellParent();
 }
 
 nsresult
-ContentProcessParent::PTestShellDestructor(PTestShellProtocolParent* shell)
+ContentProcessParent::PTestShellDestructor(PTestShellParent* shell)
 {
   delete shell;
   return NS_OK;
 }
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/ipc/ContentProcessParent.h
+++ b/dom/ipc/ContentProcessParent.h
@@ -36,36 +36,35 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_dom_ContentProcessParent_h
 #define mozilla_dom_ContentProcessParent_h
 
 #include "base/waitable_event_watcher.h"
 
-#include "mozilla/dom/PContentProcessProtocolParent.h"
+#include "mozilla/dom/PContentProcessParent.h"
 #include "mozilla/ipc/GeckoChildProcessHost.h"
 
 #include "nsIObserver.h"
 #include "mozilla/Monitor.h"
 
 namespace mozilla {
 
 namespace ipc {
 class TestShellParent;
 }
 
 namespace dom {
 
 class TabParent;
 
-class ContentProcessParent
-    : private PContentProcessProtocolParent,
-      public base::WaitableEventWatcher::Delegate,
-      public nsIObserver
+class ContentProcessParent : private PContentProcessParent,
+                             public base::WaitableEventWatcher::Delegate,
+                             public nsIObserver
 {
 private:
     typedef mozilla::ipc::GeckoChildProcessHost GeckoChildProcessHost;
 
 public:
     static ContentProcessParent* GetSingleton();
 
 #if 0
@@ -81,27 +80,27 @@ public:
     TabParent* CreateTab(const MagicWindowHandle& hwnd);
     mozilla::ipc::TestShellParent* CreateTestShell();
 
 private:
     static ContentProcessParent* gSingleton;
 
     // Hide the raw constructor methods since we don't want client code
     // using them.
-    using PContentProcessProtocolParent::SendPIFrameEmbeddingConstructor;
-    using PContentProcessProtocolParent::SendPTestShellConstructor;
+    using PContentProcessParent::SendPIFrameEmbeddingConstructor;
+    using PContentProcessParent::SendPTestShellConstructor;
 
     ContentProcessParent();
     virtual ~ContentProcessParent();
 
-    virtual PIFrameEmbeddingProtocolParent* PIFrameEmbeddingConstructor(const MagicWindowHandle& parentWidget);
-    virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingProtocolParent* frame);
+    virtual PIFrameEmbeddingParent* PIFrameEmbeddingConstructor(const MagicWindowHandle& parentWidget);
+    virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingParent* frame);
 
-    virtual PTestShellProtocolParent* PTestShellConstructor();
-    virtual nsresult PTestShellDestructor(PTestShellProtocolParent* shell);
+    virtual PTestShellParent* PTestShellConstructor();
+    virtual nsresult PTestShellDestructor(PTestShellParent* shell);
 
     mozilla::Monitor mMonitor;
 
     GeckoChildProcessHost* mSubprocess;
 };
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -33,25 +33,24 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_tabs_TabChild_h
 #define mozilla_tabs_TabChild_h
 
-#include "mozilla/dom/PIFrameEmbeddingProtocolChild.h"
+#include "mozilla/dom/PIFrameEmbeddingChild.h"
 #include "nsIWebNavigation.h"
 #include "nsCOMPtr.h"
 
 namespace mozilla {
 namespace dom {
 
-class TabChild
-    : public PIFrameEmbeddingProtocolChild
+class TabChild : public PIFrameEmbeddingChild
 {
 public:
     TabChild(const MagicWindowHandle& parentWidget);
     virtual ~TabChild();
 
     virtual nsresult RecvloadURL(const nsCString& uri);
     virtual nsresult Recvmove(const PRUint32& x,
                               const PRUint32& y,
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -34,27 +34,26 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_tabs_TabParent_h
 #define mozilla_tabs_TabParent_h
 
-#include "mozilla/dom/PIFrameEmbeddingProtocolParent.h"
+#include "mozilla/dom/PIFrameEmbeddingParent.h"
 
 #include "mozilla/ipc/GeckoChildProcessHost.h"
 
 class nsIURI;
 
 namespace mozilla {
 namespace dom {
 
-class TabParent
-    : public PIFrameEmbeddingProtocolParent
+class TabParent : public PIFrameEmbeddingParent
 {
 public:
     TabParent();
     virtual ~TabParent();
 
     void LoadURL(nsIURI* aURI);
     void Move(PRUint32 x, PRUint32 y, PRUint32 width, PRUint32 height);
 };
--- a/dom/plugins/BrowserStreamChild.h
+++ b/dom/plugins/BrowserStreamChild.h
@@ -33,24 +33,24 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_plugins_BrowserStreamChild_h
 #define mozilla_plugins_BrowserStreamChild_h 1
 
-#include "mozilla/plugins/PBrowserStreamProtocolChild.h"
+#include "mozilla/plugins/PBrowserStreamChild.h"
 
 namespace mozilla {
 namespace plugins {
 
 class PluginInstanceChild;
 
-class BrowserStreamChild : public PBrowserStreamProtocolChild
+class BrowserStreamChild : public PBrowserStreamChild
 {
 public:
   BrowserStreamChild(PluginInstanceChild* instance,
                      const nsCString& url,
                      const uint32_t& length,
                      const uint32_t& lastmodified,
                      const nsCString& headers,
                      const nsCString& mimeType,
--- a/dom/plugins/BrowserStreamParent.h
+++ b/dom/plugins/BrowserStreamParent.h
@@ -1,21 +1,21 @@
 /* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
 
 #ifndef mozilla_plugins_BrowserStreamParent_h
 #define mozilla_plugins_BrowserStreamParent_h
 
-#include "mozilla/plugins/PBrowserStreamProtocolParent.h"
+#include "mozilla/plugins/PBrowserStreamParent.h"
 
 namespace mozilla {
 namespace plugins {
 
 class PluginInstanceParent;
 
-class BrowserStreamParent : public PBrowserStreamProtocolParent
+class BrowserStreamParent : public PBrowserStreamParent
 {
   friend class PluginModuleParent;
   friend class PluginInstanceParent;
 
 public:
   BrowserStreamParent(PluginInstanceParent* npp,
                       NPStream* stream);
   virtual ~BrowserStreamParent() { }
--- a/dom/plugins/PluginInstanceChild.cpp
+++ b/dom/plugins/PluginInstanceChild.cpp
@@ -357,47 +357,47 @@ PluginInstanceChild::PluginWindowProc(HW
     if (message == WM_NCDESTROY)
         RemoveProp(hWnd, kPluginInstanceChildProperty);
 
     return res;
 }
 
 #endif // OS_WIN
 
-PPluginScriptableObjectProtocolChild*
+PPluginScriptableObjectChild*
 PluginInstanceChild::PPluginScriptableObjectConstructor(NPError* _retval)
 {
     NS_NOTYETIMPLEMENTED("PluginInstanceChild::NPObjectConstructor");
     return nsnull;
 }
 
 nsresult
-PluginInstanceChild::PPluginScriptableObjectDestructor(PPluginScriptableObjectProtocolChild* aObject,
+PluginInstanceChild::PPluginScriptableObjectDestructor(PPluginScriptableObjectChild* aObject,
                                                        NPError* _retval)
 {
     NS_NOTYETIMPLEMENTED("PluginInstanceChild::NPObjectDestructor");
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
-PBrowserStreamProtocolChild*
+PBrowserStreamChild*
 PluginInstanceChild::PBrowserStreamConstructor(const nsCString& url,
                                                const uint32_t& length,
                                                const uint32_t& lastmodified,
                                                const nsCString& headers,
                                                const nsCString& mimeType,
                                                const bool& seekable,
                                                NPError* rv,
                                                uint16_t *stype)
 {
     return new BrowserStreamChild(this, url, length, lastmodified, headers,
                                   mimeType, seekable, rv, stype);
 }
 
 nsresult
-PluginInstanceChild::PBrowserStreamDestructor(PBrowserStreamProtocolChild* stream,
+PluginInstanceChild::PBrowserStreamDestructor(PBrowserStreamChild* stream,
                                               const NPError& reason,
                                               const bool& artificial)
 {
     delete stream;
     return NS_OK;
 }
 
 } // namespace plugins
--- a/dom/plugins/PluginInstanceChild.h
+++ b/dom/plugins/PluginInstanceChild.h
@@ -34,65 +34,66 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef dom_plugins_PluginInstanceChild_h
 #define dom_plugins_PluginInstanceChild_h 1
 
-#include "mozilla/plugins/PPluginInstanceProtocolChild.h"
+#include "mozilla/plugins/PPluginInstanceChild.h"
 #include "mozilla/plugins/PluginScriptableObjectChild.h"
 
 #include "npfunctions.h"
 
 #undef _MOZ_LOG
 #define _MOZ_LOG(s) printf("[PluginInstanceChild] %s\n", s)
 
 namespace mozilla {
 namespace plugins {
 
-class PBrowserStreamProtocolChild;
+class PBrowserStreamChild;
+class BrowserStreamChild;
 
-class PluginInstanceChild : public PPluginInstanceProtocolChild
+class PluginInstanceChild : public PPluginInstanceChild
 {
 #ifdef OS_WIN
     friend LRESULT CALLBACK PluginWindowProc(HWND hWnd,
                                              UINT message,
                                              WPARAM wParam,
                                              LPARAM lParam);
 #endif
 
 protected:
     friend class BrowserStreamChild;
 
     virtual nsresult AnswerNPP_SetWindow(const NPWindow& window, NPError* rv);
 
     virtual nsresult AnswerNPP_GetValue(const nsString& key, nsString* value);
 
-    virtual PPluginScriptableObjectProtocolChild*
+    virtual PPluginScriptableObjectChild*
     PPluginScriptableObjectConstructor(NPError* _retval);
 
     virtual nsresult
-    PPluginScriptableObjectDestructor(PPluginScriptableObjectProtocolChild* aObject,
+    PPluginScriptableObjectDestructor(PPluginScriptableObjectChild* aObject,
                                       NPError* _retval);
 
 
-    virtual PBrowserStreamProtocolChild*
+    virtual PBrowserStreamChild*
     PBrowserStreamConstructor(const nsCString& url,
                               const uint32_t& length,
                               const uint32_t& lastmodified,
                               const nsCString& headers,
                               const nsCString& mimeType,
                               const bool& seekable,
                               NPError* rv,
                               uint16_t *stype);
 
     virtual nsresult
-    PBrowserStreamDestructor(PBrowserStreamProtocolChild* stream,
+    PBrowserStreamDestructor(PBrowserStreamChild* stream,
                              const NPError& reason,
                              const bool& artificial);
 
 public:
     PluginInstanceChild(const NPPluginFuncs* aPluginIface) :
         mPluginIface(aPluginIface)
 #if defined(OS_LINUX)
         , mPlug(0)
--- a/dom/plugins/PluginInstanceParent.cpp
+++ b/dom/plugins/PluginInstanceParent.cpp
@@ -37,43 +37,43 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "PluginInstanceParent.h"
 #include "BrowserStreamParent.h"
 
 namespace mozilla {
 namespace plugins {
 
-PBrowserStreamProtocolParent*
+PBrowserStreamParent*
 PluginInstanceParent::PBrowserStreamConstructor(const nsCString& url,
                                                 const uint32_t& length,
                                                 const uint32_t& lastmodified,
                                                 const nsCString& headers,
                                                 const nsCString& mimeType,
                                                 const bool& seekable,
                                                 NPError* rv,
                                                 uint16_t *stype)
 {
     NS_RUNTIMEABORT("Not reachable");
     return NULL;
 }
 
 nsresult
-PluginInstanceParent::AnswerPBrowserStreamDestructor(PBrowserStreamProtocolParent* stream,
+PluginInstanceParent::AnswerPBrowserStreamDestructor(PBrowserStreamParent* stream,
                                                      const NPError& reason,
                                                      const bool& artificial)
 {
     if (!artificial) {
         static_cast<BrowserStreamParent*>(stream)->NPN_DestroyStream(reason);
     }
     return NS_OK;
 }
 
 nsresult
-PluginInstanceParent::PBrowserStreamDestructor(PBrowserStreamProtocolParent* stream,
+PluginInstanceParent::PBrowserStreamDestructor(PBrowserStreamParent* stream,
                                                const NPError& reason,
                                                const bool& artificial)
 {
     delete stream;
     return NS_OK;
 }
 
 NPError
@@ -131,25 +131,25 @@ PluginInstanceParent::NPP_DestroyStream(
     BrowserStreamParent* sp =
         static_cast<BrowserStreamParent*>(stream->pdata);
     if (sp->mNPP != this)
         NS_RUNTIMEABORT("Mismatched plugin data");
 
     return CallPBrowserStreamDestructor(sp, reason, false);
 }
 
-PPluginScriptableObjectProtocolParent*
+PPluginScriptableObjectParent*
 PluginInstanceParent::PPluginScriptableObjectConstructor(NPError* _retval)
 {
     NS_NOTYETIMPLEMENTED("PluginInstanceParent::PPluginScriptableObjectConstructor");
     return nsnull;
 }
 
 nsresult
-PluginInstanceParent::PPluginScriptableObjectDestructor(PPluginScriptableObjectProtocolParent* aObject,
+PluginInstanceParent::PPluginScriptableObjectDestructor(PPluginScriptableObjectParent* aObject,
                                                         NPError* _retval)
 {
     NS_NOTYETIMPLEMENTED("PluginInstanceParent::PPluginScriptableObjectDestructor");
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 } // namespace plugins
 } // namespace mozilla
--- a/dom/plugins/PluginInstanceParent.h
+++ b/dom/plugins/PluginInstanceParent.h
@@ -34,30 +34,31 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef dom_plugins_PluginInstanceParent_h
 #define dom_plugins_PluginInstanceParent_h 1
 
-#include "mozilla/plugins/PPluginInstanceProtocolParent.h"
+#include "mozilla/plugins/PPluginInstanceParent.h"
 #include "mozilla/plugins/PluginScriptableObjectParent.h"
 
 #include "npfunctions.h"
 
 #undef _MOZ_LOG
 #define _MOZ_LOG(s) printf("[PluginInstanceParent] %s\n", s)
 
 namespace mozilla {
 namespace plugins {
 
+class PBrowserStreamParent;
 class BrowserStreamParent;
 
-class PluginInstanceParent : public PPluginInstanceProtocolParent
+class PluginInstanceParent : public PPluginInstanceParent
 {
     friend class PluginModuleParent;
     friend class BrowserStreamParent;
 
 public:
     PluginInstanceParent(NPP npp, const NPNetscapeFuncs* npniface)
         : mNPP(npp)
         , mNPNIface(npniface)
@@ -68,40 +69,40 @@ public:
     {
     }
 
     virtual nsresult AnswerNPN_GetValue(const nsString& in, nsString* out)
     {
         return NS_OK;
     }
 
-    virtual PPluginScriptableObjectProtocolParent*
+    virtual PPluginScriptableObjectParent*
     PPluginScriptableObjectConstructor(NPError* _retval);
 
     virtual nsresult
-    PPluginScriptableObjectDestructor(PPluginScriptableObjectProtocolParent* aObject,
+    PPluginScriptableObjectDestructor(PPluginScriptableObjectParent* aObject,
                                       NPError* _retval);
 
-    virtual PBrowserStreamProtocolParent*
+    virtual PBrowserStreamParent*
     PBrowserStreamConstructor(const nsCString& url,
                               const uint32_t& length,
                               const uint32_t& lastmodified,
                               const nsCString& headers,
                               const nsCString& mimeType,
                               const bool& seekable,
                               NPError* rv,
                               uint16_t *stype);
 
     virtual nsresult
-    AnswerPBrowserStreamDestructor(PBrowserStreamProtocolParent* stream,
+    AnswerPBrowserStreamDestructor(PBrowserStreamParent* stream,
                                    const NPError& reason,
                                    const bool& artificial);
 
     virtual nsresult
-    PBrowserStreamDestructor(PBrowserStreamProtocolParent* stream,
+    PBrowserStreamDestructor(PBrowserStreamParent* stream,
                              const NPError& reason,
                              const bool& artificial);
 
     NPError NPP_SetWindow(NPWindow* aWindow);
     NPError NPP_GetValue(NPPVariable variable, void *ret_value);
 
     NPError NPP_SetValue(NPNVariable variable, void *value)
     {
--- a/dom/plugins/PluginModuleChild.cpp
+++ b/dom/plugins/PluginModuleChild.cpp
@@ -907,17 +907,17 @@ PluginModuleChild::AnswerNP_Initialize(N
 
     *_retval = mInitializeFunc(&sBrowserFuncs);
     return NS_OK;
 #else
 #  error Please implement me for your platform
 #endif
 }
 
-PPluginInstanceProtocolChild*
+PPluginInstanceChild*
 PluginModuleChild::PPluginInstanceConstructor(const nsCString& aMimeType,
                                               const uint16_t& aMode,
                                               const nsTArray<nsCString>& aNames,
                                               const nsTArray<nsCString>& aValues,
                                               NPError* rv)
 {
     _MOZ_LOG(__FUNCTION__);
 
@@ -961,17 +961,17 @@ PluginModuleChild::PPluginInstanceConstr
         return nsnull;
     }
 
     printf ("[PluginModuleChild] %s: returning %hd\n", __FUNCTION__, *rv);
     return childInstance.forget();
 }
 
 nsresult
-PluginModuleChild::PPluginInstanceDestructor(PPluginInstanceProtocolChild* actor,
+PluginModuleChild::PPluginInstanceDestructor(PPluginInstanceChild* actor,
                                              NPError* rv)
 {
     _MOZ_LOG(__FUNCTION__);
 
     PluginInstanceChild* inst = static_cast<PluginInstanceChild*>(actor);
     *rv = mFunctions.destroy(inst->GetNPP(), 0);
     delete actor;
     inst->GetNPP()->ndata = 0;
--- a/dom/plugins/PluginModuleChild.h
+++ b/dom/plugins/PluginModuleChild.h
@@ -48,17 +48,17 @@
 #include "prlink.h"
 
 #include "npapi.h"
 #include "npfunctions.h"
 #include "nsplugindefs.h"
 
 #include "nsAutoPtr.h"
 
-#include "mozilla/plugins/PPluginModuleProtocolChild.h"
+#include "mozilla/plugins/PPluginModuleChild.h"
 #include "mozilla/plugins/PluginInstanceChild.h"
 
 // NOTE: stolen from nsNPAPIPlugin.h
 
 /*
  * Use this macro before each exported function
  * (between the return address and the function
  * itself), to ensure that the function has the
@@ -88,31 +88,31 @@ typedef NS_NPAPIPLUGIN_CALLBACK(NPError,
 
 #undef _MOZ_LOG
 #define _MOZ_LOG(s)  printf("[NPAPIPluginChild] %s\n", s)
 
 namespace mozilla {
 namespace plugins {
 //-----------------------------------------------------------------------------
 
-class PluginModuleChild : public PPluginModuleProtocolChild
+class PluginModuleChild : public PPluginModuleChild
 {
 protected:
-    // Implement the PPluginModuleProtocolChild interface
+    // Implement the PPluginModuleChild interface
     virtual nsresult AnswerNP_Initialize(NPError* rv);
 
-    virtual PPluginInstanceProtocolChild*
+    virtual PPluginInstanceChild*
     PPluginInstanceConstructor(const nsCString& aMimeType,
                                const uint16_t& aMode,
                                const nsTArray<nsCString>& aNames,
                                const nsTArray<nsCString>& aValues,
                                NPError* rv);
 
     virtual nsresult
-    PPluginInstanceDestructor(PPluginInstanceProtocolChild* actor,
+    PPluginInstanceDestructor(PPluginInstanceChild* actor,
                               NPError* rv);
 
 public:
     PluginModuleChild();
     virtual ~PluginModuleChild();
 
     bool Init(const std::string& aPluginFilename,
               MessageLoop* aIOLoop,
--- a/dom/plugins/PluginModuleParent.cpp
+++ b/dom/plugins/PluginModuleParent.cpp
@@ -70,29 +70,29 @@ PluginModuleParent::PluginModuleParent(c
 }
 
 PluginModuleParent::~PluginModuleParent()
 {
     _MOZ_LOG("  (closing Shim ...)");
     delete mShim;
 }
 
-PPluginInstanceProtocolParent*
+PPluginInstanceParent*
 PluginModuleParent::PPluginInstanceConstructor(const nsCString& aMimeType,
                                                const uint16_t& aMode,
                                                const nsTArray<nsCString>& aNames,
                                                const nsTArray<nsCString>& aValues,
                                                NPError* rv)
 {
     NS_ERROR("Not reachable!");
     return NULL;
 }
 
 nsresult
-PluginModuleParent::PPluginInstanceDestructor(PPluginInstanceProtocolParent* aActor,
+PluginModuleParent::PPluginInstanceDestructor(PPluginInstanceParent* aActor,
                                               NPError* _retval)
 {
     _MOZ_LOG(__FUNCTION__);
     delete aActor;
     return NS_OK;
 }
 
 void
--- a/dom/plugins/PluginModuleParent.h
+++ b/dom/plugins/PluginModuleParent.h
@@ -47,17 +47,17 @@
 
 #include "npapi.h"
 #include "npfunctions.h"
 #include "nsplugindefs.h"
 
 #include "base/string_util.h"
 
 #include "mozilla/SharedLibrary.h"
-#include "mozilla/plugins/PPluginModuleProtocolParent.h"
+#include "mozilla/plugins/PPluginModuleParent.h"
 #include "mozilla/plugins/PluginInstanceParent.h"
 #include "mozilla/plugins/PluginProcessParent.h"
 
 #include "nsAutoPtr.h"
 
 #undef _MOZ_LOG
 #define _MOZ_LOG(s) printf("[PluginModuleParent] %s\n", s)
 
@@ -71,31 +71,31 @@ namespace plugins {
  * This class implements the NPP API from the perspective of the rest
  * of Gecko, forwarding NPP calls along to the child process that is
  * actually running the plugin.
  *
  * This class /also/ implements a version of the NPN API, because the
  * child process needs to make these calls back into Gecko proper.
  * This class is responsible for "actually" making those function calls.
  */
-class PluginModuleParent : public PPluginModuleProtocolParent
+class PluginModuleParent : public PPluginModuleParent
 {
 private:
     typedef mozilla::SharedLibrary SharedLibrary;
 
 protected:
-    PPluginInstanceProtocolParent*
+    PPluginInstanceParent*
     PPluginInstanceConstructor(const nsCString& aMimeType,
                                const uint16_t& aMode,
                                const nsTArray<nsCString>& aNames,
                                const nsTArray<nsCString>& aValues,
                                NPError* rv);
 
     virtual nsresult
-    PPluginInstanceDestructor(PPluginInstanceProtocolParent* aActor,
+    PPluginInstanceDestructor(PPluginInstanceParent* aActor,
                               NPError* _retval);
 
 public:
     PluginModuleParent(const char* aFilePath);
 
     virtual ~PluginModuleParent();
 
     /**
--- a/dom/plugins/PluginScriptableObjectChild.h
+++ b/dom/plugins/PluginScriptableObjectChild.h
@@ -34,22 +34,22 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef dom_plugins_PluginScriptableObjectChild_h
 #define dom_plugins_PluginScriptableObjectChild_h 1
 
-#include "mozilla/plugins/PPluginScriptableObjectProtocolChild.h"
+#include "mozilla/plugins/PPluginScriptableObjectChild.h"
 
 namespace mozilla {
 namespace plugins {
 
-class PluginScriptableObjectChild : public PPluginScriptableObjectProtocolChild
+class PluginScriptableObjectChild : public PPluginScriptableObjectChild
 {
 public:
   PluginScriptableObjectChild();
   virtual ~PluginScriptableObjectChild();
 
   virtual nsresult
   AnswerInvalidate();
 
--- a/dom/plugins/PluginScriptableObjectParent.h
+++ b/dom/plugins/PluginScriptableObjectParent.h
@@ -34,22 +34,22 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef dom_plugins_PluginScriptableObjectParent_h
 #define dom_plugins_PluginScriptableObjectParent_h 1
 
-#include "mozilla/plugins/PPluginScriptableObjectProtocolParent.h"
+#include "mozilla/plugins/PPluginScriptableObjectParent.h"
 
 namespace mozilla {
 namespace plugins {
 
-class PluginScriptableObjectParent : public PPluginScriptableObjectProtocolParent
+class PluginScriptableObjectParent : public PPluginScriptableObjectParent
 {
 public:
   PluginScriptableObjectParent();
   virtual ~PluginScriptableObjectParent();
 };
 
 } /* namespace plugins */
 } /* namespace mozilla */
--- a/ipc/ipdl/ipdl.py
+++ b/ipc/ipdl/ipdl.py
@@ -76,17 +76,17 @@ for f in files:
     specstring = fd.read()
     fd.close()
 
     ast = ipdl.parse(specstring, filename, includedirs=includedirs)
     if ast is None:
         print >>sys.stderr, 'Specification could not be parsed.'
         sys.exit(1)
 
-    allprotocols.append('%sProtocolMsgStart' % ast.protocol.name)
+    allprotocols.append('%sMsgStart' % ast.protocol.name)
 
     log(2, 'checking types')
     if not ipdl.typecheck(ast):
         print >>sys.stderr, 'Specification is not well typed.'
         sys.exit(1)
 
     if _verbosity > 2:
         log(3, '  pretty printed code:')
--- a/ipc/ipdl/ipdl/lower.py
+++ b/ipc/ipdl/ipdl/lower.py
@@ -43,21 +43,21 @@ def _joinProtocolNamespacesName(sep, p, 
 
 def _protocolIncludeGuard(p, pname):
     return _joinProtocolNamespacesName('_', p, pname) +'_h'
 
 def _protocolHeaderFilename(p, pname):
     return _joinProtocolNamespacesName('/', p, pname)+ '.h'
 
 def _protocolHeaderName(pname):
-    return pname +'Protocol'
+    return pname
 
 def _actorName(pname, side):
     """|pname| is the protocol name. |side| is 'Parent' or 'Child'."""
-    return pname +'Protocol'+ side
+    return pname + side
 
 def _makeForwardDecl(p, side):
     clsname = _actorName(p.decl.type.qname.baseid, side)
     
     fd = cxx.ForwardDecl(clsname, cls=1)
     if 0 == len(p.namespaces):
         return fd
 
--- a/ipc/test-harness/TestChild.h
+++ b/ipc/test-harness/TestChild.h
@@ -33,24 +33,23 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef ipc_test_harness_TestChild_h
 #define ipc_test_harness_TestChild_h 1
 
-#include "mozilla/test/PTestProtocolChild.h"
+#include "mozilla/test/PTestChild.h"
 
 namespace mozilla {
 namespace test {
 
 // Header file contents
-class TestChild :
-    public PTestProtocolChild
+class TestChild : public PTestChild
 {
 protected:
 
 #if 1
 //-----------------------------------------------------------------------------
 // "Hello world" example
     virtual nsresult RecvHello();
 
--- a/ipc/test-harness/TestParent.h
+++ b/ipc/test-harness/TestParent.h
@@ -33,24 +33,23 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef ipc_test_harness_TestParent_h
 #define ipc_test_harness_TestParent_h 1
 
-#include "mozilla/test/PTestProtocolParent.h"
+#include "mozilla/test/PTestParent.h"
 
 namespace mozilla {
 namespace test {
 
 // Header file contents
-class TestParent :
-    public PTestProtocolParent
+class TestParent : public PTestParent
 {
 protected:
 #if 1
 //-----------------------------------------------------------------------------
 // "Hello world" example
     virtual nsresult RecvWorld();
 
 
--- a/ipc/testshell/TestShellChild.cpp
+++ b/ipc/testshell/TestShellChild.cpp
@@ -32,17 +32,17 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "TestShellChild.h"
 
 using mozilla::ipc::TestShellChild;
-using mozilla::ipc::PTestShellCommandProtocolChild;
+using mozilla::ipc::PTestShellCommandChild;
 using mozilla::ipc::XPCShellEnvironment;
 
 TestShellChild::TestShellChild()
 : mXPCShell(XPCShellEnvironment::CreateEnvironment())
 {
 }
 
 nsresult
@@ -51,33 +51,33 @@ TestShellChild::RecvExecuteCommand(const
   if (mXPCShell->IsQuitting()) {
     NS_WARNING("Commands sent after quit command issued!");
     return NS_ERROR_UNEXPECTED;
   }
 
   return mXPCShell->EvaluateString(aCommand) ? NS_OK : NS_ERROR_FAILURE;
 }
 
-PTestShellCommandProtocolChild*
+PTestShellCommandChild*
 TestShellChild::PTestShellCommandConstructor(const nsString& aCommand)
 {
-  return new PTestShellCommandProtocolChild();
+  return new PTestShellCommandChild();
 }
 
 nsresult
-TestShellChild::PTestShellCommandDestructor(PTestShellCommandProtocolChild* aCommand,
+TestShellChild::PTestShellCommandDestructor(PTestShellCommandChild* aCommand,
                                             const nsString& aResponse)
 {
   NS_ENSURE_ARG_POINTER(aCommand);
   delete aCommand;
   return NS_OK;
 }
 
 nsresult
-TestShellChild::RecvPTestShellCommandConstructor(PTestShellCommandProtocolChild* aActor,
+TestShellChild::RecvPTestShellCommandConstructor(PTestShellCommandChild* aActor,
                                                  const nsString& aCommand)
 {
   NS_ASSERTION(aActor, "Shouldn't be null!");
 
   if (mXPCShell->IsQuitting()) {
     NS_WARNING("Commands sent after quit command issued!");
     return NS_ERROR_UNEXPECTED;
   }
--- a/ipc/testshell/TestShellChild.h
+++ b/ipc/testshell/TestShellChild.h
@@ -32,44 +32,44 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef ipc_testshell_TestShellChild_h
 #define ipc_testshell_TestShellChild_h 1
 
-#include "mozilla/ipc/PTestShellProtocolChild.h"
-#include "mozilla/ipc/PTestShellCommandProtocolChild.h"
+#include "mozilla/ipc/PTestShellChild.h"
+#include "mozilla/ipc/PTestShellCommandChild.h"
 #include "mozilla/ipc/XPCShellEnvironment.h"
 
 #include "nsAutoPtr.h"
 
 namespace mozilla {
 namespace ipc {
 
 class XPCShellEnvironment;
 
-class TestShellChild : public PTestShellProtocolChild
+class TestShellChild : public PTestShellChild
 {
 public:
   TestShellChild();
 
   nsresult
   RecvExecuteCommand(const nsString& aCommand);
 
-  PTestShellCommandProtocolChild*
+  PTestShellCommandChild*
   PTestShellCommandConstructor(const nsString& aCommand);
 
   nsresult
-  RecvPTestShellCommandConstructor(PTestShellCommandProtocolChild* aActor,
+  RecvPTestShellCommandConstructor(PTestShellCommandChild* aActor,
                                    const nsString& aCommand);
 
   nsresult
-  PTestShellCommandDestructor(PTestShellCommandProtocolChild* aCommand,
+  PTestShellCommandDestructor(PTestShellCommandChild* aCommand,
                               const nsString& aResponse);
 
   void SetXPCShell(XPCShellEnvironment* aXPCShell) {
     mXPCShell = aXPCShell;
   }
 
 private:
   nsAutoPtr<XPCShellEnvironment> mXPCShell;
--- a/ipc/testshell/TestShellParent.cpp
+++ b/ipc/testshell/TestShellParent.cpp
@@ -35,35 +35,35 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "TestShellParent.h"
 
 #include "nsAutoPtr.h"
 
 using mozilla::ipc::TestShellParent;
 using mozilla::ipc::TestShellCommandParent;
-using mozilla::ipc::PTestShellCommandProtocolParent;
+using mozilla::ipc::PTestShellCommandParent;
 
-PTestShellCommandProtocolParent*
+PTestShellCommandParent*
 TestShellParent::PTestShellCommandConstructor(const nsString& aCommand)
 {
   return new TestShellCommandParent();
 }
 
 nsresult
-TestShellParent::PTestShellCommandDestructor(PTestShellCommandProtocolParent* aActor,
+TestShellParent::PTestShellCommandDestructor(PTestShellCommandParent* aActor,
                                              const nsString& aResponse)
 {
   NS_ENSURE_ARG_POINTER(aActor);
   delete aActor;
   return NS_OK;
 }
 
 nsresult
-TestShellParent::RecvPTestShellCommandDestructor(PTestShellCommandProtocolParent* aActor,
+TestShellParent::RecvPTestShellCommandDestructor(PTestShellCommandParent* aActor,
                                                  const nsString& aResponse)
 {
   NS_ENSURE_ARG_POINTER(aActor);
 
   TestShellCommandParent* command =
     reinterpret_cast<TestShellCommandParent*>(aActor);
 
   JSBool ok = command->RunCallback(aResponse);
--- a/ipc/testshell/TestShellParent.h
+++ b/ipc/testshell/TestShellParent.h
@@ -32,54 +32,54 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef ipc_testshell_TestShellParent_h
 #define ipc_testshell_TestShellParent_h 1
 
-#include "mozilla/ipc/PTestShellProtocolParent.h"
-#include "mozilla/ipc/PTestShellCommandProtocolParent.h"
+#include "mozilla/ipc/PTestShellParent.h"
+#include "mozilla/ipc/PTestShellCommandParent.h"
 
 #include "jsapi.h"
 #include "nsAutoJSValHolder.h"
 #include "nsStringGlue.h"
 
 namespace mozilla {
 namespace ipc {
 
-class TestShellCommandParent : public PTestShellCommandProtocolParent
+class TestShellCommandParent : public PTestShellCommandParent
 {
 public:
   TestShellCommandParent() : mCx(NULL) { }
 
   JSBool SetCallback(JSContext* aCx,
                      jsval aCallback);
 
   JSBool RunCallback(const nsString& aResponse);
 
   void ReleaseCallback();
 
 private:
   JSContext* mCx;
   nsAutoJSValHolder mCallback;
 };
 
-class TestShellParent : public PTestShellProtocolParent
+class TestShellParent : public PTestShellParent
 {
 public:
-  PTestShellCommandProtocolParent*
+  PTestShellCommandParent*
   PTestShellCommandConstructor(const nsString& aCommand);
 
   nsresult
-  PTestShellCommandDestructor(PTestShellCommandProtocolParent* aActor,
+  PTestShellCommandDestructor(PTestShellCommandParent* aActor,
                               const nsString& aResponse);
 
   nsresult
-  RecvPTestShellCommandDestructor(PTestShellCommandProtocolParent* aActor,
+  RecvPTestShellCommandDestructor(PTestShellCommandParent* aActor,
                                   const nsString& aResponse);
 };
 
 } /* namespace ipc */
 } /* namespace mozilla */
 
 #endif /* ipc_testshell_TestShellParent_h */