Bug 885804: IPDL unit test changes r=benjamin
authorDavid Zbarsky <dzbarsky@gmail.com>
Mon, 08 Jul 2013 11:48:40 -0400
changeset 137652 bb4f5079e0096f7824dc0b34228e35fb03146b83
parent 137651 1c60785ea720406e0535bfc5cdb3e84c711798ba
child 137653 73a7afa43d5a1426e1a5697ab8a052f6ccc0624b
push id24930
push userryanvm@gmail.com
push dateMon, 08 Jul 2013 20:17:15 +0000
treeherdermozilla-central@d87b950c7a6f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbenjamin
bugs885804
milestone25.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 885804: IPDL unit test changes r=benjamin
ipc/ipdl/test/cxx/TestActorPunning.cpp
ipc/ipdl/test/cxx/TestActorPunning.h
ipc/ipdl/test/cxx/TestBadActor.cpp
ipc/ipdl/test/cxx/TestBadActor.h
ipc/ipdl/test/cxx/TestBridgeMain.cpp
ipc/ipdl/test/cxx/TestBridgeMain.h
ipc/ipdl/test/cxx/TestDataStructures.cpp
ipc/ipdl/test/cxx/TestDataStructures.h
ipc/ipdl/test/cxx/TestDesc.cpp
ipc/ipdl/test/cxx/TestDesc.h
ipc/ipdl/test/cxx/TestFailedCtor.cpp
ipc/ipdl/test/cxx/TestFailedCtor.h
ipc/ipdl/test/cxx/TestJSON.h
ipc/ipdl/test/cxx/TestManyChildAllocs.cpp
ipc/ipdl/test/cxx/TestManyChildAllocs.h
ipc/ipdl/test/cxx/TestMultiMgrs.h
ipc/ipdl/test/cxx/TestOpens.cpp
ipc/ipdl/test/cxx/TestOpens.h
ipc/ipdl/test/cxx/TestSelfManageRoot.h
ipc/ipdl/test/cxx/TestShutdown.h
--- a/ipc/ipdl/test/cxx/TestActorPunning.cpp
+++ b/ipc/ipdl/test/cxx/TestActorPunning.cpp
@@ -20,65 +20,65 @@ TestActorPunningParent::RecvPun(PTestAct
 {
     if (a->SendBad())
         fail("bad!");
     fail("shouldn't have received this message in the first place");
     return true;
 }
 
 PTestActorPunningPunnedParent*
-TestActorPunningParent::AllocPTestActorPunningPunned()
+TestActorPunningParent::AllocPTestActorPunningPunnedParent()
 {
     return new TestActorPunningPunnedParent();
 }
 
 bool
-TestActorPunningParent::DeallocPTestActorPunningPunned(PTestActorPunningPunnedParent* a)
+TestActorPunningParent::DeallocPTestActorPunningPunnedParent(PTestActorPunningPunnedParent* a)
 {
     delete a;
     return true;
 }
 
 PTestActorPunningSubParent*
-TestActorPunningParent::AllocPTestActorPunningSub()
+TestActorPunningParent::AllocPTestActorPunningSubParent()
 {
     return new TestActorPunningSubParent();
 }
 
 bool
-TestActorPunningParent::DeallocPTestActorPunningSub(PTestActorPunningSubParent* a)
+TestActorPunningParent::DeallocPTestActorPunningSubParent(PTestActorPunningSubParent* a)
 {
     delete a;
     return true;
 }
 
 //-----------------------------------------------------------------------------
 // child
 
 PTestActorPunningPunnedChild*
-TestActorPunningChild::AllocPTestActorPunningPunned()
+TestActorPunningChild::AllocPTestActorPunningPunnedChild()
 {
     return new TestActorPunningPunnedChild();
 }
 
 bool
-TestActorPunningChild::DeallocPTestActorPunningPunned(PTestActorPunningPunnedChild*)
+TestActorPunningChild::DeallocPTestActorPunningPunnedChild(PTestActorPunningPunnedChild*)
 {
     fail("should have died by now");
     return true;
 }
 
 PTestActorPunningSubChild*
-TestActorPunningChild::AllocPTestActorPunningSub()
+TestActorPunningChild::AllocPTestActorPunningSubChild()
 {
     return new TestActorPunningSubChild();
 }
 
 bool
-TestActorPunningChild::DeallocPTestActorPunningSub(PTestActorPunningSubChild*)
+TestActorPunningChild::DeallocPTestActorPunningSubChild(PTestActorPunningSubChild*)
 {
     fail("should have died by now");
     return true;
 }
 
 bool
 TestActorPunningChild::RecvStart()
 {
--- a/ipc/ipdl/test/cxx/TestActorPunning.h
+++ b/ipc/ipdl/test/cxx/TestActorPunning.h
@@ -19,21 +19,21 @@ class TestActorPunningParent :
 {
 public:
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return false; }
 
     void Main();
 
 protected:
-    PTestActorPunningPunnedParent* AllocPTestActorPunningPunned() MOZ_OVERRIDE;
-    bool DeallocPTestActorPunningPunned(PTestActorPunningPunnedParent* a) MOZ_OVERRIDE;
+    PTestActorPunningPunnedParent* AllocPTestActorPunningPunnedParent() MOZ_OVERRIDE;
+    bool DeallocPTestActorPunningPunnedParent(PTestActorPunningPunnedParent* a) MOZ_OVERRIDE;
 
-    PTestActorPunningSubParent* AllocPTestActorPunningSub() MOZ_OVERRIDE;
-    bool DeallocPTestActorPunningSub(PTestActorPunningSubParent* a) MOZ_OVERRIDE;
+    PTestActorPunningSubParent* AllocPTestActorPunningSubParent() MOZ_OVERRIDE;
+    bool DeallocPTestActorPunningSubParent(PTestActorPunningSubParent* a) MOZ_OVERRIDE;
 
     virtual bool RecvPun(PTestActorPunningSubParent* a, const Bad& bad) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown == why)
             fail("should have died from error!");  
         passed("ok");
@@ -61,21 +61,21 @@ public:
 class TestActorPunningChild :
     public PTestActorPunningChild
 {
 public:
     TestActorPunningChild() {}
     virtual ~TestActorPunningChild() {}
 
 protected:
-    PTestActorPunningPunnedChild* AllocPTestActorPunningPunned() MOZ_OVERRIDE;
-    bool DeallocPTestActorPunningPunned(PTestActorPunningPunnedChild* a) MOZ_OVERRIDE;
+    PTestActorPunningPunnedChild* AllocPTestActorPunningPunnedChild() MOZ_OVERRIDE;
+    bool DeallocPTestActorPunningPunnedChild(PTestActorPunningPunnedChild* a) MOZ_OVERRIDE;
 
-    PTestActorPunningSubChild* AllocPTestActorPunningSub() MOZ_OVERRIDE;
-    bool DeallocPTestActorPunningSub(PTestActorPunningSubChild* a) MOZ_OVERRIDE;
+    PTestActorPunningSubChild* AllocPTestActorPunningSubChild() MOZ_OVERRIDE;
+    bool DeallocPTestActorPunningSubChild(PTestActorPunningSubChild* a) MOZ_OVERRIDE;
 
     virtual bool RecvStart() MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         fail("should have been killed off!");
     }
 };
--- a/ipc/ipdl/test/cxx/TestBadActor.cpp
+++ b/ipc/ipdl/test/cxx/TestBadActor.cpp
@@ -15,30 +15,30 @@ TestBadActorParent::Main()
   PTestBadActorSubParent* child = SendPTestBadActorSubConstructor();
   if (!child)
     fail("Sending constructor");
 
   unused << child->Call__delete__(child);
 }
 
 PTestBadActorSubParent*
-TestBadActorParent::AllocPTestBadActorSub()
+TestBadActorParent::AllocPTestBadActorSubParent()
 {
   return new TestBadActorSubParent();
 }
 
 bool
 TestBadActorSubParent::RecvPing()
 {
   fail("Shouldn't have received ping.");
   return false;
 }
 
 PTestBadActorSubChild*
-TestBadActorChild::AllocPTestBadActorSub()
+TestBadActorChild::AllocPTestBadActorSubChild()
 {
   return new TestBadActorSubChild();
 }
 
 bool
 TestBadActorChild::RecvPTestBadActorSubConstructor(PTestBadActorSubChild* actor)
 {
   if (!actor->SendPing()) {
--- a/ipc/ipdl/test/cxx/TestBadActor.h
+++ b/ipc/ipdl/test/cxx/TestBadActor.h
@@ -29,20 +29,20 @@ protected:
   {
     if (AbnormalShutdown != why)
       fail("unexpected destruction");
     passed("ok");
     QuitParent();
   }
 
   virtual PTestBadActorSubParent*
-  AllocPTestBadActorSub();
+  AllocPTestBadActorSubParent();
 
   virtual bool
-  DeallocPTestBadActorSub(PTestBadActorSubParent* actor) {
+  DeallocPTestBadActorSubParent(PTestBadActorSubParent* actor) {
     delete actor;
     return true;
   }
 };
 
 class TestBadActorSubParent
   : public PTestBadActorSubParent
 {
@@ -58,20 +58,20 @@ class TestBadActorChild
   : public PTestBadActorChild
 {
 public:
   TestBadActorChild() { }
   virtual ~TestBadActorChild() { }
 
 protected:
   virtual PTestBadActorSubChild*
-  AllocPTestBadActorSub();
+  AllocPTestBadActorSubChild();
 
   virtual bool
-  DeallocPTestBadActorSub(PTestBadActorSubChild* actor)
+  DeallocPTestBadActorSubChild(PTestBadActorSubChild* actor)
   {
     delete actor;
     return true;
   }
 
   virtual bool
   RecvPTestBadActorSubConstructor(PTestBadActorSubChild* actor);
 };
--- a/ipc/ipdl/test/cxx/TestBridgeMain.cpp
+++ b/ipc/ipdl/test/cxx/TestBridgeMain.cpp
@@ -21,18 +21,18 @@ namespace _ipdltest {
 void
 TestBridgeMainParent::Main()
 {
     if (!SendStart())
         fail("sending Start");
 }
 
 PTestBridgeMainSubParent*
-TestBridgeMainParent::AllocPTestBridgeMainSub(Transport* transport,
-                                              ProcessId otherProcess)
+TestBridgeMainParent::AllocPTestBridgeMainSubParent(Transport* transport,
+                                                    ProcessId otherProcess)
 {
     ProcessHandle h;
     if (!base::OpenProcessHandle(otherProcess, &h)) {
         return nullptr;
     }
 
     nsAutoPtr<TestBridgeMainSubParent> a(new TestBridgeMainSubParent(transport));
     if (!a->Open(transport, h, XRE_GetIOMessageLoop(), AsyncChannel::Parent)) {
@@ -172,18 +172,18 @@ bool
 TestBridgeSubChild::RecvPing()
 {
     if (!SendBridgeEm())
         fail("sending BridgeEm");
     return true;
 }
 
 PTestBridgeMainSubChild*
-TestBridgeSubChild::AllocPTestBridgeMainSub(Transport* transport,
-                                            ProcessId otherProcess)
+TestBridgeSubChild::AllocPTestBridgeMainSubChild(Transport* transport,
+                                                 ProcessId otherProcess)
 {
     ProcessHandle h;
     if (!base::OpenProcessHandle(otherProcess, &h)) {
         return nullptr;
     }
 
     nsAutoPtr<TestBridgeMainSubChild> a(new TestBridgeMainSubChild(transport));
     if (!a->Open(transport, h, XRE_GetIOMessageLoop(), AsyncChannel::Child)) {
--- a/ipc/ipdl/test/cxx/TestBridgeMain.h
+++ b/ipc/ipdl/test/cxx/TestBridgeMain.h
@@ -27,18 +27,18 @@ public:
 
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return false; }
 
     void Main();
 
 protected:
     virtual PTestBridgeMainSubParent*
-    AllocPTestBridgeMainSub(Transport* transport,
-                            ProcessId otherProcess) MOZ_OVERRIDE;
+    AllocPTestBridgeMainSubParent(Transport* transport,
+                                  ProcessId otherProcess) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 };
 
 class TestBridgeMainSubParent :
     public PTestBridgeMainSubParent
 {
 public:
@@ -101,18 +101,18 @@ class TestBridgeSubChild :
 public:
     TestBridgeSubChild();
     virtual ~TestBridgeSubChild() {}
 
 protected:
     virtual bool RecvPing() MOZ_OVERRIDE;
 
     virtual PTestBridgeMainSubChild*
-    AllocPTestBridgeMainSub(Transport* transport,
-                            ProcessId otherProcess) MOZ_OVERRIDE;
+    AllocPTestBridgeMainSubChild(Transport* transport,
+                                 ProcessId otherProcess) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 };
 
 class TestBridgeMainSubChild :
     public PTestBridgeMainSubChild
 {
 public:
--- a/ipc/ipdl/test/cxx/TestDataStructures.cpp
+++ b/ipc/ipdl/test/cxx/TestDataStructures.cpp
@@ -53,17 +53,17 @@ TestDataStructuresParent::Main()
         if (!SendPTestDataStructuresSubConstructor(i))
             fail("can't alloc actor");
 
     if (!SendStart())
         fail("can't send Start()");
 }
 
 bool
-TestDataStructuresParent::DeallocPTestDataStructuresSub(PTestDataStructuresSubParent* actor)
+TestDataStructuresParent::DeallocPTestDataStructuresSubParent(PTestDataStructuresSubParent* actor)
 {
     test_assert(Cast(actor).mI == Cast(mKids[0]).mI,
                 "dtor sent to wrong actor");
     mKids.RemoveElementAt(0);
     delete actor;
     if (mKids.Length() > 0)
         return true;
 
--- a/ipc/ipdl/test/cxx/TestDataStructures.h
+++ b/ipc/ipdl/test/cxx/TestDataStructures.h
@@ -43,24 +43,24 @@ public:
     virtual ~TestDataStructuresParent();
 
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return true; }
 
     void Main();
 
 protected:
-    virtual PTestDataStructuresSubParent* AllocPTestDataStructuresSub(const int& i) MOZ_OVERRIDE
+    virtual PTestDataStructuresSubParent* AllocPTestDataStructuresSubParent(const int& i) MOZ_OVERRIDE
     {
         PTestDataStructuresSubParent* actor = new TestDataStructuresSub(i);
         mKids.AppendElement(actor);
         return actor;
     }
 
-    virtual bool DeallocPTestDataStructuresSub(PTestDataStructuresSubParent* actor) MOZ_OVERRIDE;
+    virtual bool DeallocPTestDataStructuresSubParent(PTestDataStructuresSubParent* actor) MOZ_OVERRIDE;
 
     virtual bool RecvTest1(
             const InfallibleTArray<int>& i1,
             InfallibleTArray<int>* o1) MOZ_OVERRIDE;
 
     virtual bool RecvTest2(
             const InfallibleTArray<PTestDataStructuresSubParent*>& i1,
             InfallibleTArray<PTestDataStructuresSubParent*>* o1) MOZ_OVERRIDE;
@@ -175,24 +175,24 @@ private:
 class TestDataStructuresChild :
     public PTestDataStructuresChild
 {
 public:
     TestDataStructuresChild();
     virtual ~TestDataStructuresChild();
 
 protected:
-    virtual PTestDataStructuresSubChild* AllocPTestDataStructuresSub(const int& i) MOZ_OVERRIDE
+    virtual PTestDataStructuresSubChild* AllocPTestDataStructuresSubChild(const int& i) MOZ_OVERRIDE
     {
         PTestDataStructuresSubChild* actor = new TestDataStructuresSub(i);
         mKids.AppendElement(actor);
         return actor;
     }
 
-    virtual bool DeallocPTestDataStructuresSub(PTestDataStructuresSubChild* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestDataStructuresSubChild(PTestDataStructuresSubChild* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
     virtual bool RecvStart() MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
--- a/ipc/ipdl/test/cxx/TestDesc.cpp
+++ b/ipc/ipdl/test/cxx/TestDesc.cpp
@@ -33,35 +33,35 @@ TestDescParent::RecvOk(PTestDescSubsubPa
 
     Close();
 
     return true;
 }
 
 
 PTestDescSubParent*
-TestDescParent::AllocPTestDescSub(PTestDescSubsubParent* dummy) {
+TestDescParent::AllocPTestDescSubParent(PTestDescSubsubParent* dummy) {
     if (dummy)
         fail("actor supposed to be null");
     return new TestDescSubParent();
 }
 bool
-TestDescParent::DeallocPTestDescSub(PTestDescSubParent* actor)
+TestDescParent::DeallocPTestDescSubParent(PTestDescSubParent* actor)
 {
     delete actor;
     return true;
 }
 
 PTestDescSubsubParent*
-TestDescSubParent::AllocPTestDescSubsub()
+TestDescSubParent::AllocPTestDescSubsubParent()
 {
     return new TestDescSubsubParent();
 }
 bool
-TestDescSubParent::DeallocPTestDescSubsub(PTestDescSubsubParent* actor)
+TestDescSubParent::DeallocPTestDescSubsubParent(PTestDescSubsubParent* actor)
 {
     delete actor;
     return true;
 }
 
 
 //-----------------------------------------------------------------------------
 // child
@@ -72,34 +72,34 @@ TestDescChild::RecvTest(PTestDescSubsubC
     if (!a)
         fail("didn't receive Subsub");
     if (!SendOk(a))
         fail("couldn't send Ok()");
     return true;
 }
 
 PTestDescSubChild*
-TestDescChild::AllocPTestDescSub(PTestDescSubsubChild* dummy) {
+TestDescChild::AllocPTestDescSubChild(PTestDescSubsubChild* dummy) {
     if (dummy)
         fail("actor supposed to be null");
     return new TestDescSubChild();
 }
 bool
-TestDescChild::DeallocPTestDescSub(PTestDescSubChild* actor)
+TestDescChild::DeallocPTestDescSubChild(PTestDescSubChild* actor)
 {
     delete actor;
     return true;
 }
 
 PTestDescSubsubChild*
-TestDescSubChild::AllocPTestDescSubsub()
+TestDescSubChild::AllocPTestDescSubsubChild()
 {
     return new TestDescSubsubChild();
 }
 bool
-TestDescSubChild::DeallocPTestDescSubsub(PTestDescSubsubChild* actor)
+TestDescSubChild::DeallocPTestDescSubsubChild(PTestDescSubsubChild* actor)
 {
     delete actor;
     return true;
 }
 
 } // namespace _ipdltest
 } // namespace mozilla
--- a/ipc/ipdl/test/cxx/TestDesc.h
+++ b/ipc/ipdl/test/cxx/TestDesc.h
@@ -28,40 +28,40 @@ public:
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return true; }
 
     void Main();
 
     virtual bool RecvOk(PTestDescSubsubParent* a) MOZ_OVERRIDE;
 
 protected:
-    virtual PTestDescSubParent* AllocPTestDescSub(PTestDescSubsubParent*) MOZ_OVERRIDE;
-    virtual bool DeallocPTestDescSub(PTestDescSubParent* actor) MOZ_OVERRIDE;
+    virtual PTestDescSubParent* AllocPTestDescSubParent(PTestDescSubsubParent*) MOZ_OVERRIDE;
+    virtual bool DeallocPTestDescSubParent(PTestDescSubParent* actor) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
-            fail("unexpected destruction!");  
+            fail("unexpected destruction!");
         passed("ok");
         QuitParent();
     }
 };
 
 
 class TestDescChild :
     public PTestDescChild
 {
 public:
     TestDescChild() { }
     virtual ~TestDescChild() { }
 
 protected:
-    virtual PTestDescSubChild* AllocPTestDescSub(PTestDescSubsubChild*) MOZ_OVERRIDE;
+    virtual PTestDescSubChild* AllocPTestDescSubChild(PTestDescSubsubChild*) MOZ_OVERRIDE;
 
-    virtual bool DeallocPTestDescSub(PTestDescSubChild* actor) MOZ_OVERRIDE;
+    virtual bool DeallocPTestDescSubChild(PTestDescSubChild* actor) MOZ_OVERRIDE;
 
     virtual bool RecvTest(PTestDescSubsubChild* a) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
             fail("unexpected destruction!");
         QuitChild();
@@ -75,32 +75,32 @@ protected:
 class TestDescSubParent :
     public PTestDescSubParent
 {
 public:
     TestDescSubParent() { }
     virtual ~TestDescSubParent() { }
 
 protected:
-    virtual PTestDescSubsubParent* AllocPTestDescSubsub() MOZ_OVERRIDE;
+    virtual PTestDescSubsubParent* AllocPTestDescSubsubParent() MOZ_OVERRIDE;
 
-    virtual bool DeallocPTestDescSubsub(PTestDescSubsubParent* actor) MOZ_OVERRIDE;
+    virtual bool DeallocPTestDescSubsubParent(PTestDescSubsubParent* actor) MOZ_OVERRIDE;
 };
 
 
 class TestDescSubChild :
     public PTestDescSubChild
 {
 public:
     TestDescSubChild() { }
     virtual ~TestDescSubChild() { }
 
 protected:
-    virtual PTestDescSubsubChild* AllocPTestDescSubsub() MOZ_OVERRIDE;
-    virtual bool DeallocPTestDescSubsub(PTestDescSubsubChild* actor) MOZ_OVERRIDE;
+    virtual PTestDescSubsubChild* AllocPTestDescSubsubChild() MOZ_OVERRIDE;
+    virtual bool DeallocPTestDescSubsubChild(PTestDescSubsubChild* actor) MOZ_OVERRIDE;
 };
 
 
 //-----------------------------------------------------------------------------
 // Grand-descendent
 //
 class TestDescSubsubParent :
     public PTestDescSubsubParent
--- a/ipc/ipdl/test/cxx/TestFailedCtor.cpp
+++ b/ipc/ipdl/test/cxx/TestFailedCtor.cpp
@@ -13,44 +13,44 @@ TestFailedCtorParent::Main()
     PTestFailedCtorSubParent* p = CallPTestFailedCtorSubConstructor();
     if (p)
         fail("expected ctor to fail");
 
     Close();
 }
 
 PTestFailedCtorSubParent*
-TestFailedCtorParent::AllocPTestFailedCtorSub()
+TestFailedCtorParent::AllocPTestFailedCtorSubParent()
 {
     return new TestFailedCtorSubParent();
 }
 bool
-TestFailedCtorParent::DeallocPTestFailedCtorSub(PTestFailedCtorSubParent* actor)
+TestFailedCtorParent::DeallocPTestFailedCtorSubParent(PTestFailedCtorSubParent* actor)
 {
     delete actor;
     return true;
 }
 
 PTestFailedCtorSubsubParent*
-TestFailedCtorSubParent::AllocPTestFailedCtorSubsub()
+TestFailedCtorSubParent::AllocPTestFailedCtorSubsubParent()
 {
     TestFailedCtorSubsub* a = new TestFailedCtorSubsub();
     if (!mOne) {
         return mOne = a;
     } else if (!mTwo) {
         return mTwo = a;
     } else if (!mThree) {
         return mThree = a;
     } else {
         fail("unexpected Alloc()");
         return nullptr;
     }
 }
 bool
-TestFailedCtorSubParent::DeallocPTestFailedCtorSubsub(PTestFailedCtorSubsubParent* actor)
+TestFailedCtorSubParent::DeallocPTestFailedCtorSubsubParent(PTestFailedCtorSubsubParent* actor)
 {
     static_cast<TestFailedCtorSubsub*>(actor)->mDealloced = true;
     return true;
 }
 
 void
 TestFailedCtorSubParent::ActorDestroy(ActorDestroyReason why)
 {
@@ -75,17 +75,17 @@ TestFailedCtorSubParent::~TestFailedCtor
     delete mThree;
 }
 
 
 //-----------------------------------------------------------------------------
 // child
 
 PTestFailedCtorSubChild*
-TestFailedCtorChild::AllocPTestFailedCtorSub()
+TestFailedCtorChild::AllocPTestFailedCtorSubChild()
 {
     return new TestFailedCtorSubChild();
 }
 
 bool
 TestFailedCtorChild::AnswerPTestFailedCtorSubConstructor(PTestFailedCtorSubChild* actor)
 {
     PTestFailedCtorSubsubChild* c1 = actor->SendPTestFailedCtorSubsubConstructor();
@@ -96,37 +96,37 @@ TestFailedCtorChild::AnswerPTestFailedCt
         !actor->SendSync())
         fail("setting up test");
 
     // This causes our process to die
     return false;
 }
 
 bool
-TestFailedCtorChild::DeallocPTestFailedCtorSub(PTestFailedCtorSubChild* actor)
+TestFailedCtorChild::DeallocPTestFailedCtorSubChild(PTestFailedCtorSubChild* actor)
 {
     delete actor;
     return true;
 }
 
 void
 TestFailedCtorChild::ProcessingError(Result what)
 {
     if (OtherProcess() != 0) // thread-mode
         _exit(0);
 }
 
 PTestFailedCtorSubsubChild*
-TestFailedCtorSubChild::AllocPTestFailedCtorSubsub()
+TestFailedCtorSubChild::AllocPTestFailedCtorSubsubChild()
 {
     return new TestFailedCtorSubsub();
 }
 
 bool
-TestFailedCtorSubChild::DeallocPTestFailedCtorSubsub(PTestFailedCtorSubsubChild* actor)
+TestFailedCtorSubChild::DeallocPTestFailedCtorSubsubChild(PTestFailedCtorSubsubChild* actor)
 {
     delete actor;
     return true;
 }
 
 void
 TestFailedCtorSubChild::ActorDestroy(ActorDestroyReason why)
 {
--- a/ipc/ipdl/test/cxx/TestFailedCtor.h
+++ b/ipc/ipdl/test/cxx/TestFailedCtor.h
@@ -30,18 +30,18 @@ public:
     // FIXME/bug 703322 Disabled because child calls exit() to end
     //                  test, not clear how to handle failed ctor in
     //                  threaded mode.
     static bool RunTestInThreads() { return false; }
 
     void Main();
 
 protected:
-    virtual PTestFailedCtorSubParent* AllocPTestFailedCtorSub() MOZ_OVERRIDE;
-    virtual bool DeallocPTestFailedCtorSub(PTestFailedCtorSubParent* actor) MOZ_OVERRIDE;
+    virtual PTestFailedCtorSubParent* AllocPTestFailedCtorSubParent() MOZ_OVERRIDE;
+    virtual bool DeallocPTestFailedCtorSubParent(PTestFailedCtorSubParent* actor) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (AbnormalShutdown != why)
             fail("unexpected destruction!");  
         passed("ok");
         QuitParent();
     }
@@ -51,21 +51,21 @@ protected:
 class TestFailedCtorChild :
     public PTestFailedCtorChild
 {
 public:
     TestFailedCtorChild() { }
     virtual ~TestFailedCtorChild() { }
 
 protected:
-    virtual PTestFailedCtorSubChild* AllocPTestFailedCtorSub() MOZ_OVERRIDE;
+    virtual PTestFailedCtorSubChild* AllocPTestFailedCtorSubChild() MOZ_OVERRIDE;
 
     virtual bool AnswerPTestFailedCtorSubConstructor(PTestFailedCtorSubChild* actor) MOZ_OVERRIDE;
 
-    virtual bool DeallocPTestFailedCtorSub(PTestFailedCtorSubChild* actor) MOZ_OVERRIDE;
+    virtual bool DeallocPTestFailedCtorSubChild(PTestFailedCtorSubChild* actor) MOZ_OVERRIDE;
 
     virtual void ProcessingError(Result what) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         fail("should have _exit()ed");
     }
 };
@@ -79,19 +79,19 @@ class TestFailedCtorSubsub;
 class TestFailedCtorSubParent :
     public PTestFailedCtorSubParent
 {
 public:
     TestFailedCtorSubParent() : mOne(NULL), mTwo(NULL), mThree(NULL) { }
     virtual ~TestFailedCtorSubParent();
 
 protected:
-    virtual PTestFailedCtorSubsubParent* AllocPTestFailedCtorSubsub() MOZ_OVERRIDE;
+    virtual PTestFailedCtorSubsubParent* AllocPTestFailedCtorSubsubParent() MOZ_OVERRIDE;
 
-    virtual bool DeallocPTestFailedCtorSubsub(PTestFailedCtorSubsubParent* actor) MOZ_OVERRIDE;
+    virtual bool DeallocPTestFailedCtorSubsubParent(PTestFailedCtorSubsubParent* actor) MOZ_OVERRIDE;
     virtual bool RecvSync() MOZ_OVERRIDE { return true; }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 
     TestFailedCtorSubsub* mOne;
     TestFailedCtorSubsub* mTwo;
     TestFailedCtorSubsub* mThree;
 };
@@ -100,18 +100,18 @@ protected:
 class TestFailedCtorSubChild :
     public PTestFailedCtorSubChild
 {
 public:
     TestFailedCtorSubChild() { }
     virtual ~TestFailedCtorSubChild() { }
 
 protected:
-    virtual PTestFailedCtorSubsubChild* AllocPTestFailedCtorSubsub() MOZ_OVERRIDE;
-    virtual bool DeallocPTestFailedCtorSubsub(PTestFailedCtorSubsubChild* actor) MOZ_OVERRIDE;
+    virtual PTestFailedCtorSubsubChild* AllocPTestFailedCtorSubsubChild() MOZ_OVERRIDE;
+    virtual bool DeallocPTestFailedCtorSubsubChild(PTestFailedCtorSubsubChild* actor) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 };
 
 
 //-----------------------------------------------------------------------------
 // Grand-descendent
 //
--- a/ipc/ipdl/test/cxx/TestJSON.h
+++ b/ipc/ipdl/test/cxx/TestJSON.h
@@ -32,22 +32,22 @@ public:
 
     void Main();
 
 protected:
     virtual bool
     RecvTest(const JSONVariant& i,
              JSONVariant* o) MOZ_OVERRIDE;
 
-    virtual PTestHandleParent* AllocPTestHandle() MOZ_OVERRIDE
+    virtual PTestHandleParent* AllocPTestHandleParent() MOZ_OVERRIDE
     {
         return mKid = new TestHandleParent();
     }
 
-    virtual bool DeallocPTestHandle(PTestHandleParent* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestHandleParent(PTestHandleParent* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
@@ -74,22 +74,22 @@ class TestJSONChild :
 public:
     TestJSONChild() { }
     virtual ~TestJSONChild() { }
 
 protected:
     virtual bool
     RecvStart() MOZ_OVERRIDE;
 
-    virtual PTestHandleChild* AllocPTestHandle() MOZ_OVERRIDE
+    virtual PTestHandleChild* AllocPTestHandleChild() MOZ_OVERRIDE
     {
         return mKid = new TestHandleChild();
     }
 
-    virtual bool DeallocPTestHandle(PTestHandleChild* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestHandleChild(PTestHandleChild* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
--- a/ipc/ipdl/test/cxx/TestManyChildAllocs.cpp
+++ b/ipc/ipdl/test/cxx/TestManyChildAllocs.cpp
@@ -33,24 +33,24 @@ TestManyChildAllocsParent::RecvDone()
     // explicitly *not* cleaning up, so we can sanity-check IPDL's
     // auto-shutdown/cleanup handling
     Close();
 
     return true;
 }
 
 bool
-TestManyChildAllocsParent::DeallocPTestManyChildAllocsSub(
+TestManyChildAllocsParent::DeallocPTestManyChildAllocsSubParent(
     PTestManyChildAllocsSubParent* __a)
 {
     delete __a; return true;
 }
 
 PTestManyChildAllocsSubParent*
-TestManyChildAllocsParent::AllocPTestManyChildAllocsSub()
+TestManyChildAllocsParent::AllocPTestManyChildAllocsSubParent()
 {
     return new TestManyChildAllocsSubParent();
 }
 
 
 // child code
 
 TestManyChildAllocsChild::TestManyChildAllocsChild()
@@ -82,23 +82,23 @@ bool TestManyChildAllocsChild::RecvGo()
 
     if (!SendDone())
         fail("can't send Done()");
 
     return true;
 }
 
 bool
-TestManyChildAllocsChild::DeallocPTestManyChildAllocsSub(
+TestManyChildAllocsChild::DeallocPTestManyChildAllocsSubChild(
     PTestManyChildAllocsSubChild* __a)
 {
     delete __a; return true;
 }
 
 PTestManyChildAllocsSubChild*
-TestManyChildAllocsChild::AllocPTestManyChildAllocsSub()
+TestManyChildAllocsChild::AllocPTestManyChildAllocsSubChild()
 {
     return new TestManyChildAllocsSubChild();
 }
 
 
 } // namespace _ipdltest
 } // namespace mozilla
--- a/ipc/ipdl/test/cxx/TestManyChildAllocs.h
+++ b/ipc/ipdl/test/cxx/TestManyChildAllocs.h
@@ -23,18 +23,18 @@ public:
 
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return true; }
 
     void Main();
 
 protected:
     virtual bool RecvDone() MOZ_OVERRIDE;
-    virtual bool DeallocPTestManyChildAllocsSub(PTestManyChildAllocsSubParent* __a) MOZ_OVERRIDE;
-    virtual PTestManyChildAllocsSubParent* AllocPTestManyChildAllocsSub() MOZ_OVERRIDE;
+    virtual bool DeallocPTestManyChildAllocsSubParent(PTestManyChildAllocsSubParent* __a) MOZ_OVERRIDE;
+    virtual PTestManyChildAllocsSubParent* AllocPTestManyChildAllocsSubParent() MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
             fail("unexpected destruction!");
         passed("ok");
         QuitParent();
     }
@@ -45,18 +45,18 @@ class TestManyChildAllocsChild :
     public PTestManyChildAllocsChild
 {
 public:
     TestManyChildAllocsChild();
     virtual ~TestManyChildAllocsChild();
 
 protected:
     virtual bool RecvGo() MOZ_OVERRIDE;
-    virtual bool DeallocPTestManyChildAllocsSub(PTestManyChildAllocsSubChild* __a) MOZ_OVERRIDE;
-    virtual PTestManyChildAllocsSubChild* AllocPTestManyChildAllocsSub() MOZ_OVERRIDE;
+    virtual bool DeallocPTestManyChildAllocsSubChild(PTestManyChildAllocsSubChild* __a) MOZ_OVERRIDE;
+    virtual PTestManyChildAllocsSubChild* AllocPTestManyChildAllocsSubChild() MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
             fail("unexpected destruction!");
         QuitChild();
     }
 };
--- a/ipc/ipdl/test/cxx/TestMultiMgrs.h
+++ b/ipc/ipdl/test/cxx/TestMultiMgrs.h
@@ -35,22 +35,22 @@ public:
     virtual ~TestMultiMgrsLeftParent() { }
 
     bool HasChild(TestMultiMgrsBottomParent* c)
     {
         return ManagedPTestMultiMgrsBottomParent().Contains(c);
     }
 
 protected:
-    virtual PTestMultiMgrsBottomParent* AllocPTestMultiMgrsBottom() MOZ_OVERRIDE
+    virtual PTestMultiMgrsBottomParent* AllocPTestMultiMgrsBottomParent() MOZ_OVERRIDE
     {
         return new TestMultiMgrsBottomParent();
     }
 
-    virtual bool DeallocPTestMultiMgrsBottom(PTestMultiMgrsBottomParent* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestMultiMgrsBottomParent(PTestMultiMgrsBottomParent* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 };
 
 class TestMultiMgrsRightParent :
     public PTestMultiMgrsRightParent
@@ -60,22 +60,22 @@ public:
     virtual ~TestMultiMgrsRightParent() { }
 
     bool HasChild(TestMultiMgrsBottomParent* c)
     {
         return ManagedPTestMultiMgrsBottomParent().Contains(c);
     }
 
 protected:
-    virtual PTestMultiMgrsBottomParent* AllocPTestMultiMgrsBottom() MOZ_OVERRIDE
+    virtual PTestMultiMgrsBottomParent* AllocPTestMultiMgrsBottomParent() MOZ_OVERRIDE
     {
         return new TestMultiMgrsBottomParent();
     }
 
-    virtual bool DeallocPTestMultiMgrsBottom(PTestMultiMgrsBottomParent* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestMultiMgrsBottomParent(PTestMultiMgrsBottomParent* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 };
 
 class TestMultiMgrsParent :
     public PTestMultiMgrsParent
@@ -87,33 +87,33 @@ public:
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return true; }
 
     void Main();
 
 protected:
     virtual bool RecvOK() MOZ_OVERRIDE;
 
-    virtual PTestMultiMgrsLeftParent* AllocPTestMultiMgrsLeft() MOZ_OVERRIDE
+    virtual PTestMultiMgrsLeftParent* AllocPTestMultiMgrsLeftParent() MOZ_OVERRIDE
     {
         return new TestMultiMgrsLeftParent();
     }
 
-    virtual bool DeallocPTestMultiMgrsLeft(PTestMultiMgrsLeftParent* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestMultiMgrsLeftParent(PTestMultiMgrsLeftParent* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
-    virtual PTestMultiMgrsRightParent* AllocPTestMultiMgrsRight() MOZ_OVERRIDE
+    virtual PTestMultiMgrsRightParent* AllocPTestMultiMgrsRightParent() MOZ_OVERRIDE
     {
         return new TestMultiMgrsRightParent();
     }
 
-    virtual bool DeallocPTestMultiMgrsRight(PTestMultiMgrsRightParent* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestMultiMgrsRightParent(PTestMultiMgrsRightParent* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
@@ -145,22 +145,22 @@ public:
     bool HasChild(PTestMultiMgrsBottomChild* c)
     {
         return ManagedPTestMultiMgrsBottomChild().Contains(c);
     }
 
 protected:
     virtual bool RecvPTestMultiMgrsBottomConstructor(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE;
 
-    virtual PTestMultiMgrsBottomChild* AllocPTestMultiMgrsBottom() MOZ_OVERRIDE
+    virtual PTestMultiMgrsBottomChild* AllocPTestMultiMgrsBottomChild() MOZ_OVERRIDE
     {
         return new TestMultiMgrsBottomChild();
     }
 
-    virtual bool DeallocPTestMultiMgrsBottom(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestMultiMgrsBottomChild(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 };
 
 class TestMultiMgrsRightChild :
     public PTestMultiMgrsRightChild
@@ -172,22 +172,22 @@ public:
     bool HasChild(PTestMultiMgrsBottomChild* c)
     {
         return ManagedPTestMultiMgrsBottomChild().Contains(c);
     }
 
 protected:
     virtual bool RecvPTestMultiMgrsBottomConstructor(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE;
 
-    virtual PTestMultiMgrsBottomChild* AllocPTestMultiMgrsBottom() MOZ_OVERRIDE
+    virtual PTestMultiMgrsBottomChild* AllocPTestMultiMgrsBottomChild() MOZ_OVERRIDE
     {
         return new TestMultiMgrsBottomChild();
     }
 
-    virtual bool DeallocPTestMultiMgrsBottom(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestMultiMgrsBottomChild(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 };
 
 class TestMultiMgrsChild :
     public PTestMultiMgrsChild
@@ -199,33 +199,33 @@ public:
     void Main();
 
     PTestMultiMgrsBottomChild* mBottomL;
     PTestMultiMgrsBottomChild* mBottomR;
 
 protected:
     virtual bool RecvCheck() MOZ_OVERRIDE;
 
-    virtual PTestMultiMgrsLeftChild* AllocPTestMultiMgrsLeft() MOZ_OVERRIDE
+    virtual PTestMultiMgrsLeftChild* AllocPTestMultiMgrsLeftChild() MOZ_OVERRIDE
     {
         return new TestMultiMgrsLeftChild();
     }
 
-    virtual bool DeallocPTestMultiMgrsLeft(PTestMultiMgrsLeftChild* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestMultiMgrsLeftChild(PTestMultiMgrsLeftChild* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
-    virtual PTestMultiMgrsRightChild* AllocPTestMultiMgrsRight() MOZ_OVERRIDE
+    virtual PTestMultiMgrsRightChild* AllocPTestMultiMgrsRightChild() MOZ_OVERRIDE
     {
         return new TestMultiMgrsRightChild();
     }
 
-    virtual bool DeallocPTestMultiMgrsRight(PTestMultiMgrsRightChild* actor) MOZ_OVERRIDE
+    virtual bool DeallocPTestMultiMgrsRightChild(PTestMultiMgrsRightChild* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
--- a/ipc/ipdl/test/cxx/TestOpens.cpp
+++ b/ipc/ipdl/test/cxx/TestOpens.cpp
@@ -60,18 +60,18 @@ OpenParent(TestOpensOpenedParent* aParen
     // Messages will be delivered to this thread's message loop
     // instead of the main thread's.
     if (!aParent->Open(aTransport, aOtherProcess,
                        XRE_GetIOMessageLoop(), AsyncChannel::Parent))
         fail("opening Parent");
 }
 
 PTestOpensOpenedParent*
-TestOpensParent::AllocPTestOpensOpened(Transport* transport,
-                                       ProcessId otherProcess)
+TestOpensParent::AllocPTestOpensOpenedParent(Transport* transport,
+                                             ProcessId otherProcess)
 {
     gMainThread = MessageLoop::current();
 
     ProcessHandle h;
     if (!base::OpenProcessHandle(otherProcess, &h)) {
         return nullptr;
     }
 
@@ -173,18 +173,18 @@ OpenChild(TestOpensOpenedChild* aChild,
         fail("opening Child");
 
     // Kick off the unit tests
     if (!aChild->SendHello())
         fail("sending Hello");
 }
 
 PTestOpensOpenedChild*
-TestOpensChild::AllocPTestOpensOpened(Transport* transport,
-                                      ProcessId otherProcess)
+TestOpensChild::AllocPTestOpensOpenedChild(Transport* transport,
+                                           ProcessId otherProcess)
 {
     gMainThread = MessageLoop::current();
 
     ProcessHandle h;
     if (!base::OpenProcessHandle(otherProcess, &h)) {
         return nullptr;
     }
 
--- a/ipc/ipdl/test/cxx/TestOpens.h
+++ b/ipc/ipdl/test/cxx/TestOpens.h
@@ -23,17 +23,17 @@ public:
 
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return false; }
 
     void Main();
 
 protected:
     virtual PTestOpensOpenedParent*
-    AllocPTestOpensOpened(Transport* transport, ProcessId otherProcess) MOZ_OVERRIDE;
+    AllocPTestOpensOpenedParent(Transport* transport, ProcessId otherProcess) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 };
 
 } // namespace _ipdltest
 
 namespace _ipdltest2 {
 
@@ -66,17 +66,17 @@ class TestOpensChild : public PTestOpens
 public:
     TestOpensChild();
     virtual ~TestOpensChild() {}
 
 protected:
     virtual bool RecvStart() MOZ_OVERRIDE;
 
     virtual PTestOpensOpenedChild*
-    AllocPTestOpensOpened(Transport* transport, ProcessId otherProcess) MOZ_OVERRIDE;
+    AllocPTestOpensOpenedChild(Transport* transport, ProcessId otherProcess) MOZ_OVERRIDE;
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 };
 
 } // namespace _ipdltest
 
 namespace _ipdltest2 {
 
--- a/ipc/ipdl/test/cxx/TestSelfManageRoot.h
+++ b/ipc/ipdl/test/cxx/TestSelfManageRoot.h
@@ -24,21 +24,21 @@ public:
     }
     virtual ~TestSelfManageParent() {
         MOZ_COUNT_DTOR(TestSelfManageParent);
     }
 
     ActorDestroyReason mWhy;
 
 protected:    
-    virtual PTestSelfManageParent* AllocPTestSelfManage() MOZ_OVERRIDE {
+    virtual PTestSelfManageParent* AllocPTestSelfManageParent() MOZ_OVERRIDE {
         return new TestSelfManageParent();
     }
 
-    virtual bool DeallocPTestSelfManage(PTestSelfManageParent* a) MOZ_OVERRIDE {
+    virtual bool DeallocPTestSelfManageParent(PTestSelfManageParent* a) MOZ_OVERRIDE {
         return true;
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE {
         mWhy = why;
     }
 };
 
@@ -54,21 +54,21 @@ public:
     }
 
     static bool RunTestInProcesses() { return true; }
     static bool RunTestInThreads() { return true; }
 
     void Main();
 
 protected:    
-    virtual PTestSelfManageParent* AllocPTestSelfManage() MOZ_OVERRIDE {
+    virtual PTestSelfManageParent* AllocPTestSelfManageParent() MOZ_OVERRIDE {
         return new TestSelfManageParent();
     }
 
-    virtual bool DeallocPTestSelfManage(PTestSelfManageParent* a) MOZ_OVERRIDE {
+    virtual bool DeallocPTestSelfManageParent(PTestSelfManageParent* a) MOZ_OVERRIDE {
         return true;
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
             fail("unexpected destruction!");  
         passed("ok");
@@ -86,21 +86,21 @@ public:
     TestSelfManageChild() {
         MOZ_COUNT_CTOR(TestSelfManageChild);
     }
     virtual ~TestSelfManageChild() {
         MOZ_COUNT_DTOR(TestSelfManageChild);
     }
 
 protected:    
-    virtual PTestSelfManageChild* AllocPTestSelfManage() MOZ_OVERRIDE {
+    virtual PTestSelfManageChild* AllocPTestSelfManageChild() MOZ_OVERRIDE {
         return new TestSelfManageChild();
     }
 
-    virtual bool DeallocPTestSelfManage(PTestSelfManageChild* a) MOZ_OVERRIDE {
+    virtual bool DeallocPTestSelfManageChild(PTestSelfManageChild* a) MOZ_OVERRIDE {
         delete a;
         return true;
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE { }
 };
 
 class TestSelfManageRootChild :
@@ -112,21 +112,21 @@ public:
     }
     virtual ~TestSelfManageRootChild() {
         MOZ_COUNT_DTOR(TestSelfManageRootChild);
     }
 
     void Main();
 
 protected:    
-    virtual PTestSelfManageChild* AllocPTestSelfManage() MOZ_OVERRIDE {
+    virtual PTestSelfManageChild* AllocPTestSelfManageChild() MOZ_OVERRIDE {
         return new TestSelfManageChild();
     }
 
-    virtual bool DeallocPTestSelfManage(PTestSelfManageChild* a) MOZ_OVERRIDE {
+    virtual bool DeallocPTestSelfManageChild(PTestSelfManageChild* a) MOZ_OVERRIDE {
         delete a;
         return true;
     }
 
     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE
     {
         if (NormalShutdown != why)
             fail("unexpected destruction!");  
--- a/ipc/ipdl/test/cxx/TestShutdown.h
+++ b/ipc/ipdl/test/cxx/TestShutdown.h
@@ -59,23 +59,23 @@ public:
 protected:
     virtual bool
     AnswerStackFrame() MOZ_OVERRIDE
     {
         return CallStackFrame();
     }
 
     virtual PTestShutdownSubsubParent*
-    AllocPTestShutdownSubsub(const bool& expectParentDelete) MOZ_OVERRIDE
+    AllocPTestShutdownSubsubParent(const bool& expectParentDelete) MOZ_OVERRIDE
     {
         return new TestShutdownSubsubParent(expectParentDelete);
     }
 
     virtual bool
-    DeallocPTestShutdownSubsub(PTestShutdownSubsubParent* actor) MOZ_OVERRIDE
+    DeallocPTestShutdownSubsubParent(PTestShutdownSubsubParent* actor) MOZ_OVERRIDE
     {
         delete actor;
         ++mDeletedCount;
         return true;
     }
 
     virtual void
     ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
@@ -102,23 +102,23 @@ public:
     static bool RunTestInThreads() { return false; }
 
     void Main();
 
 protected:
     virtual bool RecvSync() MOZ_OVERRIDE { return true; }
 
     virtual PTestShutdownSubParent*
-    AllocPTestShutdownSub(const bool& expectCrash) MOZ_OVERRIDE
+    AllocPTestShutdownSubParent(const bool& expectCrash) MOZ_OVERRIDE
     {
         return new TestShutdownSubParent(expectCrash);
     }
 
     virtual bool
-    DeallocPTestShutdownSub(PTestShutdownSubParent* actor) MOZ_OVERRIDE
+    DeallocPTestShutdownSubParent(PTestShutdownSubParent* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
     virtual void
     ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 };
@@ -159,23 +159,23 @@ public:
     virtual ~TestShutdownSubChild()
     {
     }
 
 protected:
     virtual bool AnswerStackFrame() MOZ_OVERRIDE;
 
     virtual PTestShutdownSubsubChild*
-    AllocPTestShutdownSubsub(const bool& expectParentDelete) MOZ_OVERRIDE
+    AllocPTestShutdownSubsubChild(const bool& expectParentDelete) MOZ_OVERRIDE
     {
         return new TestShutdownSubsubChild(expectParentDelete);
     }
 
     virtual bool
-    DeallocPTestShutdownSubsub(PTestShutdownSubsubChild* actor) MOZ_OVERRIDE
+    DeallocPTestShutdownSubsubChild(PTestShutdownSubsubChild* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
     virtual void
     ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 
@@ -195,24 +195,24 @@ public:
     {
     }
 
 protected:
     virtual bool
     RecvStart();
 
     virtual PTestShutdownSubChild*
-    AllocPTestShutdownSub(
+    AllocPTestShutdownSubChild(
         const bool& expectCrash) MOZ_OVERRIDE
     {
         return new TestShutdownSubChild(expectCrash);
     }
 
     virtual bool
-    DeallocPTestShutdownSub(PTestShutdownSubChild* actor) MOZ_OVERRIDE
+    DeallocPTestShutdownSubChild(PTestShutdownSubChild* actor) MOZ_OVERRIDE
     {
         delete actor;
         return true;
     }
 
     virtual void
     ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 };