--- a/content/canvas/public/DocumentRendererParent.h
+++ b/content/canvas/public/DocumentRendererParent.h
@@ -21,18 +21,20 @@ public:
     DocumentRendererParent();
     virtual ~DocumentRendererParent();
 
     void SetCanvasContext(nsICanvasRenderingContextInternal* aCanvas,
 			  gfxContext* ctx);
     void DrawToCanvas(const nsIntSize& renderedSize,
 		      const nsCString& aData);
 
+    virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
     virtual bool Recv__delete__(const nsIntSize& renderedSize,
-                                const nsCString& data);
+                                const nsCString& data) MOZ_OVERRIDE;
 
 private:
     nsCOMPtr<nsICanvasRenderingContextInternal> mCanvas;
     nsRefPtr<gfxContext> mCanvasContext;
 
     DISALLOW_EVIL_CONSTRUCTORS(DocumentRendererParent);
 };
 

--- a/content/canvas/src/DocumentRendererParent.cpp
+++ b/content/canvas/src/DocumentRendererParent.cpp
@@ -43,15 +43,21 @@ void DocumentRendererParent::DrawToCanva
     // get rid of the pattern surface ref, because aData is very
     // likely to go away shortly
     mCanvasContext->SetColor(gfxRGBA(1,1,1,1));
 
     gfxRect damageRect = mCanvasContext->UserToDevice(rect);
     mCanvas->Redraw(damageRect);
 }
 
+void
+DocumentRendererParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005139
+}
+
 bool
 DocumentRendererParent::Recv__delete__(const nsIntSize& renderedSize,
                                        const nsCString& data)
 {
     DrawToCanvas(renderedSize, data);
     return true;
 }

--- a/content/media/webspeech/synth/ipc/SpeechSynthesisParent.cpp
+++ b/content/media/webspeech/synth/ipc/SpeechSynthesisParent.cpp
@@ -13,16 +13,22 @@ SpeechSynthesisParent::SpeechSynthesisPa
   MOZ_COUNT_CTOR(SpeechSynthesisParent);
 }
 
 SpeechSynthesisParent::~SpeechSynthesisParent()
 {
   MOZ_COUNT_DTOR(SpeechSynthesisParent);
 }
 
+void
+SpeechSynthesisParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005141
+}
+
 bool
 SpeechSynthesisParent::RecvReadVoiceList(InfallibleTArray<RemoteVoice>* aVoices,
                                          InfallibleTArray<nsString>* aDefaults)
 {
   nsSynthVoiceRegistry::GetInstance()->SendVoices(aVoices, aDefaults);
   return true;
 }
 
@@ -76,16 +82,22 @@ SpeechSynthesisRequestParent::~SpeechSyn
 {
   if (mTask && mTask->mActor) {
     mTask->mActor = nullptr;
   }
 
   MOZ_COUNT_DTOR(SpeechSynthesisRequestParent);
 }
 
+void
+SpeechSynthesisRequestParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005141
+}
+
 bool
 SpeechSynthesisRequestParent::RecvPause()
 {
   MOZ_ASSERT(mTask);
   mTask->Pause();
   return true;
 }
 

--- a/content/media/webspeech/synth/ipc/SpeechSynthesisParent.h
+++ b/content/media/webspeech/synth/ipc/SpeechSynthesisParent.h
@@ -17,16 +17,18 @@ class SpeechTaskParent;
 class SpeechSynthesisRequestParent;
 
 class SpeechSynthesisParent : public PSpeechSynthesisParent
 {
   friend class ContentParent;
   friend class SpeechSynthesisRequestParent;
 
 public:
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   bool RecvReadVoiceList(InfallibleTArray<RemoteVoice>* aVoices,
                          InfallibleTArray<nsString>* aDefaults) MOZ_OVERRIDE;
 
 protected:
   SpeechSynthesisParent();
   virtual ~SpeechSynthesisParent();
   PSpeechSynthesisRequestParent* AllocPSpeechSynthesisRequestParent(const nsString& aText,
                                                                     const nsString& aLang,
@@ -52,16 +54,18 @@ class SpeechSynthesisRequestParent : pub
 public:
   SpeechSynthesisRequestParent(SpeechTaskParent* aTask);
   virtual ~SpeechSynthesisRequestParent();
 
   nsRefPtr<SpeechTaskParent> mTask;
 
 protected:
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual bool RecvPause() MOZ_OVERRIDE;
 
   virtual bool RecvResume() MOZ_OVERRIDE;
 
   virtual bool RecvCancel() MOZ_OVERRIDE;
 };
 
 class SpeechTaskParent : public nsSpeechTask

--- a/dom/fmradio/ipc/FMRadioParent.cpp
+++ b/dom/fmradio/ipc/FMRadioParent.cpp
@@ -20,16 +20,22 @@ FMRadioParent::FMRadioParent()
 
 FMRadioParent::~FMRadioParent()
 {
   MOZ_COUNT_DTOR(FMRadioParent);
 
   IFMRadioService::Singleton()->RemoveObserver(this);
 }
 
+void
+FMRadioParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005146
+}
+
 bool
 FMRadioParent::RecvGetStatusInfo(StatusInfo* aStatusInfo)
 {
   aStatusInfo->enabled() = IFMRadioService::Singleton()->IsEnabled();
   aStatusInfo->frequency() = IFMRadioService::Singleton()->GetFrequency();
   aStatusInfo->upperBound() =
     IFMRadioService::Singleton()->GetFrequencyUpperBound();
   aStatusInfo->lowerBound() =

--- a/dom/fmradio/ipc/FMRadioParent.h
+++ b/dom/fmradio/ipc/FMRadioParent.h
@@ -17,16 +17,19 @@ class PFMRadioRequestParent;
 
 class FMRadioParent MOZ_FINAL : public PFMRadioParent
                               , public FMRadioEventObserver
 {
 public:
   FMRadioParent();
   ~FMRadioParent();
 
+  virtual void
+  ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual bool
   RecvGetStatusInfo(StatusInfo* aStatusInfo) MOZ_OVERRIDE;
 
   virtual PFMRadioRequestParent*
   AllocPFMRadioRequestParent(const FMRadioRequestArgs& aArgs) MOZ_OVERRIDE;
 
   virtual bool
   DeallocPFMRadioRequestParent(PFMRadioRequestParent* aActor) MOZ_OVERRIDE;

--- a/dom/indexedDB/ipc/IndexedDBParent.cpp
+++ b/dom/indexedDB/ipc/IndexedDBParent.cpp
@@ -2214,16 +2214,22 @@ IndexedDBDeleteDatabaseRequestParent::Ha
 
   if (!Send__delete__(this, mOpenRequest->GetErrorCode())) {
     return NS_ERROR_FAILURE;
   }
 
   return NS_OK;
 }
 
+void
+IndexedDBDeleteDatabaseRequestParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005149
+}
+
 nsresult
 IndexedDBDeleteDatabaseRequestParent::SetOpenRequest(
                                                  IDBOpenDBRequest* aOpenRequest)
 {
   MOZ_ASSERT(aOpenRequest);
   MOZ_ASSERT(!mOpenRequest);
 
   EventTarget* target = static_cast<EventTarget*>(aOpenRequest);

--- a/dom/indexedDB/ipc/IndexedDBParent.h
+++ b/dom/indexedDB/ipc/IndexedDBParent.h
@@ -858,16 +858,18 @@ class IndexedDBDeleteDatabaseRequestPare
 public:
   nsresult
   HandleEvent(nsIDOMEvent* aEvent);
 
 protected:
   IndexedDBDeleteDatabaseRequestParent(IDBFactory* aFactory);
   virtual ~IndexedDBDeleteDatabaseRequestParent();
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   nsresult
   SetOpenRequest(IDBOpenDBRequest* aOpenRequest);
 
   bool
   IsDisconnected() const
   {
     return static_cast<IndexedDBParent*>(Manager())->IsDisconnected();
   }

--- a/dom/ipc/Blob.cpp
+++ b/dom/ipc/Blob.cpp
@@ -469,16 +469,19 @@ public:
     MOZ_ASSERT(aRemoteStream);
   }
 
   InputStreamParent()
   {
     MOZ_ASSERT(NS_IsMainThread());
   }
 
+protected:
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
 private:
   // This method is only called by the IPDL message machinery.
   virtual bool
   Recv__delete__(const InputStreamParams& aParams,
                  const OptionalFileDescriptorSet& aFDs) MOZ_OVERRIDE;
 };
 
 nsDOMFileBase*
@@ -2155,16 +2158,22 @@ InputStreamChild::Recv__delete__(const I
   if (!stream) {
     return false;
   }
 
   mRemoteStream->SetStream(stream);
   return true;
 }
 
+void
+InputStreamParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005150
+}
+
 bool
 InputStreamParent::Recv__delete__(const InputStreamParams& aParams,
                                   const OptionalFileDescriptorSet& aFDs)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(mRemoteStream);
 
   if (aFDs.type() != OptionalFileDescriptorSet::Tvoid_t) {

--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -304,29 +304,37 @@ namespace dom {
 #define NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC "ipc:network:set-offline"
 
 class MemoryReportRequestParent : public PMemoryReportRequestParent
 {
 public:
     MemoryReportRequestParent();
     virtual ~MemoryReportRequestParent();
 
+    virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
     virtual bool Recv__delete__(const uint32_t& generation, const InfallibleTArray<MemoryReport>& report);
 private:
     ContentParent* Owner()
     {
         return static_cast<ContentParent*>(Manager());
     }
 };
 
 MemoryReportRequestParent::MemoryReportRequestParent()
 {
     MOZ_COUNT_CTOR(MemoryReportRequestParent);
 }
 
+void
+MemoryReportRequestParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005154
+}
+
 bool
 MemoryReportRequestParent::Recv__delete__(const uint32_t& generation, const InfallibleTArray<MemoryReport>& childReports)
 {
     nsRefPtr<nsMemoryReporterManager> mgr =
         nsMemoryReporterManager::GetOrCreate();
     if (mgr) {
         mgr->HandleChildReports(generation, childReports);
     }

--- a/dom/ipc/CrashReporterParent.cpp
+++ b/dom/ipc/CrashReporterParent.cpp
@@ -21,16 +21,22 @@ void
 CrashReporterParent::AnnotateCrashReport(const nsCString& key,
                                          const nsCString& data)
 {
 #ifdef MOZ_CRASHREPORTER
     mNotes.Put(key, data);
 #endif
 }
 
+void
+CrashReporterParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005155
+}
+
 bool
 CrashReporterParent::RecvAppendAppNotes(const nsCString& data)
 {
     mAppNotes.Append(data);
     return true;
 }
 
 mozilla::ipc::IProtocol*

--- a/dom/ipc/CrashReporterParent.h
+++ b/dom/ipc/CrashReporterParent.h
@@ -72,16 +72,18 @@ public:
   const nsString& ChildDumpID() {
     return mChildDumpID;
   }
 
   void
   AnnotateCrashReport(const nsCString& key, const nsCString& data);
 
  protected:
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual bool
     RecvAnnotateCrashReport(const nsCString& key, const nsCString& data) MOZ_OVERRIDE {
     AnnotateCrashReport(key, data);
     return true;
   }
   virtual bool
     RecvAppendAppNotes(const nsCString& data) MOZ_OVERRIDE;
   virtual mozilla::ipc::IProtocol*

--- a/dom/ipc/FileDescriptorSetParent.cpp
+++ b/dom/ipc/FileDescriptorSetParent.cpp
@@ -22,16 +22,22 @@ FileDescriptorSetParent::~FileDescriptor
 void
 FileDescriptorSetParent::ForgetFileDescriptors(
                                      nsTArray<FileDescriptor>& aFileDescriptors)
 {
   aFileDescriptors.Clear();
   mFileDescriptors.SwapElements(aFileDescriptors);
 }
 
+void
+FileDescriptorSetParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005157
+}
+
 bool
 FileDescriptorSetParent::RecvAddFileDescriptor(
                                           const FileDescriptor& aFileDescriptor)
 {
   mFileDescriptors.AppendElement(aFileDescriptor);
   return true;
 }
 

--- a/dom/ipc/FileDescriptorSetParent.h
+++ b/dom/ipc/FileDescriptorSetParent.h
@@ -31,16 +31,18 @@ public:
 
   void
   ForgetFileDescriptors(nsTArray<FileDescriptor>& aFileDescriptors);
 
 private:
   FileDescriptorSetParent(const FileDescriptor& aFileDescriptor);
   ~FileDescriptorSetParent();
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual bool
   RecvAddFileDescriptor(const FileDescriptor& aFileDescriptor) MOZ_OVERRIDE;
 
   nsTArray<FileDescriptor> mFileDescriptors;
 };
 
 } // namespace dom
 } // namespace mozilla

--- a/dom/plugins/ipc/BrowserStreamParent.cpp
+++ b/dom/plugins/ipc/BrowserStreamParent.cpp
@@ -25,16 +25,22 @@ BrowserStreamParent::BrowserStreamParent
 {
   mStream->pdata = static_cast<AStream*>(this);
 }
 
 BrowserStreamParent::~BrowserStreamParent()
 {
 }
 
+void
+BrowserStreamParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005159
+}
+
 bool
 BrowserStreamParent::AnswerNPN_RequestRead(const IPCByteRanges& ranges,
                                            NPError* result)
 {
   PLUGIN_LOG_DEBUG_FUNCTION;
 
   switch (mState) {
   case ALIVE:

--- a/dom/plugins/ipc/BrowserStreamParent.h
+++ b/dom/plugins/ipc/BrowserStreamParent.h
@@ -21,16 +21,18 @@ class BrowserStreamParent : public PBrow
 
 public:
   BrowserStreamParent(PluginInstanceParent* npp,
                       NPStream* stream);
   virtual ~BrowserStreamParent();
 
   virtual bool IsBrowserStream() MOZ_OVERRIDE { return true; }
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual bool AnswerNPN_RequestRead(const IPCByteRanges& ranges,
                                      NPError* result) MOZ_OVERRIDE;
 
   virtual bool RecvNPN_DestroyStream(const NPReason& reason) MOZ_OVERRIDE;
 
   virtual bool RecvStreamDestroyed() MOZ_OVERRIDE;
 
   int32_t WriteReady();

--- a/dom/plugins/ipc/PluginIdentifierParent.cpp
+++ b/dom/plugins/ipc/PluginIdentifierParent.cpp
@@ -12,16 +12,22 @@
 #include "nsCxPusher.h"
 #include "mozilla/unused.h"
 
 using namespace mozilla::plugins::parent;
 
 namespace mozilla {
 namespace plugins {
 
+void
+PluginIdentifierParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005161
+}
+
 bool
 PluginIdentifierParent::RecvRetain()
 {
   mTemporaryRefs = 0;
 
   // Intern the jsid if necessary.
   AutoSafeJSContext cx;
   JS::Rooted<jsid> id(cx, NPIdentifierToJSId(mIdentifier));

--- a/dom/plugins/ipc/PluginIdentifierParent.h
+++ b/dom/plugins/ipc/PluginIdentifierParent.h
@@ -59,16 +59,18 @@ protected:
     MOZ_COUNT_CTOR(PluginIdentifierParent);
   }
 
   virtual ~PluginIdentifierParent()
   {
     MOZ_COUNT_DTOR(PluginIdentifierParent);
   }
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual bool RecvRetain() MOZ_OVERRIDE;
 
   void AddTemporaryRef() {
     mTemporaryRefs++;
   }
 
   /**
    * @returns true if the last temporary reference was removed.

--- a/dom/plugins/ipc/PluginInstanceParent.cpp
+++ b/dom/plugins/ipc/PluginInstanceParent.cpp
@@ -51,16 +51,22 @@ extern const wchar_t* kFlashFullscreenCl
 #elif defined(XP_MACOSX)
 #include <ApplicationServices/ApplicationServices.h>
 #endif // defined(XP_MACOSX)
 
 using namespace mozilla::plugins;
 using namespace mozilla::layers;
 using namespace mozilla::gl;
 
+void
+StreamNotifyParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005162
+}
+
 bool
 StreamNotifyParent::RecvRedirectNotifyResponse(const bool& allow)
 {
   PluginInstanceParent* instance = static_cast<PluginInstanceParent*>(Manager());
   instance->mNPNIface->urlredirectresponse(instance->mNPP, this, static_cast<NPBool>(allow));
   return true;
 }
 

--- a/dom/plugins/ipc/PluginScriptableObjectParent.cpp
+++ b/dom/plugins/ipc/PluginScriptableObjectParent.cpp
@@ -638,16 +638,22 @@ PluginScriptableObjectParent::DropNPObje
   NS_ASSERTION(instance, "Must have an instance!");
 
   instance->UnregisterNPObject(mObject);
   mObject = nullptr;
 
   unused << SendUnprotect();
 }
 
+void
+PluginScriptableObjectParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005163
+}
+
 bool
 PluginScriptableObjectParent::AnswerHasMethod(PPluginIdentifierParent* aId,
                                               bool* aHasMethod)
 {
   if (!mObject) {
     NS_WARNING("Calling AnswerHasMethod with an invalidated object!");
     *aHasMethod = false;
     return true;

--- a/dom/plugins/ipc/PluginScriptableObjectParent.h
+++ b/dom/plugins/ipc/PluginScriptableObjectParent.h
@@ -40,16 +40,19 @@ public:
   virtual ~PluginScriptableObjectParent();
 
   void
   InitializeProxy();
 
   void
   InitializeLocal(NPObject* aObject);
 
+  virtual void
+  ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual bool
   AnswerHasMethod(PPluginIdentifierParent* aId,
                   bool* aHasMethod) MOZ_OVERRIDE;
 
   virtual bool
   AnswerInvoke(PPluginIdentifierParent* aId,
                const InfallibleTArray<Variant>& aArgs,
                Variant* aResult,

--- a/dom/plugins/ipc/PluginStreamParent.cpp
+++ b/dom/plugins/ipc/PluginStreamParent.cpp
@@ -21,16 +21,22 @@ PluginStreamParent::PluginStreamParent(P
                                             NullableStringGet(target),
                                             &mStream);
   if (*result == NPERR_NO_ERROR)
     mStream->pdata = static_cast<AStream*>(this);
   else
     mStream = nullptr;
 }
 
+void
+PluginStreamParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005166
+}
+
 bool
 PluginStreamParent::AnswerNPN_Write(const Buffer& data, int32_t* written)
 {
   if (mClosed) {
     *written = -1;
     return true;
   }
 

--- a/dom/plugins/ipc/PluginStreamParent.h
+++ b/dom/plugins/ipc/PluginStreamParent.h
@@ -21,16 +21,18 @@ class PluginStreamParent : public PPlugi
 
 public:
   PluginStreamParent(PluginInstanceParent* npp, const nsCString& mimeType,
                      const nsCString& target, NPError* result);
   virtual ~PluginStreamParent() { }
 
   virtual bool IsBrowserStream() MOZ_OVERRIDE { return false; }
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual bool AnswerNPN_Write(const Buffer& data, int32_t* written) MOZ_OVERRIDE;
 
   virtual bool Answer__delete__(const NPError& reason, const bool& artificial) MOZ_OVERRIDE;
 
 private:
   void NPN_DestroyStream(NPReason reason);
 
   PluginInstanceParent* mInstance;

--- a/dom/plugins/ipc/PluginSurfaceParent.cpp
+++ b/dom/plugins/ipc/PluginSurfaceParent.cpp
@@ -19,10 +19,16 @@ PluginSurfaceParent::PluginSurfaceParent
   if (dibsurf->Attach(handle, size.width, size.height, transparent))
     mSurface = dibsurf;
 }
 
 PluginSurfaceParent::~PluginSurfaceParent()
 {
 }
 
+void
+PluginSurfaceParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005167
+}
+
 }
 }

--- a/dom/plugins/ipc/PluginSurfaceParent.h
+++ b/dom/plugins/ipc/PluginSurfaceParent.h
@@ -22,16 +22,18 @@ namespace plugins {
 class PluginSurfaceParent : public PPluginSurfaceParent
 {
 public:
   PluginSurfaceParent(const WindowsSharedMemoryHandle& handle,
                       const gfxIntSize& size,
                       const bool transparent);
   ~PluginSurfaceParent();
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   gfxASurface* Surface() { return mSurface; }
 
 private:
   nsRefPtr<gfxASurface> mSurface;
 };
 
 } // namespace plugins
 } // namespace mozilla

--- a/dom/plugins/ipc/StreamNotifyParent.h
+++ b/dom/plugins/ipc/StreamNotifyParent.h
@@ -29,16 +29,18 @@ public:
   // so that we aren't destroyed again. see bug 536437.
   void SetDestructionFlag(bool* flag) {
     mDestructionFlag = flag;
   }
   void ClearDestructionFlag() {
     mDestructionFlag = nullptr;
   }
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
 private:
   bool RecvRedirectNotifyResponse(const bool& allow) MOZ_OVERRIDE;
 
   bool* mDestructionFlag;
 };
 
 } // namespace plugins
 } // namespace mozilla

--- a/dom/src/storage/DOMStorageIPC.cpp
+++ b/dom/src/storage/DOMStorageIPC.cpp
@@ -373,16 +373,22 @@ DOMStorageDBParent::CloneProtocol(Channe
 }
 
 DOMStorageDBParent::CacheParentBridge*
 DOMStorageDBParent::NewCache(const nsACString& aScope)
 {
   return new CacheParentBridge(this, aScope);
 }
 
+void
+DOMStorageDBParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005169
+}
+
 bool
 DOMStorageDBParent::RecvAsyncPreload(const nsCString& aScope, const bool& aPriority)
 {
   DOMStorageDBBridge* db = DOMStorageCache::StartDatabase();
   if (!db) {
     return false;
   }
 

--- a/dom/src/storage/DOMStorageIPC.h
+++ b/dom/src/storage/DOMStorageIPC.h
@@ -166,16 +166,17 @@ public:
 
   private:
     nsRefPtr<DOMStorageDBParent> mParent;
     nsCString mScope;
   };
 
 private:
   // IPC
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
   bool RecvAsyncPreload(const nsCString& aScope, const bool& aPriority);
   bool RecvPreload(const nsCString& aScope, const uint32_t& aAlreadyLoadedCount,
                    InfallibleTArray<nsString>* aKeys, InfallibleTArray<nsString>* aValues,
                    nsresult* aRv);
   bool RecvAsyncGetUsage(const nsCString& aScope);
   bool RecvAsyncAddItem(const nsCString& aScope, const nsString& aKey, const nsString& aValue);
   bool RecvAsyncUpdateItem(const nsCString& aScope, const nsString& aKey, const nsString& aValue);
   bool RecvAsyncRemoveItem(const nsCString& aScope, const nsString& aKey);

--- a/gfx/layers/ipc/LayerTransactionParent.cpp
+++ b/gfx/layers/ipc/LayerTransactionParent.cpp
@@ -170,16 +170,22 @@ LayerTransactionParent::Destroy()
 
 LayersBackend
 LayerTransactionParent::GetCompositorBackendType() const
 {
   return mLayerManager->GetBackendType();
 }
 
 /* virtual */
+void
+LayerTransactionParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005171
+}
+
 bool
 LayerTransactionParent::RecvUpdateNoSwap(const InfallibleTArray<Edit>& cset,
                                          const TargetConfig& targetConfig,
                                          const bool& isFirstPaint,
                                          const bool& scheduleComposite)
 {
   return RecvUpdate(cset, targetConfig, isFirstPaint, scheduleComposite, nullptr);
 }

--- a/gfx/layers/ipc/LayerTransactionParent.h
+++ b/gfx/layers/ipc/LayerTransactionParent.h
@@ -75,16 +75,18 @@ public:
     PLayerTransactionParent::DeallocShmem(aShmem);
   }
 
   virtual LayersBackend GetCompositorBackendType() const MOZ_OVERRIDE;
 
   virtual bool IsSameProcess() const MOZ_OVERRIDE;
 
 protected:
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual bool RecvUpdate(const EditArray& cset,
                           const TargetConfig& targetConfig,
                           const bool& isFirstPaint,
                           const bool& scheduleComposite,
                           EditReplyArray* reply) MOZ_OVERRIDE;
 
   virtual bool RecvUpdateNoSwap(const EditArray& cset,
                                 const TargetConfig& targetConfig,

--- a/ipc/testshell/TestShellParent.cpp
+++ b/ipc/testshell/TestShellParent.cpp
@@ -13,16 +13,22 @@
 #include "nsCxPusher.h"
 
 using namespace mozilla;
 using mozilla::ipc::TestShellParent;
 using mozilla::ipc::TestShellCommandParent;
 using mozilla::ipc::PTestShellCommandParent;
 using mozilla::dom::ContentParent;
 
+void
+TestShellParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005177
+}
+
 PTestShellCommandParent*
 TestShellParent::AllocPTestShellCommandParent(const nsString& aCommand)
 {
   return new TestShellCommandParent();
 }
 
 bool
 TestShellParent::DeallocPTestShellCommandParent(PTestShellCommandParent* aActor)

--- a/ipc/testshell/TestShellParent.h
+++ b/ipc/testshell/TestShellParent.h
@@ -19,16 +19,18 @@ namespace mozilla {
 
 namespace ipc {
 
 class TestShellCommandParent;
 
 class TestShellParent : public PTestShellParent
 {
 public:
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   PTestShellCommandParent*
   AllocPTestShellCommandParent(const nsString& aCommand);
 
   bool
   DeallocPTestShellCommandParent(PTestShellCommandParent* aActor);
 
   bool
   CommandDone(TestShellCommandParent* aActor, const nsString& aResponse);

--- a/netwerk/base/src/ChannelDiverterParent.cpp
+++ b/netwerk/base/src/ChannelDiverterParent.cpp
@@ -56,10 +56,16 @@ void
 ChannelDiverterParent::DivertTo(nsIStreamListener* newListener)
 {
   MOZ_ASSERT(newListener);
   MOZ_ASSERT(mDivertableChannelParent);
 
   mDivertableChannelParent->DivertTo(newListener);
 }
 
+void
+ChannelDiverterParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005179
+}
+
 } // namespace net
 } // namespace mozilla

--- a/netwerk/base/src/ChannelDiverterParent.h
+++ b/netwerk/base/src/ChannelDiverterParent.h
@@ -22,16 +22,19 @@ class ChannelDiverterParent :
 {
 public:
   ChannelDiverterParent();
   virtual ~ChannelDiverterParent();
 
   bool Init(const ChannelDiverterArgs& aChannel);
 
   void DivertTo(nsIStreamListener* newListener);
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
 private:
   nsRefPtr<ADivertableParentChannel> mDivertableChannelParent;
 };
 
 } // namespace net
 } // namespace mozilla
 
 #endif /* _channeldiverterparent_h_ */

--- a/netwerk/cookie/CookieServiceParent.cpp
+++ b/netwerk/cookie/CookieServiceParent.cpp
@@ -59,16 +59,22 @@ CookieServiceParent::CookieServiceParent
     already_AddRefed<nsCookieService>(nsCookieService::GetSingleton());
   NS_ASSERTION(mCookieService, "couldn't get nsICookieService");
 }
 
 CookieServiceParent::~CookieServiceParent()
 {
 }
 
+void
+CookieServiceParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005181
+}
+
 bool
 CookieServiceParent::RecvGetCookieString(const URIParams& aHost,
                                          const bool& aIsForeign,
                                          const bool& aFromHttp,
                                          const IPC::SerializedLoadContext&
                                                aLoadContext,
                                          nsCString* aResult)
 {

--- a/netwerk/cookie/CookieServiceParent.h
+++ b/netwerk/cookie/CookieServiceParent.h
@@ -23,17 +23,19 @@ public:
 
 protected:
   MOZ_WARN_UNUSED_RESULT bool
   GetAppInfoFromParams(const IPC::SerializedLoadContext &aLoadContext,
                        uint32_t& aAppId,
                        bool& aIsInBrowserElement,
                        bool& aIsPrivate);
 
-   virtual bool RecvGetCookieString(const URIParams& aHost,
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
+  virtual bool RecvGetCookieString(const URIParams& aHost,
                                    const bool& aIsForeign,
                                    const bool& aFromHttp,
                                    const IPC::SerializedLoadContext&
                                          loadContext,
                                    nsCString* aResult) MOZ_OVERRIDE;
 
   virtual bool RecvSetCookieString(const URIParams& aHost,
                                    const bool& aIsForeign,

--- a/netwerk/ipc/NeckoParent.cpp
+++ b/netwerk/ipc/NeckoParent.cpp
@@ -173,16 +173,22 @@ NeckoParent::CreateChannelLoadContext(PB
   // the common case for most xpcshell tests.
   if (aSerialized.IsNotNull()) {
     aResult = new LoadContext(aSerialized, topFrameElement, appId, inBrowser);
   }
 
   return nullptr;
 }
 
+void
+NeckoParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005184
+}
+
 PHttpChannelParent*
 NeckoParent::AllocPHttpChannelParent(PBrowserParent* aBrowser,
                                      const SerializedLoadContext& aSerialized,
                                      const HttpChannelCreationArgs& aOpenArgs)
 {
   nsCOMPtr<nsILoadContext> loadContext;
   const char *error = CreateChannelLoadContext(aBrowser, Manager(),
                                                aSerialized, loadContext);

--- a/netwerk/ipc/NeckoParent.h
+++ b/netwerk/ipc/NeckoParent.h
@@ -52,16 +52,18 @@ public:
    */
   MOZ_WARN_UNUSED_RESULT
   static const char*
   CreateChannelLoadContext(PBrowserParent* aBrowser,
                            PContentParent* aContent,
                            const SerializedLoadContext& aSerialized,
                            nsCOMPtr<nsILoadContext> &aResult);
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   virtual void
   CloneManagees(ProtocolBase* aSource,
               mozilla::ipc::ProtocolCloneContext* aCtx) MOZ_OVERRIDE;
   virtual PCookieServiceParent* AllocPCookieServiceParent() MOZ_OVERRIDE;
   virtual bool
   RecvPCookieServiceConstructor(PCookieServiceParent* aActor) MOZ_OVERRIDE
   {
     return PNeckoParent::RecvPCookieServiceConstructor(aActor);

--- a/netwerk/ipc/RemoteOpenFileParent.cpp
+++ b/netwerk/ipc/RemoteOpenFileParent.cpp
@@ -12,16 +12,22 @@
 #if !defined(XP_WIN) && !defined(MOZ_WIDGET_COCOA)
 #include <fcntl.h>
 #include <unistd.h>
 #endif
 
 namespace mozilla {
 namespace net {
 
+void
+RemoteOpenFileParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  // Implement me! Bug 1005186
+}
+
 bool
 RemoteOpenFileParent::OpenSendCloseDelete()
 {
 #if defined(XP_WIN) || defined(MOZ_WIDGET_COCOA)
   MOZ_CRASH("OS X and Windows shouldn't be doing IPDL here");
 #else
 
   // TODO: make this async!

--- a/netwerk/ipc/RemoteOpenFileParent.h
+++ b/netwerk/ipc/RemoteOpenFileParent.h
@@ -17,16 +17,18 @@ namespace net {
 
 class RemoteOpenFileParent : public PRemoteOpenFileParent
 {
 public:
   RemoteOpenFileParent(nsIFileURL* aURI)
   : mURI(aURI)
   {}
 
+  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
+
   bool OpenSendCloseDelete();
 
 private:
   nsCOMPtr<nsIFileURL> mURI;
 };
 
 } // namespace net
 } // namespace mozilla