--- a/ipc/testshell/TestShellChild.cpp
+++ b/ipc/testshell/TestShellChild.cpp
@@ -20,23 +20,23 @@ TestShellChild::RecvExecuteCommand(const
     NS_WARNING("Commands sent after quit command issued!");
     return false;
   }
 
   return mXPCShell->EvaluateString(aCommand);
 }
 
 PTestShellCommandChild*
-TestShellChild::AllocPTestShellCommand(const nsString& aCommand)
+TestShellChild::AllocPTestShellCommandChild(const nsString& aCommand)
 {
   return new PTestShellCommandChild();
 }
 
 bool
-TestShellChild::DeallocPTestShellCommand(PTestShellCommandChild* aCommand)
+TestShellChild::DeallocPTestShellCommandChild(PTestShellCommandChild* aCommand)
 {
   delete aCommand;
   return true;
 }
 
 bool
 TestShellChild::RecvPTestShellCommandConstructor(PTestShellCommandChild* aActor,
                                                  const nsString& aCommand)

--- a/ipc/testshell/TestShellChild.h
+++ b/ipc/testshell/TestShellChild.h
@@ -21,24 +21,24 @@ class TestShellChild : public PTestShell
 {
 public:
   TestShellChild();
 
   bool
   RecvExecuteCommand(const nsString& aCommand);
 
   PTestShellCommandChild*
-  AllocPTestShellCommand(const nsString& aCommand);
+  AllocPTestShellCommandChild(const nsString& aCommand);
 
   bool
   RecvPTestShellCommandConstructor(PTestShellCommandChild* aActor,
                                    const nsString& aCommand);
 
   bool
-  DeallocPTestShellCommand(PTestShellCommandChild* aCommand);
+  DeallocPTestShellCommandChild(PTestShellCommandChild* aCommand);
 
 private:
   nsAutoPtr<XPCShellEnvironment> mXPCShell;
 };
 
 } /* namespace ipc */
 } /* namespace mozilla */
 

--- a/ipc/testshell/TestShellParent.cpp
+++ b/ipc/testshell/TestShellParent.cpp
@@ -13,23 +13,23 @@
 
 using namespace mozilla;
 using mozilla::ipc::TestShellParent;
 using mozilla::ipc::TestShellCommandParent;
 using mozilla::ipc::PTestShellCommandParent;
 using mozilla::dom::ContentParent;
 
 PTestShellCommandParent*
-TestShellParent::AllocPTestShellCommand(const nsString& aCommand)
+TestShellParent::AllocPTestShellCommandParent(const nsString& aCommand)
 {
   return new TestShellCommandParent();
 }
 
 bool
-TestShellParent::DeallocPTestShellCommand(PTestShellCommandParent* aActor)
+TestShellParent::DeallocPTestShellCommandParent(PTestShellCommandParent* aActor)
 {
   delete aActor;
   return true;
 }
 
 bool
 TestShellParent::CommandDone(TestShellCommandParent* command,
                              const nsString& aResponse)
@@ -69,17 +69,17 @@ TestShellCommandParent::RunCallback(cons
 
   JSString* str = JS_NewUCStringCopyN(mCx, aResponse.get(), aResponse.Length());
   NS_ENSURE_TRUE(str, JS_FALSE);
 
   JS::Rooted<JS::Value> strVal(mCx, JS::StringValue(str));
 
   JS::Rooted<JS::Value> rval(mCx);
   JSBool ok = JS_CallFunctionValue(mCx, global, mCallback, 1, strVal.address(),
-				   rval.address());
+                                   rval.address());
   NS_ENSURE_TRUE(ok, JS_FALSE);
 
   return JS_TRUE;
 }
 
 void
 TestShellCommandParent::ReleaseCallback()
 {

--- a/ipc/testshell/TestShellParent.h
+++ b/ipc/testshell/TestShellParent.h
@@ -23,20 +23,20 @@ namespace mozilla {
 namespace ipc {
 
 class TestShellCommandParent;
 
 class TestShellParent : public PTestShellParent
 {
 public:
   PTestShellCommandParent*
-  AllocPTestShellCommand(const nsString& aCommand);
+  AllocPTestShellCommandParent(const nsString& aCommand);
 
   bool
-  DeallocPTestShellCommand(PTestShellCommandParent* aActor);
+  DeallocPTestShellCommandParent(PTestShellCommandParent* aActor);
 
   bool
   CommandDone(TestShellCommandParent* aActor, const nsString& aResponse);
 };
 
 
 class TestShellCommandParent : public PTestShellCommandParent
 {
@@ -49,17 +49,17 @@ public:
   JSBool RunCallback(const nsString& aResponse);
 
   void ReleaseCallback();
 
 protected:
   bool ExecuteCallback(const nsString& aResponse);
 
   void ActorDestroy(ActorDestroyReason why);
-  
+
   bool Recv__delete__(const nsString& aResponse) {
     return ExecuteCallback(aResponse);
   }
 
 private:
   JSContext* mCx;
   nsAutoJSValHolder mCallback;
 };

--- a/layout/ipc/RenderFrameChild.cpp
+++ b/layout/ipc/RenderFrameChild.cpp
@@ -40,22 +40,22 @@ RenderFrameChild::CancelDefaultPanZoom()
 
 void
 RenderFrameChild::DetectScrollableSubframe()
 {
   SendDetectScrollableSubframe();
 }
 
 PLayerTransactionChild*
-RenderFrameChild::AllocPLayerTransaction()
+RenderFrameChild::AllocPLayerTransactionChild()
 {
   return new LayerTransactionChild();
 }
 
 bool
-RenderFrameChild::DeallocPLayerTransaction(PLayerTransactionChild* aLayers)
+RenderFrameChild::DeallocPLayerTransactionChild(PLayerTransactionChild* aLayers)
 {
   delete aLayers;
   return true;
 }
 
 }  // namespace layout
 }  // namespace mozilla

--- a/layout/ipc/RenderFrameChild.h
+++ b/layout/ipc/RenderFrameChild.h
@@ -20,16 +20,16 @@ public:
   virtual ~RenderFrameChild() {}
 
   void CancelDefaultPanZoom();
   void DetectScrollableSubframe();
 
   void Destroy();
 
 protected:
-  virtual PLayerTransactionChild* AllocPLayerTransaction() MOZ_OVERRIDE;
-  virtual bool DeallocPLayerTransaction(PLayerTransactionChild* aLayers) MOZ_OVERRIDE;
+  virtual PLayerTransactionChild* AllocPLayerTransactionChild() MOZ_OVERRIDE;
+  virtual bool DeallocPLayerTransactionChild(PLayerTransactionChild* aLayers) MOZ_OVERRIDE;
 };
 
 } // namespace layout
 } // namespace mozilla
 
 #endif  // mozilla_dom_RenderFrameChild_h

--- a/layout/ipc/RenderFrameParent.cpp
+++ b/layout/ipc/RenderFrameParent.cpp
@@ -841,27 +841,27 @@ RenderFrameParent::RecvDetectScrollableS
 {
   if (mPanZoomController) {
     mPanZoomController->DetectScrollableSubframe();
   }
   return true;
 }
 
 PLayerTransactionParent*
-RenderFrameParent::AllocPLayerTransaction()
+RenderFrameParent::AllocPLayerTransactionParent()
 {
   if (!mFrameLoader || mFrameLoaderDestroyed) {
     return nullptr;
   }
   nsRefPtr<LayerManager> lm = GetFrom(mFrameLoader);
   return new LayerTransactionParent(lm->AsLayerManagerComposite(), this, 0);
 }
 
 bool
-RenderFrameParent::DeallocPLayerTransaction(PLayerTransactionParent* aLayers)
+RenderFrameParent::DeallocPLayerTransactionParent(PLayerTransactionParent* aLayers)
 {
   delete aLayers;
   return true;
 }
 
 void
 RenderFrameParent::BuildViewMap()
 {

--- a/layout/ipc/RenderFrameParent.h
+++ b/layout/ipc/RenderFrameParent.h
@@ -107,18 +107,18 @@ public:
 protected:
   void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 
   virtual bool RecvNotifyCompositorTransaction() MOZ_OVERRIDE;
 
   virtual bool RecvCancelDefaultPanZoom() MOZ_OVERRIDE;
   virtual bool RecvDetectScrollableSubframe() MOZ_OVERRIDE;
 
-  virtual PLayerTransactionParent* AllocPLayerTransaction() MOZ_OVERRIDE;
-  virtual bool DeallocPLayerTransaction(PLayerTransactionParent* aLayers) MOZ_OVERRIDE;
+  virtual PLayerTransactionParent* AllocPLayerTransactionParent() MOZ_OVERRIDE;
+  virtual bool DeallocPLayerTransactionParent(PLayerTransactionParent* aLayers) MOZ_OVERRIDE;
 
 private:
   void BuildViewMap();
   void TriggerRepaint();
   void DispatchEventForPanZoomController(const InputEvent& aEvent);
 
   LayerTransactionParent* GetShadowLayers() const;
   uint64_t GetLayerTreeId() const;