Bug 1512990 - Part 4 - remove declarations of Recv/Answer methods from IPDL protocol base class; r=froydnj
authorAlex Gaynor <agaynor@mozilla.com>
Wed, 06 Feb 2019 15:58:43 +0000
changeset 518312 92091d537161e4df0986113e26762ed801190dfa
parent 518311 09c24f46810fa8c6ebd5879d32db87132e72a06e
child 518313 c5e880064cfe1411baf51d52ba86b447fb99ba35
push id2032
push userffxbld-merge
push dateMon, 13 May 2019 09:36:57 +0000
treeherdermozilla-release@455c1065dcbe [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1512990
milestone67.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 1512990 - Part 4 - remove declarations of Recv/Answer methods from IPDL protocol base class; r=froydnj For cases where the class has direct calls (that is, we cast `this` to the subclass before making the call) no longer declare Recv/Answer methods on the base class at all. This should ensure that slots for them are not generated in vtables, and also allow the derived class to choose the method signature (e.g. whether it wants to take something by reference or by value). Differential Revision: https://phabricator.services.mozilla.com/D18132
devtools/shared/heapsnapshot/HeapSnapshotTempFileHelperParent.h
dom/base/nsContentPermissionHelper.h
dom/cache/CacheParent.h
dom/cache/CacheStorageParent.h
dom/cache/CacheStreamControlChild.h
dom/cache/CacheStreamControlParent.h
dom/file/ipc/IPCBlobInputStreamChild.h
dom/file/ipc/IPCBlobInputStreamParent.h
dom/file/ipc/TemporaryIPCBlobChild.h
dom/file/ipc/TemporaryIPCBlobParent.h
dom/filehandle/ActorsParent.h
dom/gamepad/ipc/GamepadEventChannelChild.h
dom/gamepad/ipc/GamepadEventChannelParent.h
dom/gamepad/ipc/GamepadTestChannelChild.h
dom/gamepad/ipc/GamepadTestChannelParent.h
dom/indexedDB/ActorsParent.cpp
dom/ipc/ContentBridgeChild.h
dom/ipc/ContentChild.h
dom/ipc/ContentParent.h
dom/ipc/FilePickerParent.h
dom/ipc/TabParent.h
dom/ipc/WindowGlobalParent.h
dom/media/gmp/ChromiumCDMParent.h
dom/media/gmp/GMPChild.h
dom/media/gmp/GMPParent.h
dom/media/gmp/GMPStorageChild.h
dom/media/gmp/GMPTimerChild.h
dom/media/gmp/GMPTimerParent.h
dom/media/gmp/GMPVideoDecoderChild.h
dom/media/gmp/GMPVideoEncoderChild.h
dom/media/ipc/RDDChild.h
dom/media/ipc/RDDParent.h
dom/media/ipc/VideoDecoderManagerParent.h
dom/media/systemservices/MediaSystemResourceManagerChild.h
dom/media/systemservices/MediaSystemResourceManagerParent.h
dom/media/webspeech/synth/ipc/SpeechSynthesisChild.h
dom/messagechannel/MessagePortChild.h
dom/messagechannel/MessagePortParent.h
dom/midi/MIDIManagerParent.h
dom/midi/MIDIPortChild.h
dom/midi/MIDIPortParent.h
dom/network/TCPServerSocketChild.h
dom/network/TCPServerSocketParent.h
dom/network/TCPSocketChild.h
dom/network/TCPSocketParent.h
dom/network/UDPSocketChild.h
dom/network/UDPSocketParent.h
dom/payments/ipc/PaymentRequestChild.h
dom/payments/ipc/PaymentRequestParent.h
dom/plugins/ipc/BrowserStreamChild.h
dom/plugins/ipc/PluginInstanceChild.h
dom/plugins/ipc/PluginInstanceParent.h
dom/plugins/ipc/PluginModuleChild.h
dom/plugins/ipc/PluginModuleParent.h
dom/plugins/ipc/PluginScriptableObjectChild.h
dom/plugins/ipc/PluginScriptableObjectParent.h
dom/plugins/ipc/StreamNotifyChild.h
dom/plugins/ipc/StreamNotifyParent.h
dom/presentation/ipc/PresentationBuilderChild.h
dom/presentation/ipc/PresentationBuilderParent.h
dom/presentation/ipc/PresentationChild.h
dom/presentation/ipc/PresentationParent.h
dom/serviceworkers/ServiceWorkerManagerChild.h
dom/serviceworkers/ServiceWorkerManagerParent.h
dom/webauthn/WebAuthnTransactionChild.h
dom/webauthn/WebAuthnTransactionParent.h
dom/webbrowserpersist/WebBrowserPersistDocumentChild.h
dom/webbrowserpersist/WebBrowserPersistDocumentParent.h
dom/workers/remoteworkers/RemoteWorkerChild.h
dom/workers/remoteworkers/RemoteWorkerParent.h
dom/workers/sharedworkers/SharedWorkerChild.h
dom/workers/sharedworkers/SharedWorkerParent.h
extensions/spellcheck/hunspell/glue/RemoteSpellCheckEngineParent.h
gfx/ipc/GPUChild.h
gfx/ipc/GPUParent.h
gfx/ipc/VsyncBridgeParent.h
gfx/layers/ipc/APZCTreeManagerChild.h
gfx/layers/ipc/APZCTreeManagerParent.h
gfx/layers/ipc/APZChild.h
gfx/layers/ipc/APZInputBridgeParent.h
gfx/layers/ipc/CompositorBridgeChild.h
gfx/layers/ipc/CompositorBridgeParent.h
gfx/layers/ipc/CompositorManagerParent.h
gfx/layers/ipc/ImageBridgeChild.h
gfx/layers/ipc/ImageBridgeParent.h
gfx/layers/ipc/LayerTransactionParent.h
gfx/layers/ipc/UiCompositorControllerChild.h
gfx/layers/ipc/UiCompositorControllerParent.h
gfx/layers/wr/WebRenderBridgeChild.h
gfx/vr/ipc/VRChild.h
gfx/vr/ipc/VRGPUParent.h
gfx/vr/ipc/VRManagerChild.h
gfx/vr/ipc/VRManagerParent.h
gfx/vr/ipc/VRParent.h
ipc/glue/FileDescriptorSetChild.h
ipc/glue/FileDescriptorSetParent.h
ipc/ipdl/ipdl/lower.py
ipc/testshell/TestShellChild.h
layout/ipc/VsyncChild.h
layout/ipc/VsyncParent.h
layout/printing/ipc/RemotePrintJobChild.h
layout/printing/ipc/RemotePrintJobParent.h
netwerk/cookie/CookieServiceChild.h
netwerk/cookie/CookieServiceParent.h
netwerk/dns/DNSRequestChild.h
netwerk/dns/DNSRequestParent.h
netwerk/ipc/NeckoChild.h
netwerk/ipc/NeckoParent.h
netwerk/ipc/SocketProcessBridgeChild.h
netwerk/ipc/SocketProcessBridgeParent.h
netwerk/ipc/SocketProcessChild.h
netwerk/ipc/SocketProcessParent.h
netwerk/protocol/http/AltDataOutputStreamChild.h
netwerk/protocol/http/AltDataOutputStreamParent.h
netwerk/protocol/http/HttpBackgroundChannelChild.h
netwerk/protocol/websocket/WebSocketChannelChild.h
netwerk/protocol/websocket/WebSocketChannelParent.h
netwerk/protocol/websocket/WebSocketEventListenerChild.h
netwerk/protocol/websocket/WebSocketEventListenerParent.h
netwerk/protocol/wyciwyg/WyciwygChannelParent.h
security/manager/ssl/PSMContentListener.h
toolkit/components/extensions/webrequest/StreamFilterChild.h
toolkit/components/extensions/webrequest/StreamFilterParent.h
toolkit/components/printingui/ipc/PrintingParent.h
uriloader/exthandler/ExternalHelperAppChild.h
uriloader/prefetch/OfflineCacheUpdateChild.h
--- a/devtools/shared/heapsnapshot/HeapSnapshotTempFileHelperParent.h
+++ b/devtools/shared/heapsnapshot/HeapSnapshotTempFileHelperParent.h
@@ -14,17 +14,17 @@ namespace devtools {
 
 class HeapSnapshotTempFileHelperParent
     : public PHeapSnapshotTempFileHelperParent {
   friend class PHeapSnapshotTempFileHelperParent;
 
   explicit HeapSnapshotTempFileHelperParent() {}
   void ActorDestroy(ActorDestroyReason why) override {}
   mozilla::ipc::IPCResult RecvOpenHeapSnapshotTempFile(
-      OpenHeapSnapshotTempFileResponse* outResponse) override;
+      OpenHeapSnapshotTempFileResponse* outResponse);
 
  public:
   static inline PHeapSnapshotTempFileHelperParent* Create();
 };
 
 /* static */ inline PHeapSnapshotTempFileHelperParent*
 HeapSnapshotTempFileHelperParent::Create() {
   return new HeapSnapshotTempFileHelperParent();
--- a/dom/base/nsContentPermissionHelper.h
+++ b/dom/base/nsContentPermissionHelper.h
@@ -216,21 +216,20 @@ class RemotePermissionRequest final
  public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSICONTENTPERMISSIONREQUESTCALLBACK
 
   RemotePermissionRequest(nsIContentPermissionRequest* aRequest,
                           nsPIDOMWindowInner* aWindow);
 
   // It will be called when prompt dismissed.
-  virtual mozilla::ipc::IPCResult RecvNotifyResult(
-      const bool& aAllow,
-      InfallibleTArray<PermissionChoice>&& aChoices) override;
+  mozilla::ipc::IPCResult RecvNotifyResult(
+      const bool& aAllow, InfallibleTArray<PermissionChoice>&& aChoices);
 
-  virtual mozilla::ipc::IPCResult RecvGetVisibility() override;
+  mozilla::ipc::IPCResult RecvGetVisibility();
 
   void IPDLAddRef() {
     mIPCOpen = true;
     AddRef();
   }
 
   void IPDLRelease() {
     mIPCOpen = false;
--- a/dom/cache/CacheParent.h
+++ b/dom/cache/CacheParent.h
@@ -29,17 +29,17 @@ class CacheParent final : public PCacheP
 
   PCacheOpParent* AllocPCacheOpParent(const CacheOpArgs& aOpArgs);
 
   bool DeallocPCacheOpParent(PCacheOpParent* aActor);
 
   virtual mozilla::ipc::IPCResult RecvPCacheOpConstructor(
       PCacheOpParent* actor, const CacheOpArgs& aOpArgs) override;
 
-  virtual mozilla::ipc::IPCResult RecvTeardown() override;
+  mozilla::ipc::IPCResult RecvTeardown();
 
   RefPtr<cache::Manager> mManager;
   const CacheId mCacheId;
 };
 
 }  // namespace cache
 }  // namespace dom
 }  // namespace mozilla
--- a/dom/cache/CacheStorageParent.h
+++ b/dom/cache/CacheStorageParent.h
@@ -32,17 +32,17 @@ class CacheStorageParent final : public 
 
   PCacheOpParent* AllocPCacheOpParent(const CacheOpArgs& aOpArgs);
 
   bool DeallocPCacheOpParent(PCacheOpParent* aActor);
 
   virtual mozilla::ipc::IPCResult RecvPCacheOpConstructor(
       PCacheOpParent* actor, const CacheOpArgs& aOpArgs) override;
 
-  virtual mozilla::ipc::IPCResult RecvTeardown() override;
+  mozilla::ipc::IPCResult RecvTeardown();
 
   // PrincipalVerifier::Listener methods
   virtual void OnPrincipalVerified(nsresult aRv,
                                    ManagerId* aManagerId) override;
 
   const Namespace mNamespace;
   RefPtr<PrincipalVerifier> mVerifier;
   nsresult mVerifiedStatus;
--- a/dom/cache/CacheStreamControlChild.h
+++ b/dom/cache/CacheStreamControlChild.h
@@ -48,18 +48,18 @@ class CacheStreamControlChild final : pu
   virtual void NoteClosedAfterForget(const nsID& aId) override;
 
 #ifdef DEBUG
   virtual void AssertOwningThread() override;
 #endif
 
   // PCacheStreamControlChild methods
   virtual void ActorDestroy(ActorDestroyReason aReason) override;
-  virtual mozilla::ipc::IPCResult RecvClose(const nsID& aId) override;
-  virtual mozilla::ipc::IPCResult RecvCloseAll() override;
+  mozilla::ipc::IPCResult RecvClose(const nsID& aId);
+  mozilla::ipc::IPCResult RecvCloseAll();
 
   bool mDestroyStarted;
   bool mDestroyDelayed;
 
   NS_DECL_OWNINGTHREAD
 };
 
 }  // namespace cache
--- a/dom/cache/CacheStreamControlParent.h
+++ b/dom/cache/CacheStreamControlParent.h
@@ -52,20 +52,20 @@ class CacheStreamControlParent final : p
 
 #ifdef DEBUG
   virtual void AssertOwningThread() override;
 #endif
 
   // PCacheStreamControlParent methods
   virtual void ActorDestroy(ActorDestroyReason aReason) override;
 
-  virtual mozilla::ipc::IPCResult RecvOpenStream(
-      const nsID& aStreamId, OpenStreamResolver&& aResolve) override;
+  mozilla::ipc::IPCResult RecvOpenStream(const nsID& aStreamId,
+                                         OpenStreamResolver&& aResolve);
 
-  virtual mozilla::ipc::IPCResult RecvNoteClosed(const nsID& aId) override;
+  mozilla::ipc::IPCResult RecvNoteClosed(const nsID& aId);
 
   void NotifyClose(const nsID& aId);
   void NotifyCloseAll();
 
   // Cycle with StreamList via a weak-ref to us.  Cleanup occurs when the actor
   // is deleted by the PBackground manager.  ActorDestroy() then calls
   // StreamList::RemoveStreamControl() to clear the weak ref.
   RefPtr<StreamList> mStreamList;
--- a/dom/file/ipc/IPCBlobInputStreamChild.h
+++ b/dom/file/ipc/IPCBlobInputStreamChild.h
@@ -51,22 +51,21 @@ class IPCBlobInputStreamChild final
   void ForgetStream(IPCBlobInputStream* aStream);
 
   const nsID& ID() const { return mID; }
 
   uint64_t Size() const { return mSize; }
 
   void StreamNeeded(IPCBlobInputStream* aStream, nsIEventTarget* aEventTarget);
 
-  mozilla::ipc::IPCResult RecvStreamReady(
-      const OptionalIPCStream& aStream) override;
+  mozilla::ipc::IPCResult RecvStreamReady(const OptionalIPCStream& aStream);
 
   void LengthNeeded(IPCBlobInputStream* aStream, nsIEventTarget* aEventTarget);
 
-  mozilla::ipc::IPCResult RecvLengthReady(const int64_t& aLength) override;
+  mozilla::ipc::IPCResult RecvLengthReady(const int64_t& aLength);
 
   void Shutdown();
 
   void Migrated();
 
  private:
   ~IPCBlobInputStreamChild();
 
--- a/dom/file/ipc/IPCBlobInputStreamParent.h
+++ b/dom/file/ipc/IPCBlobInputStreamParent.h
@@ -44,21 +44,21 @@ class IPCBlobInputStreamParent final
   void ActorDestroy(IProtocol::ActorDestroyReason aReason) override;
 
   const nsID& ID() const { return mID; }
 
   uint64_t Size() const { return mSize; }
 
   void SetCallback(IPCBlobInputStreamParentCallback* aCallback);
 
-  mozilla::ipc::IPCResult RecvStreamNeeded() override;
+  mozilla::ipc::IPCResult RecvStreamNeeded();
 
-  mozilla::ipc::IPCResult RecvLengthNeeded() override;
+  mozilla::ipc::IPCResult RecvLengthNeeded();
 
-  mozilla::ipc::IPCResult RecvClose() override;
+  mozilla::ipc::IPCResult RecvClose();
 
   mozilla::ipc::IPCResult Recv__delete__() override;
 
   bool HasValidStream() const;
 
  private:
   IPCBlobInputStreamParent(const nsID& aID, uint64_t aSize,
                            nsIContentParent* aManager);
--- a/dom/file/ipc/TemporaryIPCBlobChild.h
+++ b/dom/file/ipc/TemporaryIPCBlobChild.h
@@ -33,17 +33,17 @@ class TemporaryIPCBlobChild final
   explicit TemporaryIPCBlobChild(MutableBlobStorage* aMutableBlobStorage);
 
   void AskForBlob(TemporaryIPCBlobChildCallback* aCallback,
                   const nsACString& aContentType, PRFileDesc* aFD);
 
  private:
   ~TemporaryIPCBlobChild();
 
-  mozilla::ipc::IPCResult RecvFileDesc(const FileDescriptor& aFD) override;
+  mozilla::ipc::IPCResult RecvFileDesc(const FileDescriptor& aFD);
 
   mozilla::ipc::IPCResult Recv__delete__(
       const IPCBlobOrError& aBlobOrError) override;
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
   RefPtr<MutableBlobStorage> mMutableBlobStorage;
   RefPtr<TemporaryIPCBlobChildCallback> mCallback;
--- a/dom/file/ipc/TemporaryIPCBlobParent.h
+++ b/dom/file/ipc/TemporaryIPCBlobParent.h
@@ -22,20 +22,20 @@ class TemporaryIPCBlobParent final
  public:
   explicit TemporaryIPCBlobParent();
 
   mozilla::ipc::IPCResult CreateAndShareFile();
 
  private:
   ~TemporaryIPCBlobParent();
 
-  mozilla::ipc::IPCResult RecvOperationFailed() override;
+  mozilla::ipc::IPCResult RecvOperationFailed();
 
   mozilla::ipc::IPCResult RecvOperationDone(const nsCString& aContentType,
-                                            const FileDescriptor& aFD) override;
+                                            const FileDescriptor& aFD);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
   mozilla::ipc::IPCResult SendDeleteError(nsresult aRv);
 
   nsCOMPtr<nsIFile> mFile;
   bool mActive;
 };
--- a/dom/filehandle/ActorsParent.h
+++ b/dom/filehandle/ActorsParent.h
@@ -158,17 +158,17 @@ class BackgroundMutableFileParentBase : 
       const FileMode& aMode);
 
   virtual mozilla::ipc::IPCResult RecvPBackgroundFileHandleConstructor(
       PBackgroundFileHandleParent* aActor, const FileMode& aMode) override;
 
   virtual bool DeallocPBackgroundFileHandleParent(
       PBackgroundFileHandleParent* aActor);
 
-  mozilla::ipc::IPCResult RecvDeleteMe() final;
+  mozilla::ipc::IPCResult RecvDeleteMe();
 
-  mozilla::ipc::IPCResult RecvGetFileId(int64_t* aFileId) override;
+  virtual mozilla::ipc::IPCResult RecvGetFileId(int64_t* aFileId);
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif  // mozilla_dom_filehandle_ActorsParent_h
--- a/dom/gamepad/ipc/GamepadEventChannelChild.h
+++ b/dom/gamepad/ipc/GamepadEventChannelChild.h
@@ -10,20 +10,20 @@
 
 namespace mozilla {
 namespace dom {
 
 class GamepadEventChannelChild final : public PGamepadEventChannelChild {
  public:
   GamepadEventChannelChild() {}
   ~GamepadEventChannelChild() {}
-  virtual mozilla::ipc::IPCResult RecvGamepadUpdate(
-      const GamepadChangeEvent& aGamepadEvent) override;
-  virtual mozilla::ipc::IPCResult RecvReplyGamepadVibrateHaptic(
-      const uint32_t& aPromiseID) override;
+  mozilla::ipc::IPCResult RecvGamepadUpdate(
+      const GamepadChangeEvent& aGamepadEvent);
+  mozilla::ipc::IPCResult RecvReplyGamepadVibrateHaptic(
+      const uint32_t& aPromiseID);
   void AddPromise(const uint32_t& aID, dom::Promise* aPromise);
 
  private:
   nsRefPtrHashtable<nsUint32HashKey, dom::Promise> mPromiseList;
 };
 
 }  // namespace dom
 }  // namespace mozilla
--- a/dom/gamepad/ipc/GamepadEventChannelParent.h
+++ b/dom/gamepad/ipc/GamepadEventChannelParent.h
@@ -11,24 +11,24 @@
 namespace mozilla {
 namespace dom {
 
 class GamepadEventChannelParent final : public PGamepadEventChannelParent {
  public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GamepadEventChannelParent)
   GamepadEventChannelParent();
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
-  virtual mozilla::ipc::IPCResult RecvGamepadListenerAdded() override;
-  virtual mozilla::ipc::IPCResult RecvGamepadListenerRemoved() override;
-  virtual mozilla::ipc::IPCResult RecvVibrateHaptic(
-      const uint32_t& aControllerIdx, const uint32_t& aHapticIndex,
-      const double& aIntensity, const double& aDuration,
-      const uint32_t& aPromiseID) override;
-  virtual mozilla::ipc::IPCResult RecvStopVibrateHaptic(
-      const uint32_t& aGamepadIndex) override;
+  mozilla::ipc::IPCResult RecvGamepadListenerAdded();
+  mozilla::ipc::IPCResult RecvGamepadListenerRemoved();
+  mozilla::ipc::IPCResult RecvVibrateHaptic(const uint32_t& aControllerIdx,
+                                            const uint32_t& aHapticIndex,
+                                            const double& aIntensity,
+                                            const double& aDuration,
+                                            const uint32_t& aPromiseID);
+  mozilla::ipc::IPCResult RecvStopVibrateHaptic(const uint32_t& aGamepadIndex);
   void DispatchUpdateEvent(const GamepadChangeEvent& aEvent);
   bool HasGamepadListener() const { return mHasGamepadListener; }
 
  private:
   ~GamepadEventChannelParent() {}
   bool mHasGamepadListener;
   nsCOMPtr<nsIEventTarget> mBackgroundEventTarget;
 };
--- a/dom/gamepad/ipc/GamepadTestChannelChild.h
+++ b/dom/gamepad/ipc/GamepadTestChannelChild.h
@@ -17,18 +17,18 @@ class GamepadTestChannelChild final : pu
   friend class PGamepadTestChannelChild;
 
  public:
   GamepadTestChannelChild() {}
   ~GamepadTestChannelChild() {}
   void AddPromise(const uint32_t& aID, Promise* aPromise);
 
  private:
-  virtual mozilla::ipc::IPCResult RecvReplyGamepadIndex(
-      const uint32_t& aID, const uint32_t& aIndex) override;
+  mozilla::ipc::IPCResult RecvReplyGamepadIndex(const uint32_t& aID,
+                                                const uint32_t& aIndex);
 
   nsRefPtrHashtable<nsUint32HashKey, dom::Promise> mPromiseList;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif
--- a/dom/gamepad/ipc/GamepadTestChannelParent.h
+++ b/dom/gamepad/ipc/GamepadTestChannelParent.h
@@ -12,19 +12,19 @@
 namespace mozilla {
 namespace dom {
 
 class GamepadTestChannelParent final : public PGamepadTestChannelParent {
  public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GamepadTestChannelParent)
   GamepadTestChannelParent() : mShuttingdown(false) {}
   virtual void ActorDestroy(ActorDestroyReason aWhy) override {}
-  virtual mozilla::ipc::IPCResult RecvGamepadTestEvent(
-      const uint32_t& aID, const GamepadChangeEvent& aGamepadEvent) override;
-  virtual mozilla::ipc::IPCResult RecvShutdownChannel() override;
+  mozilla::ipc::IPCResult RecvGamepadTestEvent(
+      const uint32_t& aID, const GamepadChangeEvent& aGamepadEvent);
+  mozilla::ipc::IPCResult RecvShutdownChannel();
 
  private:
   ~GamepadTestChannelParent() {}
   bool mShuttingdown;
 };
 
 }  // namespace dom
 }  // namespace mozilla
--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -6434,17 +6434,17 @@ class MutableFile : public BackgroundMut
   ~MutableFile() override;
 
   PBackgroundFileHandleParent* AllocPBackgroundFileHandleParent(
       const FileMode& aMode) final;
 
   mozilla::ipc::IPCResult RecvPBackgroundFileHandleConstructor(
       PBackgroundFileHandleParent* aActor, const FileMode& aMode) final;
 
-  mozilla::ipc::IPCResult RecvGetFileId(int64_t* aFileId) final;
+  mozilla::ipc::IPCResult RecvGetFileId(int64_t* aFileId) override;
 };
 
 class FactoryOp : public DatabaseOperationBase,
                   public OpenDirectoryListener,
                   public PBackgroundIDBFactoryRequestParent {
  public:
   struct MaybeBlockedDatabaseInfo;
 
--- a/dom/ipc/ContentBridgeChild.h
+++ b/dom/ipc/ContentBridgeChild.h
@@ -42,19 +42,19 @@ class ContentBridgeChild final : public 
   virtual mozilla::ipc::PFileDescriptorSetChild*
   SendPFileDescriptorSetConstructor(
       const mozilla::ipc::FileDescriptor&) override;
 
   virtual mozilla::ipc::PChildToParentStreamChild*
   SendPChildToParentStreamConstructor(
       mozilla::ipc::PChildToParentStreamChild*) override;
 
-  virtual mozilla::ipc::IPCResult RecvActivate(PBrowserChild* aTab) override;
+  mozilla::ipc::IPCResult RecvActivate(PBrowserChild* aTab);
 
-  virtual mozilla::ipc::IPCResult RecvDeactivate(PBrowserChild* aTab) override;
+  mozilla::ipc::IPCResult RecvDeactivate(PBrowserChild* aTab);
 
   virtual already_AddRefed<nsIEventTarget> GetEventTargetFor(
       TabChild* aTabChild) override;
 
   FORWARD_SHMEM_ALLOCATOR_TO(PContentBridgeChild)
 
  protected:
   virtual ~ContentBridgeChild();
--- a/dom/ipc/ContentChild.h
+++ b/dom/ipc/ContentChild.h
@@ -152,53 +152,52 @@ class ContentChild final : public PConte
 
   ipc::SharedMap* SharedData() { return mSharedData; };
 
   static void AppendProcessId(nsACString& aName);
 
   static void UpdateCookieStatus(nsIChannel* aChannel);
 
   mozilla::ipc::IPCResult RecvInitContentBridgeChild(
-      Endpoint<PContentBridgeChild>&& aEndpoint) override;
+      Endpoint<PContentBridgeChild>&& aEndpoint);
 
   mozilla::ipc::IPCResult RecvInitGMPService(
-      Endpoint<PGMPServiceChild>&& aGMPService) override;
+      Endpoint<PGMPServiceChild>&& aGMPService);
 
   mozilla::ipc::IPCResult RecvInitProfiler(
-      Endpoint<PProfilerChild>&& aEndpoint) override;
+      Endpoint<PProfilerChild>&& aEndpoint);
 
   mozilla::ipc::IPCResult RecvGMPsChanged(
-      nsTArray<GMPCapabilityData>&& capabilities) override;
+      nsTArray<GMPCapabilityData>&& capabilities);
 
   mozilla::ipc::IPCResult RecvInitProcessHangMonitor(
-      Endpoint<PProcessHangMonitorChild>&& aHangMonitor) override;
+      Endpoint<PProcessHangMonitorChild>&& aHangMonitor);
 
   mozilla::ipc::IPCResult RecvInitRendering(
       Endpoint<PCompositorManagerChild>&& aCompositor,
       Endpoint<PImageBridgeChild>&& aImageBridge,
       Endpoint<PVRManagerChild>&& aVRBridge,
       Endpoint<PVideoDecoderManagerChild>&& aVideoManager,
-      nsTArray<uint32_t>&& namespaces) override;
+      nsTArray<uint32_t>&& namespaces);
 
-  mozilla::ipc::IPCResult RecvRequestPerformanceMetrics(
-      const nsID& aID) override;
+  mozilla::ipc::IPCResult RecvRequestPerformanceMetrics(const nsID& aID);
 
   mozilla::ipc::IPCResult RecvReinitRendering(
       Endpoint<PCompositorManagerChild>&& aCompositor,
       Endpoint<PImageBridgeChild>&& aImageBridge,
       Endpoint<PVRManagerChild>&& aVRBridge,
       Endpoint<PVideoDecoderManagerChild>&& aVideoManager,
-      nsTArray<uint32_t>&& namespaces) override;
+      nsTArray<uint32_t>&& namespaces);
 
-  virtual mozilla::ipc::IPCResult RecvAudioDefaultDeviceChange() override;
+  virtual mozilla::ipc::IPCResult RecvAudioDefaultDeviceChange();
 
-  mozilla::ipc::IPCResult RecvReinitRenderingForDeviceReset() override;
+  mozilla::ipc::IPCResult RecvReinitRenderingForDeviceReset();
 
   virtual mozilla::ipc::IPCResult RecvSetProcessSandbox(
-      const MaybeFileDesc& aBroker) override;
+      const MaybeFileDesc& aBroker);
 
   virtual PBrowserChild* AllocPBrowserChild(const TabId& aTabId,
                                             const TabId& aSameTabGroupAs,
                                             const IPCTabContext& aContext,
                                             const uint32_t& aChromeFlags,
                                             const ContentParentId& aCpID,
                                             const bool& aIsForBrowser) override;
 
@@ -298,215 +297,204 @@ class ContentChild final : public PConte
   PMediaChild* AllocPMediaChild();
 
   bool DeallocPMediaChild(PMediaChild* aActor);
 
   PPresentationChild* AllocPPresentationChild();
 
   bool DeallocPPresentationChild(PPresentationChild* aActor);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyPresentationReceiverLaunched(
-      PBrowserChild* aIframe, const nsString& aSessionId) override;
+  mozilla::ipc::IPCResult RecvNotifyPresentationReceiverLaunched(
+      PBrowserChild* aIframe, const nsString& aSessionId);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyPresentationReceiverCleanUp(
-      const nsString& aSessionId) override;
+  mozilla::ipc::IPCResult RecvNotifyPresentationReceiverCleanUp(
+      const nsString& aSessionId);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyEmptyHTTPCache() override;
+  mozilla::ipc::IPCResult RecvNotifyEmptyHTTPCache();
 
   PSpeechSynthesisChild* AllocPSpeechSynthesisChild();
 
   bool DeallocPSpeechSynthesisChild(PSpeechSynthesisChild* aActor);
 
-  virtual mozilla::ipc::IPCResult RecvRegisterChrome(
+  mozilla::ipc::IPCResult RecvRegisterChrome(
       InfallibleTArray<ChromePackage>&& packages,
       InfallibleTArray<SubstitutionMapping>&& resources,
       InfallibleTArray<OverrideMapping>&& overrides, const nsCString& locale,
-      const bool& reset) override;
-  virtual mozilla::ipc::IPCResult RecvRegisterChromeItem(
-      const ChromeRegistryItem& item) override;
+      const bool& reset);
+  mozilla::ipc::IPCResult RecvRegisterChromeItem(
+      const ChromeRegistryItem& item);
 
-  virtual mozilla::ipc::IPCResult RecvClearImageCache(
-      const bool& privateLoader, const bool& chrome) override;
+  mozilla::ipc::IPCResult RecvClearImageCache(const bool& privateLoader,
+                                              const bool& chrome);
 
   virtual mozilla::jsipc::PJavaScriptChild* AllocPJavaScriptChild() override;
 
   virtual bool DeallocPJavaScriptChild(
       mozilla::jsipc::PJavaScriptChild*) override;
 
   PRemoteSpellcheckEngineChild* AllocPRemoteSpellcheckEngineChild();
 
   bool DeallocPRemoteSpellcheckEngineChild(PRemoteSpellcheckEngineChild*);
 
-  virtual mozilla::ipc::IPCResult RecvSetOffline(const bool& offline) override;
+  mozilla::ipc::IPCResult RecvSetOffline(const bool& offline);
+
+  mozilla::ipc::IPCResult RecvSetConnectivity(const bool& connectivity);
+  mozilla::ipc::IPCResult RecvSetCaptivePortalState(const int32_t& state);
 
-  virtual mozilla::ipc::IPCResult RecvSetConnectivity(
-      const bool& connectivity) override;
-  virtual mozilla::ipc::IPCResult RecvSetCaptivePortalState(
-      const int32_t& state) override;
+  mozilla::ipc::IPCResult RecvBidiKeyboardNotify(const bool& isLangRTL,
+                                                 const bool& haveBidiKeyboards);
 
-  virtual mozilla::ipc::IPCResult RecvBidiKeyboardNotify(
-      const bool& isLangRTL, const bool& haveBidiKeyboards) override;
-
-  virtual mozilla::ipc::IPCResult RecvNotifyVisited(
-      nsTArray<URIParams>&& aURIs) override;
+  mozilla::ipc::IPCResult RecvNotifyVisited(nsTArray<URIParams>&& aURIs);
 
   // auto remove when alertfinished is received.
   nsresult AddRemoteAlertObserver(const nsString& aData,
                                   nsIObserver* aObserver);
 
-  virtual mozilla::ipc::IPCResult RecvPreferenceUpdate(
-      const Pref& aPref) override;
-  virtual mozilla::ipc::IPCResult RecvVarUpdate(
-      const GfxVarUpdate& pref) override;
+  mozilla::ipc::IPCResult RecvPreferenceUpdate(const Pref& aPref);
+  mozilla::ipc::IPCResult RecvVarUpdate(const GfxVarUpdate& pref);
 
-  virtual mozilla::ipc::IPCResult RecvDataStoragePut(
-      const nsString& aFilename, const DataStorageItem& aItem) override;
+  mozilla::ipc::IPCResult RecvDataStoragePut(const nsString& aFilename,
+                                             const DataStorageItem& aItem);
 
-  virtual mozilla::ipc::IPCResult RecvDataStorageRemove(
-      const nsString& aFilename, const nsCString& aKey,
-      const DataStorageType& aType) override;
+  mozilla::ipc::IPCResult RecvDataStorageRemove(const nsString& aFilename,
+                                                const nsCString& aKey,
+                                                const DataStorageType& aType);
 
-  virtual mozilla::ipc::IPCResult RecvDataStorageClear(
-      const nsString& aFilename) override;
+  mozilla::ipc::IPCResult RecvDataStorageClear(const nsString& aFilename);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyAlertsObserver(
-      const nsCString& aType, const nsString& aData) override;
+  mozilla::ipc::IPCResult RecvNotifyAlertsObserver(const nsCString& aType,
+                                                   const nsString& aData);
 
-  virtual mozilla::ipc::IPCResult RecvLoadProcessScript(
-      const nsString& aURL) override;
+  virtual mozilla::ipc::IPCResult RecvLoadProcessScript(const nsString& aURL);
 
   virtual mozilla::ipc::IPCResult RecvAsyncMessage(
       const nsString& aMsg, InfallibleTArray<CpowEntry>&& aCpows,
       const IPC::Principal& aPrincipal,
       const ClonedMessageData& aData) override;
 
   mozilla::ipc::IPCResult RecvRegisterStringBundles(
-      nsTArray<StringBundleDescriptor>&& stringBundles) override;
+      nsTArray<StringBundleDescriptor>&& stringBundles);
 
   mozilla::ipc::IPCResult RecvUpdateSharedData(
       const FileDescriptor& aMapFile, const uint32_t& aMapSize,
-      nsTArray<IPCBlob>&& aBlobs, nsTArray<nsCString>&& aChangedKeys) override;
+      nsTArray<IPCBlob>&& aBlobs, nsTArray<nsCString>&& aChangedKeys);
 
-  virtual mozilla::ipc::IPCResult RecvGeolocationUpdate(
-      nsIDOMGeoPosition* aPosition) override;
+  mozilla::ipc::IPCResult RecvGeolocationUpdate(nsIDOMGeoPosition* aPosition);
 
-  virtual mozilla::ipc::IPCResult RecvGeolocationError(
-      const uint16_t& errorCode) override;
+  mozilla::ipc::IPCResult RecvGeolocationError(const uint16_t& errorCode);
 
-  virtual mozilla::ipc::IPCResult RecvUpdateDictionaryList(
-      InfallibleTArray<nsString>&& aDictionaries) override;
+  mozilla::ipc::IPCResult RecvUpdateDictionaryList(
+      InfallibleTArray<nsString>&& aDictionaries);
 
-  virtual mozilla::ipc::IPCResult RecvUpdateFontList(
-      InfallibleTArray<SystemFontListEntry>&& aFontList) override;
+  mozilla::ipc::IPCResult RecvUpdateFontList(
+      InfallibleTArray<SystemFontListEntry>&& aFontList);
 
-  virtual mozilla::ipc::IPCResult RecvUpdateAppLocales(
-      nsTArray<nsCString>&& aAppLocales) override;
-  virtual mozilla::ipc::IPCResult RecvUpdateRequestedLocales(
-      nsTArray<nsCString>&& aRequestedLocales) override;
+  mozilla::ipc::IPCResult RecvUpdateAppLocales(
+      nsTArray<nsCString>&& aAppLocales);
+  mozilla::ipc::IPCResult RecvUpdateRequestedLocales(
+      nsTArray<nsCString>&& aRequestedLocales);
 
-  virtual mozilla::ipc::IPCResult RecvClearSiteDataReloadNeeded(
-      const nsString& aOrigin) override;
+  mozilla::ipc::IPCResult RecvClearSiteDataReloadNeeded(
+      const nsString& aOrigin);
 
-  virtual mozilla::ipc::IPCResult RecvAddPermission(
-      const IPC::Permission& permission) override;
+  mozilla::ipc::IPCResult RecvAddPermission(const IPC::Permission& permission);
 
-  virtual mozilla::ipc::IPCResult RecvRemoveAllPermissions() override;
+  mozilla::ipc::IPCResult RecvRemoveAllPermissions();
+
+  mozilla::ipc::IPCResult RecvFlushMemory(const nsString& reason);
 
-  virtual mozilla::ipc::IPCResult RecvFlushMemory(
-      const nsString& reason) override;
+  mozilla::ipc::IPCResult RecvActivateA11y(const uint32_t& aMainChromeTid,
+                                           const uint32_t& aMsaaID);
+  mozilla::ipc::IPCResult RecvShutdownA11y();
 
-  virtual mozilla::ipc::IPCResult RecvActivateA11y(
-      const uint32_t& aMainChromeTid, const uint32_t& aMsaaID) override;
-  virtual mozilla::ipc::IPCResult RecvShutdownA11y() override;
+  mozilla::ipc::IPCResult RecvGarbageCollect();
+  mozilla::ipc::IPCResult RecvCycleCollect();
+  mozilla::ipc::IPCResult RecvUnlinkGhosts();
 
-  virtual mozilla::ipc::IPCResult RecvGarbageCollect() override;
-  virtual mozilla::ipc::IPCResult RecvCycleCollect() override;
-  virtual mozilla::ipc::IPCResult RecvUnlinkGhosts() override;
-
-  virtual mozilla::ipc::IPCResult RecvAppInfo(
+  mozilla::ipc::IPCResult RecvAppInfo(
       const nsCString& version, const nsCString& buildID, const nsCString& name,
       const nsCString& UAName, const nsCString& ID, const nsCString& vendor,
-      const nsCString& sourceURL) override;
+      const nsCString& sourceURL);
 
-  virtual mozilla::ipc::IPCResult RecvRemoteType(
-      const nsString& aRemoteType) override;
+  mozilla::ipc::IPCResult RecvRemoteType(const nsString& aRemoteType);
 
   const nsAString& GetRemoteType() const;
 
-  virtual mozilla::ipc::IPCResult RecvInitServiceWorkers(
-      const ServiceWorkerConfiguration& aConfig) override;
+  mozilla::ipc::IPCResult RecvInitServiceWorkers(
+      const ServiceWorkerConfiguration& aConfig);
 
-  virtual mozilla::ipc::IPCResult RecvInitBlobURLs(
-      nsTArray<BlobURLRegistrationData>&& aRegistations) override;
+  mozilla::ipc::IPCResult RecvInitBlobURLs(
+      nsTArray<BlobURLRegistrationData>&& aRegistations);
 
-  virtual mozilla::ipc::IPCResult RecvInitJSWindowActorInfos(
-      nsTArray<JSWindowActorInfo>&& aInfos) override;
+  mozilla::ipc::IPCResult RecvInitJSWindowActorInfos(
+      nsTArray<JSWindowActorInfo>&& aInfos);
 
-  virtual mozilla::ipc::IPCResult RecvLastPrivateDocShellDestroyed() override;
+  mozilla::ipc::IPCResult RecvLastPrivateDocShellDestroyed();
 
-  virtual mozilla::ipc::IPCResult RecvNotifyProcessPriorityChanged(
-      const hal::ProcessPriority& aPriority) override;
+  mozilla::ipc::IPCResult RecvNotifyProcessPriorityChanged(
+      const hal::ProcessPriority& aPriority);
 
-  virtual mozilla::ipc::IPCResult RecvMinimizeMemoryUsage() override;
+  mozilla::ipc::IPCResult RecvMinimizeMemoryUsage();
 
-  virtual mozilla::ipc::IPCResult RecvLoadAndRegisterSheet(
-      const URIParams& aURI, const uint32_t& aType) override;
+  mozilla::ipc::IPCResult RecvLoadAndRegisterSheet(const URIParams& aURI,
+                                                   const uint32_t& aType);
 
-  virtual mozilla::ipc::IPCResult RecvUnregisterSheet(
-      const URIParams& aURI, const uint32_t& aType) override;
+  mozilla::ipc::IPCResult RecvUnregisterSheet(const URIParams& aURI,
+                                              const uint32_t& aType);
 
   void AddIdleObserver(nsIObserver* aObserver, uint32_t aIdleTimeInS);
 
   void RemoveIdleObserver(nsIObserver* aObserver, uint32_t aIdleTimeInS);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyIdleObserver(
-      const uint64_t& aObserver, const nsCString& aTopic,
-      const nsString& aData) override;
+  mozilla::ipc::IPCResult RecvNotifyIdleObserver(const uint64_t& aObserver,
+                                                 const nsCString& aTopic,
+                                                 const nsString& aData);
 
-  virtual mozilla::ipc::IPCResult RecvUpdateWindow(
-      const uintptr_t& aChildId) override;
+  mozilla::ipc::IPCResult RecvUpdateWindow(const uintptr_t& aChildId);
 
-  virtual mozilla::ipc::IPCResult RecvDomainSetChanged(
+  mozilla::ipc::IPCResult RecvDomainSetChanged(
       const uint32_t& aSetType, const uint32_t& aChangeType,
-      const OptionalURIParams& aDomain) override;
+      const OptionalURIParams& aDomain);
 
-  virtual mozilla::ipc::IPCResult RecvShutdown() override;
+  mozilla::ipc::IPCResult RecvShutdown();
 
-  virtual mozilla::ipc::IPCResult RecvInvokeDragSession(
-      nsTArray<IPCDataTransfer>&& aTransfers, const uint32_t& aAction) override;
+  mozilla::ipc::IPCResult RecvInvokeDragSession(
+      nsTArray<IPCDataTransfer>&& aTransfers, const uint32_t& aAction);
 
-  virtual mozilla::ipc::IPCResult RecvEndDragSession(
+  mozilla::ipc::IPCResult RecvEndDragSession(
       const bool& aDoneDrag, const bool& aUserCancelled,
       const mozilla::LayoutDeviceIntPoint& aEndDragPoint,
-      const uint32_t& aKeyModifiers) override;
+      const uint32_t& aKeyModifiers);
 
-  virtual mozilla::ipc::IPCResult RecvPush(const nsCString& aScope,
+  mozilla::ipc::IPCResult RecvPush(const nsCString& aScope,
+                                   const IPC::Principal& aPrincipal,
+                                   const nsString& aMessageId);
+
+  mozilla::ipc::IPCResult RecvPushWithData(const nsCString& aScope,
                                            const IPC::Principal& aPrincipal,
-                                           const nsString& aMessageId) override;
-
-  virtual mozilla::ipc::IPCResult RecvPushWithData(
-      const nsCString& aScope, const IPC::Principal& aPrincipal,
-      const nsString& aMessageId, InfallibleTArray<uint8_t>&& aData) override;
+                                           const nsString& aMessageId,
+                                           InfallibleTArray<uint8_t>&& aData);
 
-  virtual mozilla::ipc::IPCResult RecvPushSubscriptionChange(
-      const nsCString& aScope, const IPC::Principal& aPrincipal) override;
-
-  virtual mozilla::ipc::IPCResult RecvPushError(
-      const nsCString& aScope, const IPC::Principal& aPrincipal,
-      const nsString& aMessage, const uint32_t& aFlags) override;
+  mozilla::ipc::IPCResult RecvPushSubscriptionChange(
+      const nsCString& aScope, const IPC::Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyPushSubscriptionModifiedObservers(
-      const nsCString& aScope, const IPC::Principal& aPrincipal) override;
+  mozilla::ipc::IPCResult RecvPushError(const nsCString& aScope,
+                                        const IPC::Principal& aPrincipal,
+                                        const nsString& aMessage,
+                                        const uint32_t& aFlags);
 
-  virtual mozilla::ipc::IPCResult RecvActivate(PBrowserChild* aTab) override;
+  mozilla::ipc::IPCResult RecvNotifyPushSubscriptionModifiedObservers(
+      const nsCString& aScope, const IPC::Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvDeactivate(PBrowserChild* aTab) override;
+  mozilla::ipc::IPCResult RecvActivate(PBrowserChild* aTab);
+
+  mozilla::ipc::IPCResult RecvDeactivate(PBrowserChild* aTab);
 
   mozilla::ipc::IPCResult RecvRefreshScreens(
-      nsTArray<ScreenDetails>&& aScreens) override;
+      nsTArray<ScreenDetails>&& aScreens);
 
   // Get the directory for IndexedDB files. We query the parent for this and
   // cache the value
   nsString& GetIndexedDBPath();
 
   ContentParentId GetID() const { return mID; }
 
 #if defined(XP_WIN) && defined(ACCESSIBILITY)
@@ -557,76 +545,74 @@ class ContentChild final : public PConte
       const InfallibleTArray<PermissionRequest>& aRequests,
       const IPC::Principal& aPrincipal,
       const IPC::Principal& aTopLevelPrincipal,
       const bool& aIsHandlingUserInput, const TabId& aTabId);
   bool DeallocPContentPermissionRequestChild(
       PContentPermissionRequestChild* actor);
 
   // Windows specific - set up audio session
-  virtual mozilla::ipc::IPCResult RecvSetAudioSessionData(
-      const nsID& aId, const nsString& aDisplayName,
-      const nsString& aIconPath) override;
+  mozilla::ipc::IPCResult RecvSetAudioSessionData(const nsID& aId,
+                                                  const nsString& aDisplayName,
+                                                  const nsString& aIconPath);
 
   // GetFiles for WebKit/Blink FileSystem API and Directory API must run on the
   // parent process.
   void CreateGetFilesRequest(const nsAString& aDirectoryPath,
                              bool aRecursiveFlag, nsID& aUUID,
                              GetFilesHelperChild* aChild);
 
   void DeleteGetFilesRequest(nsID& aUUID, GetFilesHelperChild* aChild);
 
-  virtual mozilla::ipc::IPCResult RecvGetFilesResponse(
-      const nsID& aUUID, const GetFilesResponseResult& aResult) override;
+  mozilla::ipc::IPCResult RecvGetFilesResponse(
+      const nsID& aUUID, const GetFilesResponseResult& aResult);
 
-  virtual mozilla::ipc::IPCResult RecvBlobURLRegistration(
+  mozilla::ipc::IPCResult RecvBlobURLRegistration(
       const nsCString& aURI, const IPCBlob& aBlob,
-      const IPC::Principal& aPrincipal) override;
+      const IPC::Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvBlobURLUnregistration(
-      const nsCString& aURI) override;
+  mozilla::ipc::IPCResult RecvBlobURLUnregistration(const nsCString& aURI);
 
-  virtual mozilla::ipc::IPCResult RecvFileCreationResponse(
-      const nsID& aUUID, const FileCreationResult& aResult) override;
+  mozilla::ipc::IPCResult RecvFileCreationResponse(
+      const nsID& aUUID, const FileCreationResult& aResult);
 
   mozilla::ipc::IPCResult RecvRequestMemoryReport(
       const uint32_t& generation, const bool& anonymize,
-      const bool& minimizeMemoryUsage, const MaybeFileDesc& DMDFile) override;
+      const bool& minimizeMemoryUsage, const MaybeFileDesc& DMDFile);
 
-  virtual mozilla::ipc::IPCResult RecvSetXPCOMProcessAttributes(
+  mozilla::ipc::IPCResult RecvSetXPCOMProcessAttributes(
       const XPCOMInitData& aXPCOMInit, const StructuredCloneData& aInitialData,
       nsTArray<LookAndFeelInt>&& aLookAndFeelIntCache,
-      nsTArray<SystemFontListEntry>&& aFontList) override;
+      nsTArray<SystemFontListEntry>&& aFontList);
 
-  virtual mozilla::ipc::IPCResult RecvProvideAnonymousTemporaryFile(
-      const uint64_t& aID, const FileDescOrError& aFD) override;
+  mozilla::ipc::IPCResult RecvProvideAnonymousTemporaryFile(
+      const uint64_t& aID, const FileDescOrError& aFD);
 
   mozilla::ipc::IPCResult RecvSetPermissionsWithKey(
-      const nsCString& aPermissionKey,
-      nsTArray<IPC::Permission>&& aPerms) override;
+      const nsCString& aPermissionKey, nsTArray<IPC::Permission>&& aPerms);
+
+  mozilla::ipc::IPCResult RecvShareCodeCoverageMutex(
+      const CrossProcessMutexHandle& aHandle);
 
-  virtual mozilla::ipc::IPCResult RecvShareCodeCoverageMutex(
-      const CrossProcessMutexHandle& aHandle) override;
+  mozilla::ipc::IPCResult RecvFlushCodeCoverageCounters(
+      FlushCodeCoverageCountersResolver&& aResolver);
 
-  virtual mozilla::ipc::IPCResult RecvFlushCodeCoverageCounters(
-      FlushCodeCoverageCountersResolver&& aResolver) override;
+  mozilla::ipc::IPCResult RecvGetMemoryUniqueSetSize(
+      GetMemoryUniqueSetSizeResolver&& aResolver);
 
-  virtual mozilla::ipc::IPCResult RecvGetMemoryUniqueSetSize(
-      GetMemoryUniqueSetSizeResolver&& aResolver) override;
+  mozilla::ipc::IPCResult RecvSetInputEventQueueEnabled();
 
-  virtual mozilla::ipc::IPCResult RecvSetInputEventQueueEnabled() override;
-
-  virtual mozilla::ipc::IPCResult RecvFlushInputEventQueue() override;
+  mozilla::ipc::IPCResult RecvFlushInputEventQueue();
 
-  virtual mozilla::ipc::IPCResult RecvSuspendInputEventQueue() override;
+  mozilla::ipc::IPCResult RecvSuspendInputEventQueue();
 
-  virtual mozilla::ipc::IPCResult RecvResumeInputEventQueue() override;
+  mozilla::ipc::IPCResult RecvResumeInputEventQueue();
 
-  virtual mozilla::ipc::IPCResult RecvAddDynamicScalars(
-      nsTArray<DynamicScalarDefinition>&& aDefs) override;
+  mozilla::ipc::IPCResult RecvAddDynamicScalars(
+      nsTArray<DynamicScalarDefinition>&& aDefs);
 
 #if defined(XP_WIN) && defined(ACCESSIBILITY)
   bool SendGetA11yContentId();
 #endif  // defined(XP_WIN) && defined(ACCESSIBILITY)
 
   // Get a reference to the font list passed from the chrome process,
   // for use during gfx initialization.
   InfallibleTArray<mozilla::dom::SystemFontListEntry>& SystemFontList() {
@@ -670,35 +656,34 @@ class ContentChild final : public PConte
   nsresult AsyncOpenAnonymousTemporaryFile(
       const AnonymousTemporaryFileCallback& aCallback);
 
   virtual already_AddRefed<nsIEventTarget> GetEventTargetFor(
       TabChild* aTabChild) override;
 
   mozilla::ipc::IPCResult RecvSetPluginList(
       const uint32_t& aPluginEpoch, nsTArray<PluginTag>&& aPluginTags,
-      nsTArray<FakePluginTag>&& aFakePluginTags) override;
+      nsTArray<FakePluginTag>&& aFakePluginTags);
 
   PClientOpenWindowOpChild* AllocPClientOpenWindowOpChild(
       const ClientOpenWindowArgs& aArgs);
 
-  virtual mozilla::ipc::IPCResult RecvPClientOpenWindowOpConstructor(
+  mozilla::ipc::IPCResult RecvPClientOpenWindowOpConstructor(
       PClientOpenWindowOpChild* aActor,
       const ClientOpenWindowArgs& aArgs) override;
 
   bool DeallocPClientOpenWindowOpChild(PClientOpenWindowOpChild* aActor);
 
-  mozilla::ipc::IPCResult RecvSaveRecording(
-      const FileDescriptor& aFile) override;
+  mozilla::ipc::IPCResult RecvSaveRecording(const FileDescriptor& aFile);
 
-  virtual mozilla::ipc::IPCResult RecvCrossProcessRedirect(
+  mozilla::ipc::IPCResult RecvCrossProcessRedirect(
       const uint32_t& aRegistrarId, nsIURI* aURI, const uint32_t& aNewLoadFlags,
       const OptionalLoadInfoArgs& aLoadInfoForwarder,
       const uint64_t& aChannelId, nsIURI* aOriginalURI,
-      const uint64_t& aIdentifier) override;
+      const uint64_t& aIdentifier);
 
 #ifdef NIGHTLY_BUILD
   // Fetch the current number of pending input events.
   //
   // NOTE: This method performs an atomic read, and is safe to call from all
   // threads.
   uint32_t GetPendingInputEvents() { return mPendingInputEvents; }
 #endif
@@ -719,25 +704,23 @@ class ContentChild final : public PConte
   virtual already_AddRefed<nsIEventTarget> GetConstructedEventTarget(
       const Message& aMsg) override;
 
   virtual already_AddRefed<nsIEventTarget> GetSpecificMessageEventTarget(
       const Message& aMsg) override;
 
   virtual void OnChannelReceivedMessage(const Message& aMsg) override;
 
-  virtual mozilla::ipc::IPCResult RecvWindowClose(
-      const BrowsingContextId& aContextId, const bool& aTrustedCaller) override;
-  virtual mozilla::ipc::IPCResult RecvWindowFocus(
-      const BrowsingContextId& aContextId) override;
-  virtual mozilla::ipc::IPCResult RecvWindowBlur(
-      const BrowsingContextId& aContextId) override;
-  virtual mozilla::ipc::IPCResult RecvWindowPostMessage(
+  mozilla::ipc::IPCResult RecvWindowClose(const BrowsingContextId& aContextId,
+                                          const bool& aTrustedCaller);
+  mozilla::ipc::IPCResult RecvWindowFocus(const BrowsingContextId& aContextId);
+  mozilla::ipc::IPCResult RecvWindowBlur(const BrowsingContextId& aContextId);
+  mozilla::ipc::IPCResult RecvWindowPostMessage(
       const BrowsingContextId& aContextId, const ClonedMessageData& aMessage,
-      const PostMessageData& aData) override;
+      const PostMessageData& aData);
 
 #ifdef NIGHTLY_BUILD
   virtual PContentChild::Result OnMessageReceived(const Message& aMsg) override;
 #else
   using PContentChild::OnMessageReceived;
 #endif
 
   virtual PContentChild::Result OnMessageReceived(const Message& aMsg,
--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -272,51 +272,49 @@ class ContentParent final : public PCont
    *           this plugin window.
    */
   static void SendAsyncUpdate(nsIWidget* aWidget);
 #endif
 
   // Let managees query if it is safe to send messages.
   bool IsDestroyed() const { return !mIPCOpen; }
 
-  virtual mozilla::ipc::IPCResult RecvCreateChildProcess(
+  mozilla::ipc::IPCResult RecvCreateChildProcess(
       const IPCTabContext& aContext, const hal::ProcessPriority& aPriority,
       const TabId& aOpenerTabId, const TabId& aTabId, ContentParentId* aCpId,
-      bool* aIsForBrowser) override;
+      bool* aIsForBrowser);
 
-  virtual mozilla::ipc::IPCResult RecvBridgeToChildProcess(
-      const ContentParentId& aCpId,
-      Endpoint<PContentBridgeParent>* aEndpoint) override;
+  mozilla::ipc::IPCResult RecvBridgeToChildProcess(
+      const ContentParentId& aCpId, Endpoint<PContentBridgeParent>* aEndpoint);
 
-  virtual mozilla::ipc::IPCResult RecvOpenRecordReplayChannel(
-      const uint32_t& channelId, FileDescriptor* connection) override;
-  virtual mozilla::ipc::IPCResult RecvCreateReplayingProcess(
-      const uint32_t& aChannelId) override;
+  mozilla::ipc::IPCResult RecvOpenRecordReplayChannel(
+      const uint32_t& channelId, FileDescriptor* connection);
+  mozilla::ipc::IPCResult RecvCreateReplayingProcess(
+      const uint32_t& aChannelId);
 
-  virtual mozilla::ipc::IPCResult RecvCreateGMPService() override;
+  mozilla::ipc::IPCResult RecvCreateGMPService();
 
-  virtual mozilla::ipc::IPCResult RecvLoadPlugin(
+  mozilla::ipc::IPCResult RecvLoadPlugin(
       const uint32_t& aPluginId, nsresult* aRv, uint32_t* aRunID,
-      Endpoint<PPluginModuleParent>* aEndpoint) override;
+      Endpoint<PPluginModuleParent>* aEndpoint);
 
-  virtual mozilla::ipc::IPCResult RecvMaybeReloadPlugins() override;
+  mozilla::ipc::IPCResult RecvMaybeReloadPlugins();
 
-  virtual mozilla::ipc::IPCResult RecvConnectPluginBridge(
+  mozilla::ipc::IPCResult RecvConnectPluginBridge(
       const uint32_t& aPluginId, nsresult* aRv,
-      Endpoint<PPluginModuleParent>* aEndpoint) override;
+      Endpoint<PPluginModuleParent>* aEndpoint);
 
-  virtual mozilla::ipc::IPCResult RecvLaunchRDDProcess(
-      nsresult* aRv, Endpoint<PRemoteDecoderManagerChild>* aEndpoint) override;
+  mozilla::ipc::IPCResult RecvLaunchRDDProcess(
+      nsresult* aRv, Endpoint<PRemoteDecoderManagerChild>* aEndpoint);
 
-  virtual mozilla::ipc::IPCResult RecvUngrabPointer(
-      const uint32_t& aTime) override;
+  mozilla::ipc::IPCResult RecvUngrabPointer(const uint32_t& aTime);
 
-  virtual mozilla::ipc::IPCResult RecvRemovePermission(
-      const IPC::Principal& aPrincipal, const nsCString& aPermissionType,
-      nsresult* aRv) override;
+  mozilla::ipc::IPCResult RecvRemovePermission(const IPC::Principal& aPrincipal,
+                                               const nsCString& aPermissionType,
+                                               nsresult* aRv);
 
   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(ContentParent, nsIObserver)
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_NSIOBSERVER
   NS_DECL_NSIDOMGEOPOSITIONCALLBACK
   NS_DECL_NSIDOMGEOPOSITIONERRORCALLBACK
   NS_DECL_NSIINTERFACEREQUESTOR
@@ -399,18 +397,18 @@ class ContentParent final : public PCont
    * about this name: It might not be unique, apps can spoof special names,
    * etc.  So please don't use this name to make any decisions about the
    * ContentParent based on the value returned here.
    */
   void FriendlyName(nsAString& aName, bool aAnonymize = false);
 
   virtual void OnChannelError() override;
 
-  virtual mozilla::ipc::IPCResult RecvInitCrashReporter(
-      Shmem&& aShmem, const NativeThreadId& aThreadId) override;
+  mozilla::ipc::IPCResult RecvInitCrashReporter(
+      Shmem&& aShmem, const NativeThreadId& aThreadId);
 
   PNeckoParent* AllocPNeckoParent();
 
   virtual mozilla::ipc::IPCResult RecvPNeckoConstructor(
       PNeckoParent* aActor) override {
     return PContentParent::RecvPNeckoConstructor(aActor);
   }
 
@@ -420,19 +418,19 @@ class ContentParent final : public PCont
 
 #if defined(NS_PRINTING)
   /**
    * @return the PrintingParent for this ContentParent.
    */
   already_AddRefed<embedding::PrintingParent> GetPrintingParent();
 #endif
 
-  virtual mozilla::ipc::IPCResult RecvInitStreamFilter(
+  mozilla::ipc::IPCResult RecvInitStreamFilter(
       const uint64_t& aChannelId, const nsString& aAddonId,
-      InitStreamFilterResolver&& aResolver) override;
+      InitStreamFilterResolver&& aResolver);
 
   virtual PChildToParentStreamParent* AllocPChildToParentStreamParent()
       override;
   virtual bool DeallocPChildToParentStreamParent(
       PChildToParentStreamParent* aActor) override;
 
   virtual PParentToChildStreamParent* SendPParentToChildStreamConstructor(
       PParentToChildStreamParent*) override;
@@ -458,103 +456,99 @@ class ContentParent final : public PCont
 
   virtual mozilla::ipc::IPCResult RecvPJavaScriptConstructor(
       PJavaScriptParent* aActor) override {
     return PContentParent::RecvPJavaScriptConstructor(aActor);
   }
 
   PRemoteSpellcheckEngineParent* AllocPRemoteSpellcheckEngineParent();
 
-  virtual mozilla::ipc::IPCResult RecvRecordingDeviceEvents(
+  mozilla::ipc::IPCResult RecvRecordingDeviceEvents(
       const nsString& aRecordingStatus, const nsString& aPageURL,
-      const bool& aIsAudio, const bool& aIsVideo) override;
+      const bool& aIsAudio, const bool& aIsVideo);
 
   bool CycleCollectWithLogs(bool aDumpAllTraces,
                             nsICycleCollectorLogSink* aSink,
                             nsIDumpGCAndCCLogsCallback* aCallback);
 
-  virtual mozilla::ipc::IPCResult RecvUnregisterRemoteFrame(
+  mozilla::ipc::IPCResult RecvUnregisterRemoteFrame(
       const TabId& aTabId, const ContentParentId& aCpId,
-      const bool& aMarkedDestroying) override;
+      const bool& aMarkedDestroying);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyTabDestroying(
-      const TabId& aTabId, const ContentParentId& aCpId) override;
+  mozilla::ipc::IPCResult RecvNotifyTabDestroying(const TabId& aTabId,
+                                                  const ContentParentId& aCpId);
 
   nsTArray<TabContext> GetManagedTabContext();
 
   POfflineCacheUpdateParent* AllocPOfflineCacheUpdateParent(
       const URIParams& aManifestURI, const URIParams& aDocumentURI,
       const PrincipalInfo& aLoadingPrincipalInfo, const bool& aStickDocument);
 
   virtual mozilla::ipc::IPCResult RecvPOfflineCacheUpdateConstructor(
       POfflineCacheUpdateParent* aActor, const URIParams& aManifestURI,
       const URIParams& aDocumentURI, const PrincipalInfo& aLoadingPrincipal,
       const bool& stickDocument) override;
 
   bool DeallocPOfflineCacheUpdateParent(POfflineCacheUpdateParent* aActor);
 
   mozilla::ipc::IPCResult RecvSetOfflinePermission(
-      const IPC::Principal& principal) override;
+      const IPC::Principal& principal);
 
-  virtual mozilla::ipc::IPCResult RecvFinishShutdown() override;
+  mozilla::ipc::IPCResult RecvFinishShutdown();
 
   void MaybeInvokeDragSession(TabParent* aParent);
 
   PContentPermissionRequestParent* AllocPContentPermissionRequestParent(
       const InfallibleTArray<PermissionRequest>& aRequests,
       const IPC::Principal& aPrincipal,
       const IPC::Principal& aTopLevelPrincipal, const bool& aIsTrusted,
       const TabId& aTabId);
 
   bool DeallocPContentPermissionRequestParent(
       PContentPermissionRequestParent* actor);
 
   virtual bool HandleWindowsMessages(const Message& aMsg) const override;
 
   void ForkNewProcess(bool aBlocking);
 
-  virtual mozilla::ipc::IPCResult RecvCreateWindow(
+  mozilla::ipc::IPCResult RecvCreateWindow(
       PBrowserParent* aThisTabParent, PBrowserParent* aNewTab,
       const uint32_t& aChromeFlags, const bool& aCalledFromJS,
       const bool& aPositionSpecified, const bool& aSizeSpecified,
       const OptionalURIParams& aURIToLoad, const nsCString& aFeatures,
       const nsCString& aBaseURI, const float& aFullZoom,
       const IPC::Principal& aTriggeringPrincipal,
-      const uint32_t& aReferrerPolicy,
-      CreateWindowResolver&& aResolve) override;
+      const uint32_t& aReferrerPolicy, CreateWindowResolver&& aResolve);
 
-  virtual mozilla::ipc::IPCResult RecvCreateWindowInDifferentProcess(
+  mozilla::ipc::IPCResult RecvCreateWindowInDifferentProcess(
       PBrowserParent* aThisTab, const uint32_t& aChromeFlags,
       const bool& aCalledFromJS, const bool& aPositionSpecified,
       const bool& aSizeSpecified, const OptionalURIParams& aURIToLoad,
       const nsCString& aFeatures, const nsCString& aBaseURI,
       const float& aFullZoom, const nsString& aName,
       const IPC::Principal& aTriggeringPrincipal,
-      const uint32_t& aReferrerPolicy) override;
+      const uint32_t& aReferrerPolicy);
 
   static void BroadcastBlobURLRegistration(
       const nsACString& aURI, BlobImpl* aBlobImpl, nsIPrincipal* aPrincipal,
       ContentParent* aIgnoreThisCP = nullptr);
 
   static void BroadcastBlobURLUnregistration(
       const nsACString& aURI, ContentParent* aIgnoreThisCP = nullptr);
 
-  virtual mozilla::ipc::IPCResult RecvStoreAndBroadcastBlobURLRegistration(
-      const nsCString& aURI, const IPCBlob& aBlob,
-      const Principal& aPrincipal) override;
-
-  virtual mozilla::ipc::IPCResult RecvUnstoreAndBroadcastBlobURLUnregistration(
-      const nsCString& aURI) override;
+  mozilla::ipc::IPCResult RecvStoreAndBroadcastBlobURLRegistration(
+      const nsCString& aURI, const IPCBlob& aBlob, const Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvGetA11yContentId(
-      uint32_t* aContentId) override;
+  mozilla::ipc::IPCResult RecvUnstoreAndBroadcastBlobURLUnregistration(
+      const nsCString& aURI);
 
-  virtual mozilla::ipc::IPCResult RecvA11yHandlerControl(
-      const uint32_t& aPid,
-      const IHandlerControlHolder& aHandlerControl) override;
+  mozilla::ipc::IPCResult RecvGetA11yContentId(uint32_t* aContentId);
+
+  mozilla::ipc::IPCResult RecvA11yHandlerControl(
+      const uint32_t& aPid, const IHandlerControlHolder& aHandlerControl);
 
   virtual int32_t Pid() const override;
 
   // PURLClassifierParent.
   PURLClassifierParent* AllocPURLClassifierParent(const Principal& aPrincipal,
                                                   bool* aSuccess);
   virtual mozilla::ipc::IPCResult RecvPURLClassifierConstructor(
       PURLClassifierParent* aActor, const Principal& aPrincipal,
@@ -610,40 +604,38 @@ class ContentParent final : public PCont
   static hal::ProcessPriority GetInitialProcessPriority(Element* aFrameElement);
 
   // Control the priority of the IPC messages for input events.
   void SetInputPriorityEventEnabled(bool aEnabled);
   bool IsInputPriorityEventEnabled() { return mIsInputPriorityEventEnabled; }
 
   static bool IsInputEventQueueSupported();
 
-  virtual mozilla::ipc::IPCResult RecvAttachBrowsingContext(
+  mozilla::ipc::IPCResult RecvAttachBrowsingContext(
       const BrowsingContextId& aParentContextId,
       const BrowsingContextId& aOpenerId, const BrowsingContextId& aContextId,
-      const nsString& aName) override;
+      const nsString& aName);
 
-  virtual mozilla::ipc::IPCResult RecvDetachBrowsingContext(
-      const BrowsingContextId& aContextId, const bool& aMoveToBFCache) override;
+  mozilla::ipc::IPCResult RecvDetachBrowsingContext(
+      const BrowsingContextId& aContextId, const bool& aMoveToBFCache);
 
-  virtual mozilla::ipc::IPCResult RecvSetOpenerBrowsingContext(
+  mozilla::ipc::IPCResult RecvSetOpenerBrowsingContext(
       const BrowsingContextId& aContextId,
-      const BrowsingContextId& aOpenerContextId) override;
+      const BrowsingContextId& aOpenerContextId);
 
-  virtual mozilla::ipc::IPCResult RecvWindowClose(
-      const BrowsingContextId& aContextId, const bool& aTrustedCaller) override;
-  virtual mozilla::ipc::IPCResult RecvWindowFocus(
-      const BrowsingContextId& aContextId) override;
-  virtual mozilla::ipc::IPCResult RecvWindowBlur(
-      const BrowsingContextId& aContextId) override;
-  virtual mozilla::ipc::IPCResult RecvWindowPostMessage(
+  mozilla::ipc::IPCResult RecvWindowClose(const BrowsingContextId& aContextId,
+                                          const bool& aTrustedCaller);
+  mozilla::ipc::IPCResult RecvWindowFocus(const BrowsingContextId& aContextId);
+  mozilla::ipc::IPCResult RecvWindowBlur(const BrowsingContextId& aContextId);
+  mozilla::ipc::IPCResult RecvWindowPostMessage(
       const BrowsingContextId& aContextId, const ClonedMessageData& aMessage,
-      const PostMessageData& aData) override;
+      const PostMessageData& aData);
 
-  virtual mozilla::ipc::IPCResult RecvSetUserGestureActivation(
-      const BrowsingContextId& aContextId, const bool& aNewValue) override;
+  mozilla::ipc::IPCResult RecvSetUserGestureActivation(
+      const BrowsingContextId& aContextId, const bool& aNewValue);
 
  protected:
   void OnChannelConnected(int32_t pid) override;
 
   virtual void ActorDestroy(ActorDestroyReason why) override;
 
   bool ShouldContinueFromReplyTimeout() override;
 
@@ -820,25 +812,23 @@ class ContentParent final : public PCont
 
   /**
    * Get or create the corresponding content parent array to
    * |aContentProcessType|.
    */
   static nsTArray<ContentParent*>& GetOrCreatePool(
       const nsAString& aContentProcessType);
 
-  virtual mozilla::ipc::IPCResult RecvInitBackground(
-      Endpoint<mozilla::ipc::PBackgroundParent>&& aEndpoint) override;
+  mozilla::ipc::IPCResult RecvInitBackground(
+      Endpoint<mozilla::ipc::PBackgroundParent>&& aEndpoint);
 
-  mozilla::ipc::IPCResult RecvAddMemoryReport(
-      const MemoryReport& aReport) override;
-  mozilla::ipc::IPCResult RecvFinishMemoryReport(
-      const uint32_t& aGeneration) override;
+  mozilla::ipc::IPCResult RecvAddMemoryReport(const MemoryReport& aReport);
+  mozilla::ipc::IPCResult RecvFinishMemoryReport(const uint32_t& aGeneration);
   mozilla::ipc::IPCResult RecvAddPerformanceMetrics(
-      const nsID& aID, nsTArray<PerformanceInfo>&& aMetrics) override;
+      const nsID& aID, nsTArray<PerformanceInfo>&& aMetrics);
 
   virtual bool DeallocPJavaScriptParent(
       mozilla::jsipc::PJavaScriptParent*) override;
 
   bool DeallocPRemoteSpellcheckEngineParent(PRemoteSpellcheckEngineParent*);
 
   virtual PBrowserParent* AllocPBrowserParent(
       const TabId& aTabId, const TabId& aSameTabGroupAs,
@@ -857,23 +847,23 @@ class ContentParent final : public PCont
       const uint64_t& aSize) override;
 
   virtual PIPCBlobInputStreamParent* AllocPIPCBlobInputStreamParent(
       const nsID& aID, const uint64_t& aSize) override;
 
   virtual bool DeallocPIPCBlobInputStreamParent(
       PIPCBlobInputStreamParent* aActor) override;
 
-  virtual mozilla::ipc::IPCResult RecvIsSecureURI(
+  mozilla::ipc::IPCResult RecvIsSecureURI(
       const uint32_t& aType, const URIParams& aURI, const uint32_t& aFlags,
-      const OriginAttributes& aOriginAttributes, bool* aIsSecureURI) override;
+      const OriginAttributes& aOriginAttributes, bool* aIsSecureURI);
 
-  virtual mozilla::ipc::IPCResult RecvAccumulateMixedContentHSTS(
+  mozilla::ipc::IPCResult RecvAccumulateMixedContentHSTS(
       const URIParams& aURI, const bool& aActive,
-      const OriginAttributes& aOriginAttributes) override;
+      const OriginAttributes& aOriginAttributes);
 
   bool DeallocPHalParent(PHalParent*);
 
   bool DeallocPHeapSnapshotTempFileHelperParent(
       PHeapSnapshotTempFileHelperParent*);
 
   PCycleCollectWithLogsParent* AllocPCycleCollectWithLogsParent(
       const bool& aDumpAllTraces, const FileDescriptor& aGCLog,
@@ -931,262 +921,248 @@ class ContentParent final : public PCont
       PSpeechSynthesisParent* aActor) override;
 
   PWebBrowserPersistDocumentParent* AllocPWebBrowserPersistDocumentParent(
       PBrowserParent* aBrowser, const uint64_t& aOuterWindowID);
 
   bool DeallocPWebBrowserPersistDocumentParent(
       PWebBrowserPersistDocumentParent* aActor);
 
-  virtual mozilla::ipc::IPCResult RecvGetGfxVars(
-      InfallibleTArray<GfxVarUpdate>* aVars) override;
+  mozilla::ipc::IPCResult RecvGetGfxVars(InfallibleTArray<GfxVarUpdate>* aVars);
 
-  virtual mozilla::ipc::IPCResult RecvReadFontList(
-      InfallibleTArray<FontListEntry>* retValue) override;
+  mozilla::ipc::IPCResult RecvReadFontList(
+      InfallibleTArray<FontListEntry>* retValue);
 
-  virtual mozilla::ipc::IPCResult RecvSetClipboard(
+  mozilla::ipc::IPCResult RecvSetClipboard(
       const IPCDataTransfer& aDataTransfer, const bool& aIsPrivateData,
       const IPC::Principal& aRequestingPrincipal,
-      const uint32_t& aContentPolicyType,
-      const int32_t& aWhichClipboard) override;
+      const uint32_t& aContentPolicyType, const int32_t& aWhichClipboard);
 
-  virtual mozilla::ipc::IPCResult RecvGetClipboard(
-      nsTArray<nsCString>&& aTypes, const int32_t& aWhichClipboard,
-      IPCDataTransfer* aDataTransfer) override;
+  mozilla::ipc::IPCResult RecvGetClipboard(nsTArray<nsCString>&& aTypes,
+                                           const int32_t& aWhichClipboard,
+                                           IPCDataTransfer* aDataTransfer);
 
-  virtual mozilla::ipc::IPCResult RecvEmptyClipboard(
-      const int32_t& aWhichClipboard) override;
+  mozilla::ipc::IPCResult RecvEmptyClipboard(const int32_t& aWhichClipboard);
 
-  virtual mozilla::ipc::IPCResult RecvClipboardHasType(
-      nsTArray<nsCString>&& aTypes, const int32_t& aWhichClipboard,
-      bool* aHasType) override;
-
-  virtual mozilla::ipc::IPCResult RecvGetExternalClipboardFormats(
-      const int32_t& aWhichClipboard, const bool& aPlainTextOnly,
-      nsTArray<nsCString>* aTypes) override;
+  mozilla::ipc::IPCResult RecvClipboardHasType(nsTArray<nsCString>&& aTypes,
+                                               const int32_t& aWhichClipboard,
+                                               bool* aHasType);
 
-  virtual mozilla::ipc::IPCResult RecvPlaySound(const URIParams& aURI) override;
-  virtual mozilla::ipc::IPCResult RecvBeep() override;
-  virtual mozilla::ipc::IPCResult RecvPlayEventSound(
-      const uint32_t& aEventId) override;
+  mozilla::ipc::IPCResult RecvGetExternalClipboardFormats(
+      const int32_t& aWhichClipboard, const bool& aPlainTextOnly,
+      nsTArray<nsCString>* aTypes);
 
-  virtual mozilla::ipc::IPCResult RecvGetIconForExtension(
-      const nsCString& aFileExt, const uint32_t& aIconSize,
-      InfallibleTArray<uint8_t>* bits) override;
+  mozilla::ipc::IPCResult RecvPlaySound(const URIParams& aURI);
+  mozilla::ipc::IPCResult RecvBeep();
+  mozilla::ipc::IPCResult RecvPlayEventSound(const uint32_t& aEventId);
 
-  virtual mozilla::ipc::IPCResult RecvGetShowPasswordSetting(
-      bool* showPassword) override;
+  mozilla::ipc::IPCResult RecvGetIconForExtension(
+      const nsCString& aFileExt, const uint32_t& aIconSize,
+      InfallibleTArray<uint8_t>* bits);
 
-  virtual mozilla::ipc::IPCResult RecvStartVisitedQuery(
-      const URIParams& uri) override;
+  mozilla::ipc::IPCResult RecvGetShowPasswordSetting(bool* showPassword);
 
-  virtual mozilla::ipc::IPCResult RecvSetURITitle(
-      const URIParams& uri, const nsString& title) override;
+  mozilla::ipc::IPCResult RecvStartVisitedQuery(const URIParams& uri);
+
+  mozilla::ipc::IPCResult RecvSetURITitle(const URIParams& uri,
+                                          const nsString& title);
 
   bool HasNotificationPermission(const IPC::Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvShowAlert(
-      nsIAlertNotification* aAlert) override;
+  mozilla::ipc::IPCResult RecvShowAlert(nsIAlertNotification* aAlert);
 
-  virtual mozilla::ipc::IPCResult RecvCloseAlert(
-      const nsString& aName, const IPC::Principal& aPrincipal) override;
+  mozilla::ipc::IPCResult RecvCloseAlert(const nsString& aName,
+                                         const IPC::Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvDisableNotifications(
-      const IPC::Principal& aPrincipal) override;
+  mozilla::ipc::IPCResult RecvDisableNotifications(
+      const IPC::Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvOpenNotificationSettings(
-      const IPC::Principal& aPrincipal) override;
+  mozilla::ipc::IPCResult RecvOpenNotificationSettings(
+      const IPC::Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvNotificationEvent(
-      const nsString& aType, const NotificationEventData& aData) override;
+  mozilla::ipc::IPCResult RecvNotificationEvent(
+      const nsString& aType, const NotificationEventData& aData);
 
-  virtual mozilla::ipc::IPCResult RecvLoadURIExternal(
-      const URIParams& uri, PBrowserParent* windowContext) override;
-  virtual mozilla::ipc::IPCResult RecvExtProtocolChannelConnectParent(
-      const uint32_t& registrarId) override;
+  mozilla::ipc::IPCResult RecvLoadURIExternal(const URIParams& uri,
+                                              PBrowserParent* windowContext);
+  mozilla::ipc::IPCResult RecvExtProtocolChannelConnectParent(
+      const uint32_t& registrarId);
 
-  virtual mozilla::ipc::IPCResult RecvSyncMessage(
+  mozilla::ipc::IPCResult RecvSyncMessage(
       const nsString& aMsg, const ClonedMessageData& aData,
       InfallibleTArray<CpowEntry>&& aCpows, const IPC::Principal& aPrincipal,
       nsTArray<StructuredCloneData>* aRetvals) override;
 
-  virtual mozilla::ipc::IPCResult RecvRpcMessage(
+  mozilla::ipc::IPCResult RecvRpcMessage(
       const nsString& aMsg, const ClonedMessageData& aData,
       InfallibleTArray<CpowEntry>&& aCpows, const IPC::Principal& aPrincipal,
       nsTArray<StructuredCloneData>* aRetvals) override;
 
-  virtual mozilla::ipc::IPCResult RecvAsyncMessage(
+  mozilla::ipc::IPCResult RecvAsyncMessage(
       const nsString& aMsg, InfallibleTArray<CpowEntry>&& aCpows,
       const IPC::Principal& aPrincipal,
       const ClonedMessageData& aData) override;
 
-  virtual mozilla::ipc::IPCResult RecvAddGeolocationListener(
-      const IPC::Principal& aPrincipal, const bool& aHighAccuracy) override;
-  virtual mozilla::ipc::IPCResult RecvRemoveGeolocationListener() override;
+  mozilla::ipc::IPCResult RecvAddGeolocationListener(
+      const IPC::Principal& aPrincipal, const bool& aHighAccuracy);
+  mozilla::ipc::IPCResult RecvRemoveGeolocationListener();
 
-  virtual mozilla::ipc::IPCResult RecvSetGeolocationHigherAccuracy(
-      const bool& aEnable) override;
+  mozilla::ipc::IPCResult RecvSetGeolocationHigherAccuracy(const bool& aEnable);
 
-  virtual mozilla::ipc::IPCResult RecvConsoleMessage(
-      const nsString& aMessage) override;
+  mozilla::ipc::IPCResult RecvConsoleMessage(const nsString& aMessage);
 
-  virtual mozilla::ipc::IPCResult RecvScriptError(
+  mozilla::ipc::IPCResult RecvScriptError(
       const nsString& aMessage, const nsString& aSourceName,
       const nsString& aSourceLine, const uint32_t& aLineNumber,
       const uint32_t& aColNumber, const uint32_t& aFlags,
-      const nsCString& aCategory, const bool& aIsFromPrivateWindow) override;
+      const nsCString& aCategory, const bool& aIsFromPrivateWindow);
 
-  virtual mozilla::ipc::IPCResult RecvScriptErrorWithStack(
+  mozilla::ipc::IPCResult RecvScriptErrorWithStack(
       const nsString& aMessage, const nsString& aSourceName,
       const nsString& aSourceLine, const uint32_t& aLineNumber,
       const uint32_t& aColNumber, const uint32_t& aFlags,
       const nsCString& aCategory, const bool& aIsFromPrivateWindow,
-      const ClonedMessageData& aStack) override;
+      const ClonedMessageData& aStack);
 
  private:
   mozilla::ipc::IPCResult RecvScriptErrorInternal(
       const nsString& aMessage, const nsString& aSourceName,
       const nsString& aSourceLine, const uint32_t& aLineNumber,
       const uint32_t& aColNumber, const uint32_t& aFlags,
       const nsCString& aCategory, const bool& aIsFromPrivateWindow,
       const ClonedMessageData* aStack = nullptr);
 
  public:
-  virtual mozilla::ipc::IPCResult RecvPrivateDocShellsExist(
-      const bool& aExist) override;
+  mozilla::ipc::IPCResult RecvPrivateDocShellsExist(const bool& aExist);
 
-  virtual mozilla::ipc::IPCResult RecvFirstIdle() override;
+  mozilla::ipc::IPCResult RecvFirstIdle();
 
-  virtual mozilla::ipc::IPCResult RecvDeviceReset() override;
+  mozilla::ipc::IPCResult RecvDeviceReset();
 
-  virtual mozilla::ipc::IPCResult RecvKeywordToURI(
-      const nsCString& aKeyword, nsString* aProviderName,
-      RefPtr<nsIInputStream>* aPostData, OptionalURIParams* aURI) override;
+  mozilla::ipc::IPCResult RecvKeywordToURI(const nsCString& aKeyword,
+                                           nsString* aProviderName,
+                                           RefPtr<nsIInputStream>* aPostData,
+                                           OptionalURIParams* aURI);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyKeywordSearchLoading(
-      const nsString& aProvider, const nsString& aKeyword) override;
+  mozilla::ipc::IPCResult RecvNotifyKeywordSearchLoading(
+      const nsString& aProvider, const nsString& aKeyword);
 
-  virtual mozilla::ipc::IPCResult RecvCopyFavicon(
+  mozilla::ipc::IPCResult RecvCopyFavicon(
       const URIParams& aOldURI, const URIParams& aNewURI,
-      const IPC::Principal& aLoadingPrincipal,
-      const bool& aInPrivateBrowsing) override;
+      const IPC::Principal& aLoadingPrincipal, const bool& aInPrivateBrowsing);
 
   virtual void ProcessingError(Result aCode, const char* aMsgName) override;
 
-  virtual mozilla::ipc::IPCResult RecvGraphicsError(
-      const nsCString& aError) override;
+  mozilla::ipc::IPCResult RecvGraphicsError(const nsCString& aError);
 
-  virtual mozilla::ipc::IPCResult RecvBeginDriverCrashGuard(
-      const uint32_t& aGuardType, bool* aOutCrashed) override;
+  mozilla::ipc::IPCResult RecvBeginDriverCrashGuard(const uint32_t& aGuardType,
+                                                    bool* aOutCrashed);
 
-  virtual mozilla::ipc::IPCResult RecvEndDriverCrashGuard(
-      const uint32_t& aGuardType) override;
+  mozilla::ipc::IPCResult RecvEndDriverCrashGuard(const uint32_t& aGuardType);
 
-  virtual mozilla::ipc::IPCResult RecvAddIdleObserver(
-      const uint64_t& observerId, const uint32_t& aIdleTimeInS) override;
+  mozilla::ipc::IPCResult RecvAddIdleObserver(const uint64_t& observerId,
+                                              const uint32_t& aIdleTimeInS);
 
-  virtual mozilla::ipc::IPCResult RecvRemoveIdleObserver(
-      const uint64_t& observerId, const uint32_t& aIdleTimeInS) override;
+  mozilla::ipc::IPCResult RecvRemoveIdleObserver(const uint64_t& observerId,
+                                                 const uint32_t& aIdleTimeInS);
 
-  virtual mozilla::ipc::IPCResult RecvBackUpXResources(
-      const FileDescriptor& aXSocketFd) override;
+  mozilla::ipc::IPCResult RecvBackUpXResources(
+      const FileDescriptor& aXSocketFd);
 
-  virtual mozilla::ipc::IPCResult RecvRequestAnonymousTemporaryFile(
-      const uint64_t& aID) override;
+  mozilla::ipc::IPCResult RecvRequestAnonymousTemporaryFile(
+      const uint64_t& aID);
+
+  mozilla::ipc::IPCResult RecvCreateAudioIPCConnection(
+      CreateAudioIPCConnectionResolver&& aResolver);
 
-  virtual mozilla::ipc::IPCResult RecvCreateAudioIPCConnection(
-      CreateAudioIPCConnectionResolver&& aResolver) override;
+  mozilla::ipc::IPCResult RecvKeygenProcessValue(const nsString& oldValue,
+                                                 const nsString& challenge,
+                                                 const nsString& keytype,
+                                                 const nsString& keyparams,
+                                                 nsString* newValue);
 
-  virtual mozilla::ipc::IPCResult RecvKeygenProcessValue(
-      const nsString& oldValue, const nsString& challenge,
-      const nsString& keytype, const nsString& keyparams,
-      nsString* newValue) override;
-
-  virtual mozilla::ipc::IPCResult RecvKeygenProvideContent(
-      nsString* aAttribute, nsTArray<nsString>* aContent) override;
+  mozilla::ipc::IPCResult RecvKeygenProvideContent(
+      nsString* aAttribute, nsTArray<nsString>* aContent);
 
   virtual PFileDescriptorSetParent* AllocPFileDescriptorSetParent(
       const mozilla::ipc::FileDescriptor&) override;
 
   virtual bool DeallocPFileDescriptorSetParent(
       PFileDescriptorSetParent*) override;
 
   PWebrtcGlobalParent* AllocPWebrtcGlobalParent();
   bool DeallocPWebrtcGlobalParent(PWebrtcGlobalParent* aActor);
 
-  virtual mozilla::ipc::IPCResult RecvUpdateDropEffect(
-      const uint32_t& aDragAction, const uint32_t& aDropEffect) override;
+  mozilla::ipc::IPCResult RecvUpdateDropEffect(const uint32_t& aDragAction,
+                                               const uint32_t& aDropEffect);
 
-  virtual mozilla::ipc::IPCResult RecvShutdownProfile(
-      const nsCString& aProfile) override;
+  mozilla::ipc::IPCResult RecvShutdownProfile(const nsCString& aProfile);
 
-  virtual mozilla::ipc::IPCResult RecvGetGraphicsDeviceInitData(
-      ContentDeviceData* aOut) override;
+  mozilla::ipc::IPCResult RecvGetGraphicsDeviceInitData(
+      ContentDeviceData* aOut);
 
-  virtual mozilla::ipc::IPCResult RecvGetAndroidSystemInfo(
-      AndroidSystemInfo* aInfo) override;
+  mozilla::ipc::IPCResult RecvGetAndroidSystemInfo(AndroidSystemInfo* aInfo);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyBenchmarkResult(
-      const nsString& aCodecName, const uint32_t& aDecodeFPS) override;
+  mozilla::ipc::IPCResult RecvNotifyBenchmarkResult(const nsString& aCodecName,
+                                                    const uint32_t& aDecodeFPS);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyPushObservers(
+  mozilla::ipc::IPCResult RecvNotifyPushObservers(
       const nsCString& aScope, const IPC::Principal& aPrincipal,
-      const nsString& aMessageId) override;
+      const nsString& aMessageId);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyPushObserversWithData(
+  mozilla::ipc::IPCResult RecvNotifyPushObserversWithData(
       const nsCString& aScope, const IPC::Principal& aPrincipal,
-      const nsString& aMessageId, InfallibleTArray<uint8_t>&& aData) override;
+      const nsString& aMessageId, InfallibleTArray<uint8_t>&& aData);
+
+  mozilla::ipc::IPCResult RecvNotifyPushSubscriptionChangeObservers(
+      const nsCString& aScope, const IPC::Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyPushSubscriptionChangeObservers(
-      const nsCString& aScope, const IPC::Principal& aPrincipal) override;
-
-  virtual mozilla::ipc::IPCResult RecvPushError(
-      const nsCString& aScope, const IPC::Principal& aPrincipal,
-      const nsString& aMessage, const uint32_t& aFlags) override;
+  mozilla::ipc::IPCResult RecvPushError(const nsCString& aScope,
+                                        const IPC::Principal& aPrincipal,
+                                        const nsString& aMessage,
+                                        const uint32_t& aFlags);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyPushSubscriptionModifiedObservers(
-      const nsCString& aScope, const IPC::Principal& aPrincipal) override;
+  mozilla::ipc::IPCResult RecvNotifyPushSubscriptionModifiedObservers(
+      const nsCString& aScope, const IPC::Principal& aPrincipal);
 
-  virtual mozilla::ipc::IPCResult RecvGetFilesRequest(
-      const nsID& aID, const nsString& aDirectoryPath,
-      const bool& aRecursiveFlag) override;
+  mozilla::ipc::IPCResult RecvGetFilesRequest(const nsID& aID,
+                                              const nsString& aDirectoryPath,
+                                              const bool& aRecursiveFlag);
 
-  virtual mozilla::ipc::IPCResult RecvDeleteGetFilesRequest(
-      const nsID& aID) override;
+  mozilla::ipc::IPCResult RecvDeleteGetFilesRequest(const nsID& aID);
 
-  virtual mozilla::ipc::IPCResult RecvFileCreationRequest(
+  mozilla::ipc::IPCResult RecvFileCreationRequest(
       const nsID& aID, const nsString& aFullPath, const nsString& aType,
       const nsString& aName, const bool& aLastModifiedPassed,
       const int64_t& aLastModified, const bool& aExistenceCheck,
-      const bool& aIsFromNsIFile) override;
+      const bool& aIsFromNsIFile);
 
-  virtual mozilla::ipc::IPCResult RecvAccumulateChildHistograms(
-      InfallibleTArray<HistogramAccumulation>&& aAccumulations) override;
-  virtual mozilla::ipc::IPCResult RecvAccumulateChildKeyedHistograms(
-      InfallibleTArray<KeyedHistogramAccumulation>&& aAccumulations) override;
-  virtual mozilla::ipc::IPCResult RecvUpdateChildScalars(
-      InfallibleTArray<ScalarAction>&& aScalarActions) override;
-  virtual mozilla::ipc::IPCResult RecvUpdateChildKeyedScalars(
-      InfallibleTArray<KeyedScalarAction>&& aScalarActions) override;
-  virtual mozilla::ipc::IPCResult RecvRecordChildEvents(
-      nsTArray<ChildEventData>&& events) override;
-  virtual mozilla::ipc::IPCResult RecvRecordDiscardedData(
-      const DiscardedData& aDiscardedData) override;
+  mozilla::ipc::IPCResult RecvAccumulateChildHistograms(
+      InfallibleTArray<HistogramAccumulation>&& aAccumulations);
+  mozilla::ipc::IPCResult RecvAccumulateChildKeyedHistograms(
+      InfallibleTArray<KeyedHistogramAccumulation>&& aAccumulations);
+  mozilla::ipc::IPCResult RecvUpdateChildScalars(
+      InfallibleTArray<ScalarAction>&& aScalarActions);
+  mozilla::ipc::IPCResult RecvUpdateChildKeyedScalars(
+      InfallibleTArray<KeyedScalarAction>&& aScalarActions);
+  mozilla::ipc::IPCResult RecvRecordChildEvents(
+      nsTArray<ChildEventData>&& events);
+  mozilla::ipc::IPCResult RecvRecordDiscardedData(
+      const DiscardedData& aDiscardedData);
 
-  virtual mozilla::ipc::IPCResult RecvBHRThreadHang(
-      const HangDetails& aHangDetails) override;
+  mozilla::ipc::IPCResult RecvBHRThreadHang(const HangDetails& aHangDetails);
 
-  virtual mozilla::ipc::IPCResult RecvFirstPartyStorageAccessGrantedForOrigin(
+  mozilla::ipc::IPCResult RecvFirstPartyStorageAccessGrantedForOrigin(
       const Principal& aParentPrincipal, const Principal& aTrackingPrincipal,
       const nsCString& aTrackingOrigin, const nsCString& aGrantedOrigin,
       const int& aAllowMode,
-      FirstPartyStorageAccessGrantedForOriginResolver&& aResolver) override;
+      FirstPartyStorageAccessGrantedForOriginResolver&& aResolver);
 
-  virtual mozilla::ipc::IPCResult RecvStoreUserInteractionAsPermission(
-      const Principal& aPrincipal) override;
+  mozilla::ipc::IPCResult RecvStoreUserInteractionAsPermission(
+      const Principal& aPrincipal);
 
   // Notify the ContentChild to enable the input event prioritization when
   // initializing.
   void MaybeEnableRemoteInputEventQueue();
 
 #if defined(XP_MACOSX) && defined(MOZ_CONTENT_SANDBOX)
   void AppendSandboxParams(std::vector<std::string>& aArgs);
   void AppendDynamicSandboxParams(std::vector<std::string>& aArgs);
--- a/dom/ipc/FilePickerParent.h
+++ b/dom/ipc/FilePickerParent.h
@@ -32,25 +32,26 @@ class FilePickerParent : public PFilePic
     RefPtr<BlobImpl> mBlobImpl;
     nsString mDirectoryPath;
 
     enum { eBlobImpl, eDirectoryPath } mType;
   };
 
   void SendFilesOrDirectories(const nsTArray<BlobImplOrString>& aData);
 
-  virtual mozilla::ipc::IPCResult RecvOpen(
-      const int16_t& aSelectedType, const bool& aAddToRecentDocs,
-      const nsString& aDefaultFile, const nsString& aDefaultExtension,
-      InfallibleTArray<nsString>&& aFilters,
-      InfallibleTArray<nsString>&& aFilterNames,
-      InfallibleTArray<nsString>&& aRawFilters,
-      const nsString& aDisplayDirectory,
-      const nsString& aDisplaySpecialDirectory,
-      const nsString& aOkButtonLabel) override;
+  mozilla::ipc::IPCResult RecvOpen(const int16_t& aSelectedType,
+                                   const bool& aAddToRecentDocs,
+                                   const nsString& aDefaultFile,
+                                   const nsString& aDefaultExtension,
+                                   InfallibleTArray<nsString>&& aFilters,
+                                   InfallibleTArray<nsString>&& aFilterNames,
+                                   InfallibleTArray<nsString>&& aRawFilters,
+                                   const nsString& aDisplayDirectory,
+                                   const nsString& aDisplaySpecialDirectory,
+                                   const nsString& aOkButtonLabel);
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
   class FilePickerShownCallback : public nsIFilePickerShownCallback {
    public:
     explicit FilePickerShownCallback(FilePickerParent* aFilePickerParent)
         : mFilePickerParent(aFilePickerParent) {}
 
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -131,173 +131,166 @@ class TabParent final : public PBrowserP
   CanonicalBrowsingContext* GetBrowsingContext() { return mBrowsingContext; }
 
   void Destroy();
 
   void RemoveWindowListeners();
 
   void AddWindowListeners();
 
-  virtual mozilla::ipc::IPCResult RecvMoveFocus(
-      const bool& aForward, const bool& aForDocumentNavigation) override;
-
-  virtual mozilla::ipc::IPCResult RecvSizeShellTo(
-      const uint32_t& aFlags, const int32_t& aWidth, const int32_t& aHeight,
-      const int32_t& aShellItemWidth, const int32_t& aShellItemHeight) override;
+  mozilla::ipc::IPCResult RecvMoveFocus(const bool& aForward,
+                                        const bool& aForDocumentNavigation);
 
-  virtual mozilla::ipc::IPCResult RecvDropLinks(
-      nsTArray<nsString>&& aLinks) override;
+  mozilla::ipc::IPCResult RecvSizeShellTo(const uint32_t& aFlags,
+                                          const int32_t& aWidth,
+                                          const int32_t& aHeight,
+                                          const int32_t& aShellItemWidth,
+                                          const int32_t& aShellItemHeight);
 
-  virtual mozilla::ipc::IPCResult RecvEvent(
-      const RemoteDOMEvent& aEvent) override;
+  mozilla::ipc::IPCResult RecvDropLinks(nsTArray<nsString>&& aLinks);
 
-  virtual mozilla::ipc::IPCResult RecvReplyKeyEvent(
-      const WidgetKeyboardEvent& aEvent) override;
+  mozilla::ipc::IPCResult RecvEvent(const RemoteDOMEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvReplyKeyEvent(const WidgetKeyboardEvent& aEvent);
 
-  virtual mozilla::ipc::IPCResult RecvAccessKeyNotHandled(
-      const WidgetKeyboardEvent& aEvent) override;
+  mozilla::ipc::IPCResult RecvAccessKeyNotHandled(
+      const WidgetKeyboardEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvSetHasBeforeUnload(const bool& aHasBeforeUnload);
 
-  virtual mozilla::ipc::IPCResult RecvSetHasBeforeUnload(
-      const bool& aHasBeforeUnload) override;
-
-  virtual mozilla::ipc::IPCResult RecvRegisterProtocolHandler(
-      const nsString& aScheme, nsIURI* aHandlerURI, const nsString& aTitle,
-      nsIURI* aDocURI) override;
+  mozilla::ipc::IPCResult RecvRegisterProtocolHandler(const nsString& aScheme,
+                                                      nsIURI* aHandlerURI,
+                                                      const nsString& aTitle,
+                                                      nsIURI* aDocURI);
 
-  virtual mozilla::ipc::IPCResult RecvOnContentBlockingEvent(
+  mozilla::ipc::IPCResult RecvOnContentBlockingEvent(
       const OptionalWebProgressData& aWebProgressData,
-      const RequestData& aRequestData, const uint32_t& aEvent) override;
+      const RequestData& aRequestData, const uint32_t& aEvent);
 
-  virtual mozilla::ipc::IPCResult RecvBrowserFrameOpenWindow(
+  mozilla::ipc::IPCResult RecvBrowserFrameOpenWindow(
       PBrowserParent* aOpener, const nsString& aURL, const nsString& aName,
-      const nsString& aFeatures,
-      BrowserFrameOpenWindowResolver&& aResolve) override;
+      const nsString& aFeatures, BrowserFrameOpenWindowResolver&& aResolve);
 
-  virtual mozilla::ipc::IPCResult RecvSyncMessage(
+  mozilla::ipc::IPCResult RecvSyncMessage(
       const nsString& aMessage, const ClonedMessageData& aData,
       InfallibleTArray<CpowEntry>&& aCpows, const IPC::Principal& aPrincipal,
-      nsTArray<ipc::StructuredCloneData>* aRetVal) override;
+      nsTArray<ipc::StructuredCloneData>* aRetVal);
 
-  virtual mozilla::ipc::IPCResult RecvRpcMessage(
+  mozilla::ipc::IPCResult RecvRpcMessage(
       const nsString& aMessage, const ClonedMessageData& aData,
       InfallibleTArray<CpowEntry>&& aCpows, const IPC::Principal& aPrincipal,
-      nsTArray<ipc::StructuredCloneData>* aRetVal) override;
+      nsTArray<ipc::StructuredCloneData>* aRetVal);
 
-  virtual mozilla::ipc::IPCResult RecvAsyncMessage(
-      const nsString& aMessage, InfallibleTArray<CpowEntry>&& aCpows,
-      const IPC::Principal& aPrincipal,
-      const ClonedMessageData& aData) override;
+  mozilla::ipc::IPCResult RecvAsyncMessage(const nsString& aMessage,
+                                           InfallibleTArray<CpowEntry>&& aCpows,
+                                           const IPC::Principal& aPrincipal,
+                                           const ClonedMessageData& aData);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyIMEFocus(
+  mozilla::ipc::IPCResult RecvNotifyIMEFocus(
       const ContentCache& aContentCache,
       const widget::IMENotification& aEventMessage,
-      NotifyIMEFocusResolver&& aResolve) override;
+      NotifyIMEFocusResolver&& aResolve);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyIMETextChange(
+  mozilla::ipc::IPCResult RecvNotifyIMETextChange(
       const ContentCache& aContentCache,
-      const widget::IMENotification& aEventMessage) override;
+      const widget::IMENotification& aEventMessage);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyIMECompositionUpdate(
+  mozilla::ipc::IPCResult RecvNotifyIMECompositionUpdate(
       const ContentCache& aContentCache,
-      const widget::IMENotification& aEventMessage) override;
+      const widget::IMENotification& aEventMessage);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyIMESelection(
+  mozilla::ipc::IPCResult RecvNotifyIMESelection(
       const ContentCache& aContentCache,
-      const widget::IMENotification& aEventMessage) override;
+      const widget::IMENotification& aEventMessage);
 
-  virtual mozilla::ipc::IPCResult RecvUpdateContentCache(
-      const ContentCache& aContentCache) override;
+  mozilla::ipc::IPCResult RecvUpdateContentCache(
+      const ContentCache& aContentCache);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyIMEMouseButtonEvent(
-      const widget::IMENotification& aEventMessage,
-      bool* aConsumedByIME) override;
+  mozilla::ipc::IPCResult RecvNotifyIMEMouseButtonEvent(
+      const widget::IMENotification& aEventMessage, bool* aConsumedByIME);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyIMEPositionChange(
+  mozilla::ipc::IPCResult RecvNotifyIMEPositionChange(
       const ContentCache& aContentCache,
-      const widget::IMENotification& aEventMessage) override;
+      const widget::IMENotification& aEventMessage);
 
-  virtual mozilla::ipc::IPCResult RecvOnEventNeedingAckHandled(
-      const EventMessage& aMessage) override;
+  mozilla::ipc::IPCResult RecvOnEventNeedingAckHandled(
+      const EventMessage& aMessage);
 
-  virtual mozilla::ipc::IPCResult RecvRequestIMEToCommitComposition(
-      const bool& aCancel, bool* aIsCommitted,
-      nsString* aCommittedString) override;
+  mozilla::ipc::IPCResult RecvRequestIMEToCommitComposition(
+      const bool& aCancel, bool* aIsCommitted, nsString* aCommittedString);
 
-  virtual mozilla::ipc::IPCResult RecvStartPluginIME(
+  mozilla::ipc::IPCResult RecvStartPluginIME(
       const WidgetKeyboardEvent& aKeyboardEvent, const int32_t& aPanelX,
-      const int32_t& aPanelY, nsString* aCommitted) override;
+      const int32_t& aPanelY, nsString* aCommitted);
 
-  virtual mozilla::ipc::IPCResult RecvSetPluginFocused(
-      const bool& aFocused) override;
+  mozilla::ipc::IPCResult RecvSetPluginFocused(const bool& aFocused);
 
-  virtual mozilla::ipc::IPCResult RecvSetCandidateWindowForPlugin(
-      const widget::CandidateWindowPosition& aPosition) override;
-  virtual mozilla::ipc::IPCResult RecvEnableIMEForPlugin(
-      const bool& aEnable) override;
+  mozilla::ipc::IPCResult RecvSetCandidateWindowForPlugin(
+      const widget::CandidateWindowPosition& aPosition);
+  mozilla::ipc::IPCResult RecvEnableIMEForPlugin(const bool& aEnable);
 
-  virtual mozilla::ipc::IPCResult RecvDefaultProcOfPluginEvent(
-      const WidgetPluginEvent& aEvent) override;
+  mozilla::ipc::IPCResult RecvDefaultProcOfPluginEvent(
+      const WidgetPluginEvent& aEvent);
 
-  virtual mozilla::ipc::IPCResult RecvGetInputContext(
-      widget::IMEState* aIMEState) override;
+  mozilla::ipc::IPCResult RecvGetInputContext(widget::IMEState* aIMEState);
 
-  virtual mozilla::ipc::IPCResult RecvSetInputContext(
+  mozilla::ipc::IPCResult RecvSetInputContext(
       const widget::InputContext& aContext,
-      const widget::InputContextAction& aAction) override;
+      const widget::InputContextAction& aAction);
 
   // See nsIKeyEventInPluginCallback
   virtual void HandledWindowedPluginKeyEvent(
       const NativeEventData& aKeyEventData, bool aIsConsumed) override;
 
-  virtual mozilla::ipc::IPCResult RecvOnWindowedPluginKeyEvent(
-      const NativeEventData& aKeyEventData) override;
+  mozilla::ipc::IPCResult RecvOnWindowedPluginKeyEvent(
+      const NativeEventData& aKeyEventData);
 
-  virtual mozilla::ipc::IPCResult RecvRequestFocus(
-      const bool& aCanRaise) override;
+  mozilla::ipc::IPCResult RecvRequestFocus(const bool& aCanRaise);
 
-  virtual mozilla::ipc::IPCResult RecvLookUpDictionary(
+  mozilla::ipc::IPCResult RecvLookUpDictionary(
       const nsString& aText, nsTArray<mozilla::FontRange>&& aFontRangeArray,
-      const bool& aIsVertical, const LayoutDeviceIntPoint& aPoint) override;
+      const bool& aIsVertical, const LayoutDeviceIntPoint& aPoint);
 
-  virtual mozilla::ipc::IPCResult RecvEnableDisableCommands(
+  mozilla::ipc::IPCResult RecvEnableDisableCommands(
       const nsString& aAction, nsTArray<nsCString>&& aEnabledCommands,
-      nsTArray<nsCString>&& aDisabledCommands) override;
+      nsTArray<nsCString>&& aDisabledCommands);
 
-  virtual mozilla::ipc::IPCResult RecvSetCursor(
+  mozilla::ipc::IPCResult RecvSetCursor(
       const nsCursor& aValue, const bool& aHasCustomCursor,
       const nsCString& aUri, const uint32_t& aWidth, const uint32_t& aHeight,
       const uint32_t& aStride, const gfx::SurfaceFormat& aFormat,
       const uint32_t& aHotspotX, const uint32_t& aHotspotY,
-      const bool& aForce) override;
+      const bool& aForce);
 
-  virtual mozilla::ipc::IPCResult RecvSetStatus(
-      const uint32_t& aType, const nsString& aStatus) override;
+  mozilla::ipc::IPCResult RecvSetStatus(
+      const uint32_t& aType, const nsString& aStatus);
 
-  virtual mozilla::ipc::IPCResult RecvShowTooltip(
-      const uint32_t& aX, const uint32_t& aY, const nsString& aTooltip,
-      const nsString& aDirection) override;
+  mozilla::ipc::IPCResult RecvShowTooltip(const uint32_t& aX,
+                                          const uint32_t& aY,
+                                          const nsString& aTooltip,
+                                          const nsString& aDirection);
 
-  virtual mozilla::ipc::IPCResult RecvHideTooltip() override;
-
-  virtual mozilla::ipc::IPCResult RecvSetNativeChildOfShareableWindow(
-      const uintptr_t& childWindow) override;
+  mozilla::ipc::IPCResult RecvHideTooltip();
 
-  virtual mozilla::ipc::IPCResult RecvDispatchFocusToTopLevelWindow() override;
+  mozilla::ipc::IPCResult RecvSetNativeChildOfShareableWindow(
+      const uintptr_t& childWindow);
 
-  virtual mozilla::ipc::IPCResult RecvRespondStartSwipeEvent(
-      const uint64_t& aInputBlockId, const bool& aStartSwipe) override;
+  mozilla::ipc::IPCResult RecvDispatchFocusToTopLevelWindow();
+
+  mozilla::ipc::IPCResult RecvRespondStartSwipeEvent(
+      const uint64_t& aInputBlockId, const bool& aStartSwipe);
 
-  virtual mozilla::ipc::IPCResult RecvDispatchWheelEvent(
-      const mozilla::WidgetWheelEvent& aEvent) override;
+  mozilla::ipc::IPCResult RecvDispatchWheelEvent(
+      const mozilla::WidgetWheelEvent& aEvent);
 
-  virtual mozilla::ipc::IPCResult RecvDispatchMouseEvent(
-      const mozilla::WidgetMouseEvent& aEvent) override;
+  mozilla::ipc::IPCResult RecvDispatchMouseEvent(
+      const mozilla::WidgetMouseEvent& aEvent);
 
-  virtual mozilla::ipc::IPCResult RecvDispatchKeyboardEvent(
-      const mozilla::WidgetKeyboardEvent& aEvent) override;
+  mozilla::ipc::IPCResult RecvDispatchKeyboardEvent(
+      const mozilla::WidgetKeyboardEvent& aEvent);
 
   PColorPickerParent* AllocPColorPickerParent(const nsString& aTitle,
                                               const nsString& aInitialColor);
 
   bool DeallocPColorPickerParent(PColorPickerParent* aColorPicker);
 
   PDocAccessibleParent* AllocPDocAccessibleParent(PDocAccessibleParent*,
                                                   const uint64_t&,
@@ -354,56 +347,53 @@ class TabParent final : public PBrowserP
 
   bool MapEventCoordinatesForChildProcess(mozilla::WidgetEvent* aEvent);
 
   void MapEventCoordinatesForChildProcess(const LayoutDeviceIntPoint& aOffset,
                                           mozilla::WidgetEvent* aEvent);
 
   LayoutDeviceToCSSScale GetLayoutDeviceToCSSScale();
 
-  virtual mozilla::ipc::IPCResult RecvRequestNativeKeyBindings(
+  mozilla::ipc::IPCResult RecvRequestNativeKeyBindings(
       const uint32_t& aType, const mozilla::WidgetKeyboardEvent& aEvent,
-      nsTArray<mozilla::CommandInt>* aCommands) override;
+      nsTArray<mozilla::CommandInt>* aCommands);
 
-  virtual mozilla::ipc::IPCResult RecvSynthesizeNativeKeyEvent(
+  mozilla::ipc::IPCResult RecvSynthesizeNativeKeyEvent(
       const int32_t& aNativeKeyboardLayout, const int32_t& aNativeKeyCode,
       const uint32_t& aModifierFlags, const nsString& aCharacters,
-      const nsString& aUnmodifiedCharacters,
-      const uint64_t& aObserverId) override;
+      const nsString& aUnmodifiedCharacters, const uint64_t& aObserverId);
 
-  virtual mozilla::ipc::IPCResult RecvSynthesizeNativeMouseEvent(
+  mozilla::ipc::IPCResult RecvSynthesizeNativeMouseEvent(
       const LayoutDeviceIntPoint& aPoint, const uint32_t& aNativeMessage,
-      const uint32_t& aModifierFlags, const uint64_t& aObserverId) override;
+      const uint32_t& aModifierFlags, const uint64_t& aObserverId);
 
-  virtual mozilla::ipc::IPCResult RecvSynthesizeNativeMouseMove(
-      const LayoutDeviceIntPoint& aPoint, const uint64_t& aObserverId) override;
+  mozilla::ipc::IPCResult RecvSynthesizeNativeMouseMove(
+      const LayoutDeviceIntPoint& aPoint, const uint64_t& aObserverId);
 
-  virtual mozilla::ipc::IPCResult RecvSynthesizeNativeMouseScrollEvent(
+  mozilla::ipc::IPCResult RecvSynthesizeNativeMouseScrollEvent(
       const LayoutDeviceIntPoint& aPoint, const uint32_t& aNativeMessage,
       const double& aDeltaX, const double& aDeltaY, const double& aDeltaZ,
       const uint32_t& aModifierFlags, const uint32_t& aAdditionalFlags,
-      const uint64_t& aObserverId) override;
+      const uint64_t& aObserverId);
 
-  virtual mozilla::ipc::IPCResult RecvSynthesizeNativeTouchPoint(
+  mozilla::ipc::IPCResult RecvSynthesizeNativeTouchPoint(
       const uint32_t& aPointerId, const TouchPointerState& aPointerState,
       const LayoutDeviceIntPoint& aPoint, const double& aPointerPressure,
-      const uint32_t& aPointerOrientation,
-      const uint64_t& aObserverId) override;
+      const uint32_t& aPointerOrientation, const uint64_t& aObserverId);
 
-  virtual mozilla::ipc::IPCResult RecvSynthesizeNativeTouchTap(
+  mozilla::ipc::IPCResult RecvSynthesizeNativeTouchTap(
       const LayoutDeviceIntPoint& aPoint, const bool& aLongTap,
-      const uint64_t& aObserverId) override;
+      const uint64_t& aObserverId);
 
-  virtual mozilla::ipc::IPCResult RecvClearNativeTouchSequence(
-      const uint64_t& aObserverId) override;
+  mozilla::ipc::IPCResult RecvClearNativeTouchSequence(
+      const uint64_t& aObserverId);
 
-  virtual mozilla::ipc::IPCResult RecvSetPrefersReducedMotionOverrideForTest(
-      const bool& aValue) override;
-  virtual mozilla::ipc::IPCResult RecvResetPrefersReducedMotionOverrideForTest()
-      override;
+  mozilla::ipc::IPCResult RecvSetPrefersReducedMotionOverrideForTest(
+      const bool& aValue);
+  mozilla::ipc::IPCResult RecvResetPrefersReducedMotionOverrideForTest();
 
   void SendMouseEvent(const nsAString& aType, float aX, float aY,
                       int32_t aButton, int32_t aClickCount, int32_t aModifiers,
                       bool aIgnoreRootScrollFrame);
 
   /**
    * The following Send*Event() marks aEvent as posted to remote process if
    * it succeeded.  So, you can check the result with
@@ -524,32 +514,32 @@ class TabParent final : public PBrowserP
 
   void LayerTreeUpdate(const LayersObserverEpoch& aEpoch, bool aActive);
 
   void RequestRootPaint(gfx::CrossProcessPaint* aPaint, IntRect aRect,
                         float aScale, nscolor aBackgroundColor);
   void RequestSubPaint(gfx::CrossProcessPaint* aPaint, float aScale,
                        nscolor aBackgroundColor);
 
-  virtual mozilla::ipc::IPCResult RecvInvokeDragSession(
+  mozilla::ipc::IPCResult RecvInvokeDragSession(
       nsTArray<IPCDataTransfer>&& aTransfers, const uint32_t& aAction,
       const OptionalShmem& aVisualDnDData, const uint32_t& aStride,
       const gfx::SurfaceFormat& aFormat, const LayoutDeviceIntRect& aDragRect,
-      const IPC::Principal& aPrincipal) override;
+      const IPC::Principal& aPrincipal);
 
   void AddInitialDnDDataTo(DataTransfer* aDataTransfer,
                            nsIPrincipal** aPrincipal);
 
   bool TakeDragVisualization(RefPtr<mozilla::gfx::SourceSurface>& aSurface,
                              LayoutDeviceIntRect* aDragRect);
 
   layout::RenderFrame* GetRenderFrame();
 
   mozilla::ipc::IPCResult RecvEnsureLayersConnected(
-      CompositorOptions* aCompositorOptions) override;
+      CompositorOptions* aCompositorOptions);
 
   // LiveResizeListener implementation
   void LiveResizeStarted() override;
   void LiveResizeStopped() override;
 
   void SetReadyToHandleInputEvents() { mIsReadyToHandleInputEvents = true; }
   bool IsReadyToHandleInputEvents() { return mIsReadyToHandleInputEvents; }
 
@@ -560,57 +550,56 @@ class TabParent final : public PBrowserP
   void NavigateByKey(bool aForward, bool aForDocumentNavigation);
 
  protected:
   bool ReceiveMessage(
       const nsString& aMessage, bool aSync, ipc::StructuredCloneData* aData,
       mozilla::jsipc::CpowHolder* aCpows, nsIPrincipal* aPrincipal,
       nsTArray<ipc::StructuredCloneData>* aJSONRetVal = nullptr);
 
-  virtual mozilla::ipc::IPCResult RecvAsyncAuthPrompt(
-      const nsCString& aUri, const nsString& aRealm,
-      const uint64_t& aCallbackId) override;
+  mozilla::ipc::IPCResult RecvAsyncAuthPrompt(const nsCString& aUri,
+                                              const nsString& aRealm,
+                                              const uint64_t& aCallbackId);
 
   virtual mozilla::ipc::IPCResult Recv__delete__() override;
 
   virtual void ActorDestroy(ActorDestroyReason why) override;
 
   Element* mFrameElement;
   nsCOMPtr<nsIBrowserDOMWindow> mBrowserDOMWindow;
 
-  virtual mozilla::ipc::IPCResult RecvRemotePaintIsReady() override;
+  mozilla::ipc::IPCResult RecvRemotePaintIsReady();
 
-  virtual mozilla::ipc::IPCResult RecvNotifyCompositorTransaction() override;
+  mozilla::ipc::IPCResult RecvNotifyCompositorTransaction();
 
-  virtual mozilla::ipc::IPCResult RecvRemoteIsReadyToHandleInputEvents()
-      override;
+  mozilla::ipc::IPCResult RecvRemoteIsReadyToHandleInputEvents();
 
-  virtual mozilla::ipc::IPCResult RecvPaintWhileInterruptingJSNoOp(
-      const LayersObserverEpoch& aEpoch) override;
+  mozilla::ipc::IPCResult RecvPaintWhileInterruptingJSNoOp(
+      const LayersObserverEpoch& aEpoch);
 
-  virtual mozilla::ipc::IPCResult RecvSetDimensions(
-      const uint32_t& aFlags, const int32_t& aX, const int32_t& aY,
-      const int32_t& aCx, const int32_t& aCy) override;
+  mozilla::ipc::IPCResult RecvSetDimensions(const uint32_t& aFlags,
+                                            const int32_t& aX,
+                                            const int32_t& aY,
+                                            const int32_t& aCx,
+                                            const int32_t& aCy);
 
-  virtual mozilla::ipc::IPCResult RecvShowCanvasPermissionPrompt(
-      const nsCString& aFirstPartyURI, const bool& aHideDoorHanger) override;
+  mozilla::ipc::IPCResult RecvShowCanvasPermissionPrompt(
+      const nsCString& aFirstPartyURI, const bool& aHideDoorHanger);
 
-  virtual mozilla::ipc::IPCResult RecvRootBrowsingContext(
-      const BrowsingContextId& aId) override;
+  mozilla::ipc::IPCResult RecvRootBrowsingContext(const BrowsingContextId& aId);
 
-  mozilla::ipc::IPCResult RecvSetSystemFont(
-      const nsCString& aFontName) override;
-  mozilla::ipc::IPCResult RecvGetSystemFont(nsCString* aFontName) override;
+  mozilla::ipc::IPCResult RecvSetSystemFont(const nsCString& aFontName);
+  mozilla::ipc::IPCResult RecvGetSystemFont(nsCString* aFontName);
 
-  virtual mozilla::ipc::IPCResult RecvVisitURI(
-      const URIParams& aURI, const OptionalURIParams& aLastVisitedURI,
-      const uint32_t& aFlags) override;
+  mozilla::ipc::IPCResult RecvVisitURI(const URIParams& aURI,
+                                       const OptionalURIParams& aLastVisitedURI,
+                                       const uint32_t& aFlags);
 
-  virtual mozilla::ipc::IPCResult RecvQueryVisitedState(
-      InfallibleTArray<URIParams>&& aURIs) override;
+  mozilla::ipc::IPCResult RecvQueryVisitedState(
+      InfallibleTArray<URIParams>&& aURIs);
 
   ContentCacheInParent mContentCache;
 
   nsIntRect mRect;
   ScreenIntSize mDimensions;
   hal::ScreenOrientation mOrientation;
   float mDPI;
   int32_t mRounding;
--- a/dom/ipc/WindowGlobalParent.h
+++ b/dom/ipc/WindowGlobalParent.h
@@ -94,19 +94,19 @@ class WindowGlobalParent final : public 
   void Init(const WindowGlobalInit& aInit);
 
   nsISupports* GetParentObject();
   JSObject* WrapObject(JSContext* aCx,
                        JS::Handle<JSObject*> aGivenProto) override;
 
  protected:
   // IPC messages
-  mozilla::ipc::IPCResult RecvUpdateDocumentURI(nsIURI* aURI) override;
-  mozilla::ipc::IPCResult RecvBecomeCurrentWindowGlobal() override;
-  mozilla::ipc::IPCResult RecvDestroy() override;
+  mozilla::ipc::IPCResult RecvUpdateDocumentURI(nsIURI* aURI);
+  mozilla::ipc::IPCResult RecvBecomeCurrentWindowGlobal();
+  mozilla::ipc::IPCResult RecvDestroy();
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   ~WindowGlobalParent();
 
   // NOTE: This document principal doesn't reflect possible |document.domain|
   // mutations which may have been made in the actual document.
--- a/dom/media/gmp/ChromiumCDMParent.h
+++ b/dom/media/gmp/ChromiumCDMParent.h
@@ -85,50 +85,49 @@ class ChromiumCDMParent final : public P
   RefPtr<ShutdownPromise> ShutdownVideoDecoder();
 
   void Shutdown();
 
  protected:
   ~ChromiumCDMParent() {}
 
   ipc::IPCResult Recv__delete__() override;
-  ipc::IPCResult RecvOnResolvePromiseWithKeyStatus(
-      const uint32_t& aPromiseId, const uint32_t& aKeyStatus) override;
-  ipc::IPCResult RecvOnResolveNewSessionPromise(
-      const uint32_t& aPromiseId, const nsCString& aSessionId) override;
-  ipc::IPCResult RecvResolveLoadSessionPromise(
-      const uint32_t& aPromiseId, const bool& aSuccessful) override;
-  ipc::IPCResult RecvOnResolvePromise(const uint32_t& aPromiseId) override;
+  ipc::IPCResult RecvOnResolvePromiseWithKeyStatus(const uint32_t& aPromiseId,
+                                                   const uint32_t& aKeyStatus);
+  ipc::IPCResult RecvOnResolveNewSessionPromise(const uint32_t& aPromiseId,
+                                                const nsCString& aSessionId);
+  ipc::IPCResult RecvResolveLoadSessionPromise(const uint32_t& aPromiseId,
+                                               const bool& aSuccessful);
+  ipc::IPCResult RecvOnResolvePromise(const uint32_t& aPromiseId);
   ipc::IPCResult RecvOnRejectPromise(const uint32_t& aPromiseId,
                                      const uint32_t& aError,
                                      const uint32_t& aSystemCode,
-                                     const nsCString& aErrorMessage) override;
+                                     const nsCString& aErrorMessage);
   ipc::IPCResult RecvOnSessionMessage(const nsCString& aSessionId,
                                       const uint32_t& aMessageType,
-                                      nsTArray<uint8_t>&& aMessage) override;
+                                      nsTArray<uint8_t>&& aMessage);
   ipc::IPCResult RecvOnSessionKeysChange(
-      const nsCString& aSessionId,
-      nsTArray<CDMKeyInformation>&& aKeysInfo) override;
-  ipc::IPCResult RecvOnExpirationChange(
-      const nsCString& aSessionId, const double& aSecondsSinceEpoch) override;
-  ipc::IPCResult RecvOnSessionClosed(const nsCString& aSessionId) override;
+      const nsCString& aSessionId, nsTArray<CDMKeyInformation>&& aKeysInfo);
+  ipc::IPCResult RecvOnExpirationChange(const nsCString& aSessionId,
+                                        const double& aSecondsSinceEpoch);
+  ipc::IPCResult RecvOnSessionClosed(const nsCString& aSessionId);
   ipc::IPCResult RecvDecrypted(const uint32_t& aId, const uint32_t& aStatus,
-                               ipc::Shmem&& aData) override;
+                               ipc::Shmem&& aData);
   ipc::IPCResult RecvDecryptFailed(const uint32_t& aId,
-                                   const uint32_t& aStatus) override;
-  ipc::IPCResult RecvOnDecoderInitDone(const uint32_t& aStatus) override;
+                                   const uint32_t& aStatus);
+  ipc::IPCResult RecvOnDecoderInitDone(const uint32_t& aStatus);
   ipc::IPCResult RecvDecodedShmem(const CDMVideoFrame& aFrame,
-                                  ipc::Shmem&& aShmem) override;
+                                  ipc::Shmem&& aShmem);
   ipc::IPCResult RecvDecodedData(const CDMVideoFrame& aFrame,
-                                 nsTArray<uint8_t>&& aData) override;
-  ipc::IPCResult RecvDecodeFailed(const uint32_t& aStatus) override;
-  ipc::IPCResult RecvShutdown() override;
-  ipc::IPCResult RecvResetVideoDecoderComplete() override;
-  ipc::IPCResult RecvDrainComplete() override;
-  ipc::IPCResult RecvIncreaseShmemPoolSize() override;
+                                 nsTArray<uint8_t>&& aData);
+  ipc::IPCResult RecvDecodeFailed(const uint32_t& aStatus);
+  ipc::IPCResult RecvShutdown();
+  ipc::IPCResult RecvResetVideoDecoderComplete();
+  ipc::IPCResult RecvDrainComplete();
+  ipc::IPCResult RecvIncreaseShmemPoolSize();
   void ActorDestroy(ActorDestroyReason aWhy) override;
   bool SendBufferToCDM(uint32_t aSizeInBytes);
 
   void ReorderAndReturnOutput(RefPtr<VideoData>&& aFrame);
 
   void RejectPromise(uint32_t aPromiseId, nsresult aError,
                      const nsCString& aErrorMessage);
 
--- a/dom/media/gmp/GMPChild.h
+++ b/dom/media/gmp/GMPChild.h
@@ -40,35 +40,34 @@ class GMPChild : public PGMPChild {
 
  private:
   friend class GMPContentChild;
 
   bool ResolveLinks(nsCOMPtr<nsIFile>& aPath);
 
   bool GetUTF8LibPath(nsACString& aOutLibPath);
 
-  mozilla::ipc::IPCResult RecvProvideStorageId(
-      const nsCString& aStorageId) override;
+  mozilla::ipc::IPCResult RecvProvideStorageId(const nsCString& aStorageId);
 
-  mozilla::ipc::IPCResult AnswerStartPlugin(const nsString& aAdapter) override;
-  mozilla::ipc::IPCResult RecvPreloadLibs(const nsCString& aLibs) override;
+  mozilla::ipc::IPCResult AnswerStartPlugin(const nsString& aAdapter);
+  mozilla::ipc::IPCResult RecvPreloadLibs(const nsCString& aLibs);
 
   PGMPTimerChild* AllocPGMPTimerChild();
   bool DeallocPGMPTimerChild(PGMPTimerChild* aActor);
 
   PGMPStorageChild* AllocPGMPStorageChild();
   bool DeallocPGMPStorageChild(PGMPStorageChild* aActor);
 
   void GMPContentChildActorDestroy(GMPContentChild* aGMPContentChild);
 
-  mozilla::ipc::IPCResult RecvCrashPluginNow() override;
-  mozilla::ipc::IPCResult RecvCloseActive() override;
+  mozilla::ipc::IPCResult RecvCrashPluginNow();
+  mozilla::ipc::IPCResult RecvCloseActive();
 
   mozilla::ipc::IPCResult RecvInitGMPContentChild(
-      Endpoint<PGMPContentChild>&& aEndpoint) override;
+      Endpoint<PGMPContentChild>&& aEndpoint);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
   void ProcessingError(Result aCode, const char* aReason) override;
 
   GMPErr GetAPI(const char* aAPIName, void* aHostAPI, void** aPluginAPI,
                 uint32_t aDecryptorId = 0);
 
   nsTArray<Pair<nsCString, nsCString>> MakeCDMHostVerificationPaths();
--- a/dom/media/gmp/GMPParent.h
+++ b/dom/media/gmp/GMPParent.h
@@ -153,29 +153,29 @@ class GMPParent final : public PGMPParen
       const nsAString& aJSON);  // Main thread.
   RefPtr<GenericPromise> ReadChromiumManifestFile(
       nsIFile* aFile);  // GMP thread.
   void WriteExtraDataForMinidump();
   bool GetCrashID(nsString& aResult);
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
   mozilla::ipc::IPCResult RecvInitCrashReporter(
-      Shmem&& shmem, const NativeThreadId& aThreadId) override;
+      Shmem&& shmem, const NativeThreadId& aThreadId);
 
   mozilla::ipc::IPCResult RecvPGMPStorageConstructor(
       PGMPStorageParent* actor) override;
   PGMPStorageParent* AllocPGMPStorageParent();
   bool DeallocPGMPStorageParent(PGMPStorageParent* aActor);
 
   mozilla::ipc::IPCResult RecvPGMPTimerConstructor(
       PGMPTimerParent* actor) override;
   PGMPTimerParent* AllocPGMPTimerParent();
   bool DeallocPGMPTimerParent(PGMPTimerParent* aActor);
 
-  mozilla::ipc::IPCResult RecvPGMPContentChildDestroyed() override;
+  mozilla::ipc::IPCResult RecvPGMPContentChildDestroyed();
   bool IsUsed() {
     return mGMPContentChildCount > 0 || !mGetContentParentPromises.IsEmpty();
   }
 
   void ResolveGetContentParentPromises();
   void RejectGetContentParentPromises();
 
   GMPState mState;
--- a/dom/media/gmp/GMPStorageChild.h
+++ b/dom/media/gmp/GMPStorageChild.h
@@ -70,23 +70,23 @@ class GMPStorageChild : public PGMPStora
   bool HasRecord(const nsCString& aRecordName);
   already_AddRefed<GMPRecordImpl> GetRecord(const nsCString& aRecordName);
 
  protected:
   ~GMPStorageChild() {}
 
   // PGMPStorageChild
   mozilla::ipc::IPCResult RecvOpenComplete(const nsCString& aRecordName,
-                                           const GMPErr& aStatus) override;
-  mozilla::ipc::IPCResult RecvReadComplete(
-      const nsCString& aRecordName, const GMPErr& aStatus,
-      InfallibleTArray<uint8_t>&& aBytes) override;
+                                           const GMPErr& aStatus);
+  mozilla::ipc::IPCResult RecvReadComplete(const nsCString& aRecordName,
+                                           const GMPErr& aStatus,
+                                           InfallibleTArray<uint8_t>&& aBytes);
   mozilla::ipc::IPCResult RecvWriteComplete(const nsCString& aRecordName,
-                                            const GMPErr& aStatus) override;
-  mozilla::ipc::IPCResult RecvShutdown() override;
+                                            const GMPErr& aStatus);
+  mozilla::ipc::IPCResult RecvShutdown();
 
  private:
   Monitor mMonitor;
   nsRefPtrHashtable<nsCStringHashKey, GMPRecordImpl> mRecords;
   GMPChild* mPlugin;
   bool mShutdown;
 };
 
--- a/dom/media/gmp/GMPTimerChild.h
+++ b/dom/media/gmp/GMPTimerChild.h
@@ -25,17 +25,17 @@ class GMPTimerChild : public PGMPTimerCh
   NS_INLINE_DECL_REFCOUNTING(GMPTimerChild)
 
   explicit GMPTimerChild(GMPChild* aPlugin);
 
   GMPErr SetTimer(GMPTask* aTask, int64_t aTimeoutMS);
 
  protected:
   // GMPTimerChild
-  mozilla::ipc::IPCResult RecvTimerExpired(const uint32_t& aTimerId) override;
+  mozilla::ipc::IPCResult RecvTimerExpired(const uint32_t& aTimerId);
 
  private:
   ~GMPTimerChild();
 
   nsDataHashtable<nsUint32HashKey, GMPTask*> mTimers;
   uint32_t mTimerCount;
 
   GMPChild* mPlugin;
--- a/dom/media/gmp/GMPTimerParent.h
+++ b/dom/media/gmp/GMPTimerParent.h
@@ -23,17 +23,17 @@ class GMPTimerParent : public PGMPTimerP
  public:
   NS_INLINE_DECL_REFCOUNTING(GMPTimerParent)
   explicit GMPTimerParent(nsISerialEventTarget* aGMPEventTarget);
 
   void Shutdown();
 
  protected:
   mozilla::ipc::IPCResult RecvSetTimer(const uint32_t& aTimerId,
-                                       const uint32_t& aTimeoutMs) override;
+                                       const uint32_t& aTimeoutMs);
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   ~GMPTimerParent() {}
 
   static void GMPTimerExpired(nsITimer* aTimer, void* aClosure);
 
   struct Context {
--- a/dom/media/gmp/GMPVideoDecoderChild.h
+++ b/dom/media/gmp/GMPVideoDecoderChild.h
@@ -46,26 +46,25 @@ class GMPVideoDecoderChild : public PGMP
   void Dealloc(Shmem& aMem) override;
 
  private:
   virtual ~GMPVideoDecoderChild();
 
   // PGMPVideoDecoderChild
   mozilla::ipc::IPCResult RecvInitDecode(
       const GMPVideoCodec& aCodecSettings,
-      InfallibleTArray<uint8_t>&& aCodecSpecific,
-      const int32_t& aCoreCount) override;
+      InfallibleTArray<uint8_t>&& aCodecSpecific, const int32_t& aCoreCount);
   mozilla::ipc::IPCResult RecvDecode(
       const GMPVideoEncodedFrameData& aInputFrame, const bool& aMissingFrames,
       InfallibleTArray<uint8_t>&& aCodecSpecificInfo,
-      const int64_t& aRenderTimeMs) override;
-  mozilla::ipc::IPCResult RecvChildShmemForPool(Shmem&& aFrameBuffer) override;
-  mozilla::ipc::IPCResult RecvReset() override;
-  mozilla::ipc::IPCResult RecvDrain() override;
-  mozilla::ipc::IPCResult RecvDecodingComplete() override;
+      const int64_t& aRenderTimeMs);
+  mozilla::ipc::IPCResult RecvChildShmemForPool(Shmem&& aFrameBuffer);
+  mozilla::ipc::IPCResult RecvReset();
+  mozilla::ipc::IPCResult RecvDrain();
+  mozilla::ipc::IPCResult RecvDecodingComplete();
 
   GMPContentChild* mPlugin;
   GMPVideoDecoder* mVideoDecoder;
   GMPVideoHostImpl mVideoHost;
 
   // Non-zero when a GMP is blocked spinning the IPC message loop while
   // waiting on an NeedShmem to complete.
   int mNeedShmemIntrCount;
--- a/dom/media/gmp/GMPVideoEncoderChild.h
+++ b/dom/media/gmp/GMPVideoEncoderChild.h
@@ -43,30 +43,28 @@ class GMPVideoEncoderChild : public PGMP
 
  private:
   virtual ~GMPVideoEncoderChild();
 
   // PGMPVideoEncoderChild
   mozilla::ipc::IPCResult RecvInitEncode(
       const GMPVideoCodec& aCodecSettings,
       InfallibleTArray<uint8_t>&& aCodecSpecific, const int32_t& aNumberOfCores,
-      const uint32_t& aMaxPayloadSize) override;
+      const uint32_t& aMaxPayloadSize);
   mozilla::ipc::IPCResult RecvEncode(
       const GMPVideoi420FrameData& aInputFrame,
       InfallibleTArray<uint8_t>&& aCodecSpecificInfo,
-      InfallibleTArray<GMPVideoFrameType>&& aFrameTypes) override;
-  mozilla::ipc::IPCResult RecvChildShmemForPool(
-      Shmem&& aEncodedBuffer) override;
-  mozilla::ipc::IPCResult RecvSetChannelParameters(
-      const uint32_t& aPacketLoss, const uint32_t& aRTT) override;
+      InfallibleTArray<GMPVideoFrameType>&& aFrameTypes);
+  mozilla::ipc::IPCResult RecvChildShmemForPool(Shmem&& aEncodedBuffer);
+  mozilla::ipc::IPCResult RecvSetChannelParameters(const uint32_t& aPacketLoss,
+                                                   const uint32_t& aRTT);
   mozilla::ipc::IPCResult RecvSetRates(const uint32_t& aNewBitRate,
-                                       const uint32_t& aFrameRate) override;
-  mozilla::ipc::IPCResult RecvSetPeriodicKeyFrames(
-      const bool& aEnable) override;
-  mozilla::ipc::IPCResult RecvEncodingComplete() override;
+                                       const uint32_t& aFrameRate);
+  mozilla::ipc::IPCResult RecvSetPeriodicKeyFrames(const bool& aEnable);
+  mozilla::ipc::IPCResult RecvEncodingComplete();
 
   GMPContentChild* mPlugin;
   GMPVideoEncoder* mVideoEncoder;
   GMPVideoHostImpl mVideoHost;
 
   // Non-zero when a GMP is blocked spinning the IPC message loop while
   // waiting on an NeedShmem to complete.
   int mNeedShmemIntrCount;
--- a/dom/media/ipc/RDDChild.h
+++ b/dom/media/ipc/RDDChild.h
@@ -28,26 +28,24 @@ class RDDChild final : public PRDDChild 
   explicit RDDChild(RDDProcessHost* aHost);
   ~RDDChild();
 
   void Init();
 
   bool EnsureRDDReady();
 
   // PRDDChild overrides.
-  mozilla::ipc::IPCResult RecvInitComplete() override;
+  mozilla::ipc::IPCResult RecvInitComplete();
   mozilla::ipc::IPCResult RecvInitCrashReporter(
-      Shmem&& shmem, const NativeThreadId& aThreadId) override;
+      Shmem&& shmem, const NativeThreadId& aThreadId);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  mozilla::ipc::IPCResult RecvAddMemoryReport(
-      const MemoryReport& aReport) override;
-  mozilla::ipc::IPCResult RecvFinishMemoryReport(
-      const uint32_t& aGeneration) override;
+  mozilla::ipc::IPCResult RecvAddMemoryReport(const MemoryReport& aReport);
+  mozilla::ipc::IPCResult RecvFinishMemoryReport(const uint32_t& aGeneration);
 
   bool SendRequestMemoryReport(const uint32_t& aGeneration,
                                const bool& aAnonymize,
                                const bool& aMinimizeMemoryUsage,
                                const MaybeFileDesc& aDMDFile);
 
   static void Destroy(UniquePtr<RDDChild>&& aChild);
 
--- a/dom/media/ipc/RDDParent.h
+++ b/dom/media/ipc/RDDParent.h
@@ -19,25 +19,25 @@ class RDDParent final : public PRDDParen
   RDDParent();
   ~RDDParent();
 
   static RDDParent* GetSingleton();
 
   bool Init(base::ProcessId aParentPid, const char* aParentBuildID,
             MessageLoop* aIOLoop, IPC::Channel* aChannel);
 
-  mozilla::ipc::IPCResult RecvInit() override;
+  mozilla::ipc::IPCResult RecvInit();
   mozilla::ipc::IPCResult RecvInitProfiler(
-      Endpoint<PProfilerChild>&& aEndpoint) override;
+      Endpoint<PProfilerChild>&& aEndpoint);
 
   mozilla::ipc::IPCResult RecvNewContentRemoteDecoderManager(
-      Endpoint<PRemoteDecoderManagerParent>&& aEndpoint) override;
+      Endpoint<PRemoteDecoderManagerParent>&& aEndpoint);
   mozilla::ipc::IPCResult RecvRequestMemoryReport(
       const uint32_t& generation, const bool& anonymize,
-      const bool& minimizeMemoryUsage, const MaybeFileDesc& DMDFile) override;
+      const bool& minimizeMemoryUsage, const MaybeFileDesc& DMDFile);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   const TimeStamp mLaunchTime;
 #ifdef MOZ_GECKO_PROFILER
   RefPtr<ChildProfilerController> mProfilerController;
 #endif
--- a/dom/media/ipc/VideoDecoderManagerParent.h
+++ b/dom/media/ipc/VideoDecoderManagerParent.h
@@ -37,19 +37,19 @@ class VideoDecoderManagerParent final : 
       const VideoInfo& aVideoInfo, const float& aFramerate,
       const CreateDecoderParams::OptionSet& aOptions,
       const layers::TextureFactoryIdentifier& aIdentifier, bool* aSuccess,
       nsCString* aBlacklistedD3D11Driver, nsCString* aBlacklistedD3D9Driver,
       nsCString* aErrorDescription);
   bool DeallocPVideoDecoderParent(PVideoDecoderParent* actor);
 
   mozilla::ipc::IPCResult RecvReadback(const SurfaceDescriptorGPUVideo& aSD,
-                                       SurfaceDescriptor* aResult) override;
+                                       SurfaceDescriptor* aResult);
   mozilla::ipc::IPCResult RecvDeallocateSurfaceDescriptorGPUVideo(
-      const SurfaceDescriptorGPUVideo& aSD) override;
+      const SurfaceDescriptorGPUVideo& aSD);
 
   void ActorDestroy(mozilla::ipc::IProtocol::ActorDestroyReason) override;
 
   void DeallocPVideoDecoderManagerParent() override;
 
  private:
   explicit VideoDecoderManagerParent(
       VideoDecoderManagerThreadHolder* aThreadHolder);
--- a/dom/media/systemservices/MediaSystemResourceManagerChild.h
+++ b/dom/media/systemservices/MediaSystemResourceManagerChild.h
@@ -43,17 +43,17 @@ class MediaSystemResourceManagerChild fi
   virtual ~MediaSystemResourceManagerChild();
 
   void Destroy();
 
   void SetManager(MediaSystemResourceManager* aManager) { mManager = aManager; }
 
  protected:
   mozilla::ipc::IPCResult RecvResponse(const uint32_t& aId,
-                                       const bool& aSuccess) override;
+                                       const bool& aSuccess);
 
  private:
   void ActorDestroy(ActorDestroyReason aActorDestroyReason) override;
 
   bool mDestroyed;
   MediaSystemResourceManager* mManager;
 
   friend class mozilla::ipc::BackgroundChildImpl;
--- a/dom/media/systemservices/MediaSystemResourceManagerParent.h
+++ b/dom/media/systemservices/MediaSystemResourceManagerParent.h
@@ -23,21 +23,21 @@ class MediaSystemResourceManagerParent f
 
  public:
   MediaSystemResourceManagerParent();
   virtual ~MediaSystemResourceManagerParent();
 
  protected:
   mozilla::ipc::IPCResult RecvAcquire(
       const uint32_t& aId, const MediaSystemResourceType& aResourceType,
-      const bool& aWillWait) override;
+      const bool& aWillWait);
 
-  mozilla::ipc::IPCResult RecvRelease(const uint32_t& aId) override;
+  mozilla::ipc::IPCResult RecvRelease(const uint32_t& aId);
 
-  mozilla::ipc::IPCResult RecvRemoveResourceManager() override;
+  mozilla::ipc::IPCResult RecvRemoveResourceManager();
 
  private:
   void ActorDestroy(ActorDestroyReason aActorDestroyReason) override;
 
   struct MediaSystemResourceRequest {
     MediaSystemResourceRequest()
         : mId(-1), mResourceType(MediaSystemResourceType::INVALID_RESOURCE) {}
     MediaSystemResourceRequest(uint32_t aId,
--- a/dom/media/webspeech/synth/ipc/SpeechSynthesisChild.h
+++ b/dom/media/webspeech/synth/ipc/SpeechSynthesisChild.h
@@ -19,29 +19,28 @@ class SpeechTaskChild;
 
 class SpeechSynthesisChild : public PSpeechSynthesisChild {
   friend class nsSynthVoiceRegistry;
   friend class PSpeechSynthesisChild;
 
  public:
   mozilla::ipc::IPCResult RecvInitialVoicesAndState(
       nsTArray<RemoteVoice>&& aVoices, nsTArray<nsString>&& aDefaults,
-      const bool& aIsSpeaking) override;
+      const bool& aIsSpeaking);
 
-  mozilla::ipc::IPCResult RecvVoiceAdded(const RemoteVoice& aVoice) override;
+  mozilla::ipc::IPCResult RecvVoiceAdded(const RemoteVoice& aVoice);
 
-  mozilla::ipc::IPCResult RecvVoiceRemoved(const nsString& aUri) override;
+  mozilla::ipc::IPCResult RecvVoiceRemoved(const nsString& aUri);
 
   mozilla::ipc::IPCResult RecvSetDefaultVoice(const nsString& aUri,
-                                              const bool& aIsDefault) override;
+                                              const bool& aIsDefault);
 
-  mozilla::ipc::IPCResult RecvIsSpeakingChanged(
-      const bool& aIsSpeaking) override;
+  mozilla::ipc::IPCResult RecvIsSpeakingChanged(const bool& aIsSpeaking);
 
-  mozilla::ipc::IPCResult RecvNotifyVoicesChanged() override;
+  mozilla::ipc::IPCResult RecvNotifyVoicesChanged();
 
  protected:
   SpeechSynthesisChild();
   virtual ~SpeechSynthesisChild();
 
   PSpeechSynthesisRequestChild* AllocPSpeechSynthesisRequestChild(
       const nsString& aLang, const nsString& aUri, const nsString& aText,
       const float& aVolume, const float& aPitch, const float& aRate,
--- a/dom/messagechannel/MessagePortChild.h
+++ b/dom/messagechannel/MessagePortChild.h
@@ -24,23 +24,23 @@ class MessagePortChild final : public PM
 
   MessagePortChild();
 
   void SetPort(MessagePort* aPort) { mPort = aPort; }
 
  private:
   ~MessagePortChild() { MOZ_ASSERT(!mPort); }
 
-  virtual mozilla::ipc::IPCResult RecvEntangled(
-      nsTArray<ClonedMessageData>&& aMessages) override;
+  mozilla::ipc::IPCResult RecvEntangled(
+      nsTArray<ClonedMessageData>&& aMessages);
 
-  virtual mozilla::ipc::IPCResult RecvReceiveData(
-      nsTArray<ClonedMessageData>&& aMessages) override;
+  mozilla::ipc::IPCResult RecvReceiveData(
+      nsTArray<ClonedMessageData>&& aMessages);
 
-  virtual mozilla::ipc::IPCResult RecvStopSendingDataConfirmed() override;
+  mozilla::ipc::IPCResult RecvStopSendingDataConfirmed();
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
   // This is a raw pointer because this child is owned by this MessagePort.
   MessagePort* mPort;
 };
 
 }  // namespace dom
--- a/dom/messagechannel/MessagePortParent.h
+++ b/dom/messagechannel/MessagePortParent.h
@@ -31,25 +31,25 @@ class MessagePortParent final : public P
   bool CanSendData() const { return mCanSendData; }
 
   const nsID& ID() const { return mUUID; }
 
   static bool ForceClose(const nsID& aUUID, const nsID& aDestinationUUID,
                          const uint32_t& aSequenceID);
 
  private:
-  virtual mozilla::ipc::IPCResult RecvPostMessages(
-      nsTArray<ClonedMessageData>&& aMessages) override;
+  mozilla::ipc::IPCResult RecvPostMessages(
+      nsTArray<ClonedMessageData>&& aMessages);
 
-  virtual mozilla::ipc::IPCResult RecvDisentangle(
-      nsTArray<ClonedMessageData>&& aMessages) override;
+  mozilla::ipc::IPCResult RecvDisentangle(
+      nsTArray<ClonedMessageData>&& aMessages);
 
-  virtual mozilla::ipc::IPCResult RecvStopSendingData() override;
+  mozilla::ipc::IPCResult RecvStopSendingData();
 
-  virtual mozilla::ipc::IPCResult RecvClose() override;
+  mozilla::ipc::IPCResult RecvClose();
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
   RefPtr<MessagePortService> mService;
   const nsID mUUID;
   bool mEntangled;
   bool mCanSendData;
 };
--- a/dom/midi/MIDIManagerParent.h
+++ b/dom/midi/MIDIManagerParent.h
@@ -17,17 +17,17 @@ namespace dom {
  * (represented in DOM by MIDIAccess). Manages actor lifetime so that we know
  * to shut down services when all MIDIManagers are gone.
  *
  */
 class MIDIManagerParent final : public PMIDIManagerParent {
  public:
   NS_INLINE_DECL_REFCOUNTING(MIDIManagerParent);
   MIDIManagerParent() = default;
-  mozilla::ipc::IPCResult RecvShutdown() override;
+  mozilla::ipc::IPCResult RecvShutdown();
   void Teardown();
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   ~MIDIManagerParent() = default;
 };
 
 }  // namespace dom
--- a/dom/midi/MIDIPortChild.h
+++ b/dom/midi/MIDIPortChild.h
@@ -20,23 +20,22 @@ class MIDIPortInfo;
  * Child actor for a MIDIPort object. Each MIDIPort DOM object in JS has a its
  * own child actor. The lifetime of the actor object is dependent on the
  * lifetime of the JS object.
  *
  */
 class MIDIPortChild final : public PMIDIPortChild, public MIDIPortInterface {
  public:
   NS_INLINE_DECL_REFCOUNTING(MIDIPortChild);
-  virtual mozilla::ipc::IPCResult RecvReceive(
-      nsTArray<MIDIMessage>&& aMsgs) override;
+  mozilla::ipc::IPCResult RecvReceive(nsTArray<MIDIMessage>&& aMsgs);
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  virtual mozilla::ipc::IPCResult RecvUpdateStatus(
-      const uint32_t& aDeviceState, const uint32_t& aConnectionState) override;
+  mozilla::ipc::IPCResult RecvUpdateStatus(const uint32_t& aDeviceState,
+                                           const uint32_t& aConnectionState);
 
   MIDIPortChild(const MIDIPortInfo& aPortInfo, bool aSysexEnabled,
                 MIDIPort* aPort);
   // virtual void Shutdown() override;
   void SetActorAlive();
 
   void Teardown();
 
--- a/dom/midi/MIDIPortParent.h
+++ b/dom/midi/MIDIPortParent.h
@@ -18,21 +18,21 @@ namespace dom {
 /**
  * Actor representing the parent (PBackground thread) side of a MIDIPort object.
  *
  */
 class MIDIPortParent final : public PMIDIPortParent, public MIDIPortInterface {
  public:
   NS_INLINE_DECL_REFCOUNTING(MIDIPortParent);
   void ActorDestroy(ActorDestroyReason) override;
-  mozilla::ipc::IPCResult RecvSend(nsTArray<MIDIMessage>&& aMsg) override;
-  mozilla::ipc::IPCResult RecvOpen() override;
-  mozilla::ipc::IPCResult RecvClose() override;
-  mozilla::ipc::IPCResult RecvClear() override;
-  mozilla::ipc::IPCResult RecvShutdown() override;
+  mozilla::ipc::IPCResult RecvSend(nsTArray<MIDIMessage>&& aMsg);
+  mozilla::ipc::IPCResult RecvOpen();
+  mozilla::ipc::IPCResult RecvClose();
+  mozilla::ipc::IPCResult RecvClear();
+  mozilla::ipc::IPCResult RecvShutdown();
   MOZ_IMPLICIT MIDIPortParent(const MIDIPortInfo& aPortInfo,
                               const bool aSysexEnabled);
   // Sends the current port status to the child actor. May also send message
   // buffer if required.
   bool SendUpdateStatus(const MIDIPortDeviceState& aState,
                         const MIDIPortConnectionState& aConnection);
   uint32_t GetInternalId() const { return mInternalId; }
   void Teardown();
--- a/dom/network/TCPServerSocketChild.h
+++ b/dom/network/TCPServerSocketChild.h
@@ -48,16 +48,15 @@ class TCPServerSocketChild : public mozi
 
   TCPServerSocketChild(TCPServerSocket* aServerSocket, uint16_t aLocalPort,
                        uint16_t aBacklog, bool aUseArrayBuffers,
                        nsIEventTarget* aIPCEventTarget);
   ~TCPServerSocketChild();
 
   void Close();
 
-  virtual mozilla::ipc::IPCResult RecvCallbackAccept(
-      PTCPSocketChild* socket) override;
+  mozilla::ipc::IPCResult RecvCallbackAccept(PTCPSocketChild* socket);
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif  // mozilla_dom_TCPServerSocketChild_h
--- a/dom/network/TCPServerSocketParent.h
+++ b/dom/network/TCPServerSocketParent.h
@@ -25,18 +25,18 @@ class TCPServerSocketParent : public moz
   NS_DECL_CYCLE_COLLECTION_CLASS(TCPServerSocketParent)
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 
   TCPServerSocketParent(PNeckoParent* neckoParent, uint16_t aLocalPort,
                         uint16_t aBacklog, bool aUseArrayBuffers);
 
   void Init();
 
-  virtual mozilla::ipc::IPCResult RecvClose() override;
-  virtual mozilla::ipc::IPCResult RecvRequestDelete() override;
+  mozilla::ipc::IPCResult RecvClose();
+  mozilla::ipc::IPCResult RecvRequestDelete();
 
   void AddIPDLReference();
   void ReleaseIPDLReference();
 
   void OnConnect(TCPServerSocketEvent* event);
 
  private:
   ~TCPServerSocketParent();
--- a/dom/network/TCPSocketChild.h
+++ b/dom/network/TCPSocketChild.h
@@ -63,22 +63,22 @@ class TCPSocketChild : public mozilla::n
   nsresult SendSend(const ArrayBuffer& aData, uint32_t aByteOffset,
                     uint32_t aByteLength, uint32_t aTrackingNumber);
   void SendSendArray(nsTArray<uint8_t>* arr, uint32_t trackingNumber);
   void SetSocket(TCPSocket* aSocket);
 
   void GetHost(nsAString& aHost);
   void GetPort(uint16_t* aPort);
 
-  virtual mozilla::ipc::IPCResult RecvCallback(
-      const nsString& aType, const CallbackData& aData,
-      const uint32_t& aReadyState) override;
-  virtual mozilla::ipc::IPCResult RecvRequestDelete() override;
-  virtual mozilla::ipc::IPCResult RecvUpdateBufferedAmount(
-      const uint32_t& aBufferred, const uint32_t& aTrackingNumber) override;
+  mozilla::ipc::IPCResult RecvCallback(const nsString& aType,
+                                       const CallbackData& aData,
+                                       const uint32_t& aReadyState);
+  mozilla::ipc::IPCResult RecvRequestDelete();
+  mozilla::ipc::IPCResult RecvUpdateBufferedAmount(
+      const uint32_t& aBufferred, const uint32_t& aTrackingNumber);
   nsresult SetFilterName(const nsACString& aFilterName);
 
  private:
   nsString mHost;
   uint16_t mPort;
   nsCString mFilterName;
   nsCOMPtr<nsIEventTarget> mIPCEventTarget;
 };
--- a/dom/network/TCPSocketParent.h
+++ b/dom/network/TCPSocketParent.h
@@ -44,33 +44,33 @@ class TCPSocketParentBase : public nsISu
 
 class TCPSocketParent : public mozilla::net::PTCPSocketParent,
                         public TCPSocketParentBase {
  public:
   NS_IMETHOD_(MozExternalRefCountType) Release() override;
 
   TCPSocketParent() {}
 
-  virtual mozilla::ipc::IPCResult RecvOpen(
-      const nsString& aHost, const uint16_t& aPort, const bool& useSSL,
-      const bool& aUseArrayBuffers) override;
+  mozilla::ipc::IPCResult RecvOpen(const nsString& aHost, const uint16_t& aPort,
+                                   const bool& useSSL,
+                                   const bool& aUseArrayBuffers);
 
-  virtual mozilla::ipc::IPCResult RecvOpenBind(
+  mozilla::ipc::IPCResult RecvOpenBind(
       const nsCString& aRemoteHost, const uint16_t& aRemotePort,
       const nsCString& aLocalAddr, const uint16_t& aLocalPort,
       const bool& aUseSSL, const bool& aReuseAddrPort,
-      const bool& aUseArrayBuffers, const nsCString& aFilter) override;
+      const bool& aUseArrayBuffers, const nsCString& aFilter);
 
-  virtual mozilla::ipc::IPCResult RecvStartTLS() override;
-  virtual mozilla::ipc::IPCResult RecvSuspend() override;
-  virtual mozilla::ipc::IPCResult RecvResume() override;
-  virtual mozilla::ipc::IPCResult RecvClose() override;
-  virtual mozilla::ipc::IPCResult RecvData(
-      const SendableData& aData, const uint32_t& aTrackingNumber) override;
-  virtual mozilla::ipc::IPCResult RecvRequestDelete() override;
+  mozilla::ipc::IPCResult RecvStartTLS();
+  mozilla::ipc::IPCResult RecvSuspend();
+  mozilla::ipc::IPCResult RecvResume();
+  mozilla::ipc::IPCResult RecvClose();
+  mozilla::ipc::IPCResult RecvData(const SendableData& aData,
+                                   const uint32_t& aTrackingNumber);
+  mozilla::ipc::IPCResult RecvRequestDelete();
 
   void FireErrorEvent(const nsAString& aName, const nsAString& aType,
                       TCPReadyState aReadyState);
   void FireEvent(const nsAString& aType, TCPReadyState aReadyState);
   void FireArrayBufferDataEvent(nsTArray<uint8_t>& aBuffer,
                                 TCPReadyState aReadyState);
   void FireStringDataEvent(const nsACString& aData, TCPReadyState aReadyState);
 
--- a/dom/network/UDPSocketChild.h
+++ b/dom/network/UDPSocketChild.h
@@ -40,27 +40,26 @@ class UDPSocketChild : public mozilla::n
                        public UDPSocketChildBase {
  public:
   NS_DECL_NSIUDPSOCKETCHILD
   NS_IMETHOD_(MozExternalRefCountType) Release() override;
 
   UDPSocketChild();
   virtual ~UDPSocketChild();
 
-  virtual mozilla::ipc::IPCResult RecvCallbackOpened(
-      const UDPAddressInfo& aAddressInfo) override;
-  virtual mozilla::ipc::IPCResult RecvCallbackConnected(
-      const UDPAddressInfo& aAddressInfo) override;
-  virtual mozilla::ipc::IPCResult RecvCallbackClosed() override;
-  virtual mozilla::ipc::IPCResult RecvCallbackReceivedData(
-      const UDPAddressInfo& aAddressInfo,
-      InfallibleTArray<uint8_t>&& aData) override;
-  virtual mozilla::ipc::IPCResult RecvCallbackError(
-      const nsCString& aMessage, const nsCString& aFilename,
-      const uint32_t& aLineNumber) override;
+  mozilla::ipc::IPCResult RecvCallbackOpened(
+      const UDPAddressInfo& aAddressInfo);
+  mozilla::ipc::IPCResult RecvCallbackConnected(
+      const UDPAddressInfo& aAddressInfo);
+  mozilla::ipc::IPCResult RecvCallbackClosed();
+  mozilla::ipc::IPCResult RecvCallbackReceivedData(
+      const UDPAddressInfo& aAddressInfo, InfallibleTArray<uint8_t>&& aData);
+  mozilla::ipc::IPCResult RecvCallbackError(const nsCString& aMessage,
+                                            const nsCString& aFilename,
+                                            const uint32_t& aLineNumber);
 
  private:
   nsresult SendDataInternal(const UDPSocketAddr& aAddr, const uint8_t* aData,
                             const uint32_t aByteLength);
 
   mozilla::ipc::PBackgroundChild* mBackgroundManager;
   uint16_t mLocalPort;
   nsCString mLocalAddress;
--- a/dom/network/UDPSocketParent.h
+++ b/dom/network/UDPSocketParent.h
@@ -26,38 +26,38 @@ class UDPSocketParent : public mozilla::
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIUDPSOCKETLISTENER
 
   explicit UDPSocketParent(PBackgroundParent* aManager);
   explicit UDPSocketParent(PNeckoParent* aManager);
 
   bool Init(const IPC::Principal& aPrincipal, const nsACString& aFilter);
 
-  virtual mozilla::ipc::IPCResult RecvBind(
-      const UDPAddressInfo& aAddressInfo, const bool& aAddressReuse,
-      const bool& aLoopback, const uint32_t& recvBufferSize,
-      const uint32_t& sendBufferSize) override;
-  virtual mozilla::ipc::IPCResult RecvConnect(
-      const UDPAddressInfo& aAddressInfo) override;
+  mozilla::ipc::IPCResult RecvBind(const UDPAddressInfo& aAddressInfo,
+                                   const bool& aAddressReuse,
+                                   const bool& aLoopback,
+                                   const uint32_t& recvBufferSize,
+                                   const uint32_t& sendBufferSize);
+  mozilla::ipc::IPCResult RecvConnect(const UDPAddressInfo& aAddressInfo);
   void DoSendConnectResponse(const UDPAddressInfo& aAddressInfo);
   void SendConnectResponse(nsIEventTarget* aThread,
                            const UDPAddressInfo& aAddressInfo);
   void DoConnect(nsCOMPtr<nsIUDPSocket>& aSocket,
                  nsCOMPtr<nsIEventTarget>& aReturnThread,
                  const UDPAddressInfo& aAddressInfo);
 
-  virtual mozilla::ipc::IPCResult RecvOutgoingData(
-      const UDPData& aData, const UDPSocketAddr& aAddr) override;
+  mozilla::ipc::IPCResult RecvOutgoingData(const UDPData& aData,
+                                           const UDPSocketAddr& aAddr);
 
-  virtual mozilla::ipc::IPCResult RecvClose() override;
-  virtual mozilla::ipc::IPCResult RecvRequestDelete() override;
-  virtual mozilla::ipc::IPCResult RecvJoinMulticast(
-      const nsCString& aMulticastAddress, const nsCString& aInterface) override;
-  virtual mozilla::ipc::IPCResult RecvLeaveMulticast(
-      const nsCString& aMulticastAddress, const nsCString& aInterface) override;
+  mozilla::ipc::IPCResult RecvClose();
+  mozilla::ipc::IPCResult RecvRequestDelete();
+  mozilla::ipc::IPCResult RecvJoinMulticast(const nsCString& aMulticastAddress,
+                                            const nsCString& aInterface);
+  mozilla::ipc::IPCResult RecvLeaveMulticast(const nsCString& aMulticastAddress,
+                                             const nsCString& aInterface);
 
  private:
   virtual ~UDPSocketParent();
 
   virtual void ActorDestroy(ActorDestroyReason why) override;
   void Send(const InfallibleTArray<uint8_t>& aData, const UDPSocketAddr& aAddr);
   void Send(const IPCStream& aStream, const UDPSocketAddr& aAddr);
   nsresult BindInternal(const nsCString& aHost, const uint16_t& aPort,
--- a/dom/payments/ipc/PaymentRequestChild.h
+++ b/dom/payments/ipc/PaymentRequestChild.h
@@ -21,31 +21,32 @@ class PaymentRequestChild final : public
   explicit PaymentRequestChild(PaymentRequest* aRequest);
 
   void MaybeDelete(bool aCanBeInManager);
 
   nsresult RequestPayment(const IPCPaymentActionRequest& aAction);
 
  protected:
   mozilla::ipc::IPCResult RecvRespondPayment(
-      const IPCPaymentActionResponse& aResponse) override;
+      const IPCPaymentActionResponse& aResponse);
 
   mozilla::ipc::IPCResult RecvChangeShippingAddress(
-      const nsString& aRequestId, const IPCPaymentAddress& aAddress) override;
+      const nsString& aRequestId, const IPCPaymentAddress& aAddress);
+
+  mozilla::ipc::IPCResult RecvChangeShippingOption(const nsString& aRequestId,
+                                                   const nsString& aOption);
 
-  mozilla::ipc::IPCResult RecvChangeShippingOption(
-      const nsString& aRequestId, const nsString& aOption) override;
-
-  mozilla::ipc::IPCResult RecvChangePayerDetail(
-      const nsString& aRequestId, const nsString& aPayerName,
-      const nsString& aPayerEmail, const nsString& aPayerPhone) override;
+  mozilla::ipc::IPCResult RecvChangePayerDetail(const nsString& aRequestId,
+                                                const nsString& aPayerName,
+                                                const nsString& aPayerEmail,
+                                                const nsString& aPayerPhone);
 
   mozilla::ipc::IPCResult RecvChangePaymentMethod(
       const nsString& aRequestId, const nsString& aMethodName,
-      const IPCMethodChangeDetails& aMethodDetails) override;
+      const IPCMethodChangeDetails& aMethodDetails);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   ~PaymentRequestChild() = default;
 
   void DetachFromRequest(bool aCanBeInManager);
 
--- a/dom/payments/ipc/PaymentRequestParent.h
+++ b/dom/payments/ipc/PaymentRequestParent.h
@@ -31,17 +31,17 @@ class PaymentRequestParent final : publi
                              const nsAString& aPayerEmail,
                              const nsAString& aPayerPhone);
   nsresult ChangePaymentMethod(const nsAString& aRequestId,
                                const nsAString& aMethodName,
                                nsIMethodChangeDetails* aMethodDetails);
 
  protected:
   mozilla::ipc::IPCResult RecvRequestPayment(
-      const IPCPaymentActionRequest& aRequest) override;
+      const IPCPaymentActionRequest& aRequest);
 
   mozilla::ipc::IPCResult Recv__delete__() override;
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   ~PaymentRequestParent() = default;
 
--- a/dom/plugins/ipc/BrowserStreamChild.h
+++ b/dom/plugins/ipc/BrowserStreamChild.h
@@ -24,21 +24,20 @@ class BrowserStreamChild : public PBrows
                      StreamNotifyChild* notifyData, const nsCString& headers);
   virtual ~BrowserStreamChild();
 
   virtual bool IsBrowserStream() override { return true; }
 
   NPError StreamConstructed(const nsCString& mimeType, const bool& seekable,
                             uint16_t* stype);
 
-  virtual mozilla::ipc::IPCResult RecvWrite(const int32_t& offset,
-                                            const uint32_t& newsize,
-                                            const Buffer& data) override;
-  virtual mozilla::ipc::IPCResult RecvNPP_DestroyStream(
-      const NPReason& reason) override;
+  mozilla::ipc::IPCResult RecvWrite(const int32_t& offset,
+                                    const uint32_t& newsize,
+                                    const Buffer& data);
+  mozilla::ipc::IPCResult RecvNPP_DestroyStream(const NPReason& reason);
   virtual mozilla::ipc::IPCResult Recv__delete__() override;
 
   void EnsureCorrectInstance(PluginInstanceChild* i) {
     if (i != mInstance) MOZ_CRASH("Incorrect stream instance");
   }
   void EnsureCorrectStream(NPStream* s) {
     if (s != &mStream) MOZ_CRASH("Incorrect stream data");
   }
--- a/dom/plugins/ipc/PluginInstanceChild.h
+++ b/dom/plugins/ipc/PluginInstanceChild.h
@@ -58,121 +58,115 @@ class PluginInstanceChild : public PPlug
   friend LRESULT CALLBACK PluginWindowProc(HWND hWnd, UINT message,
                                            WPARAM wParam, LPARAM lParam);
   static LRESULT CALLBACK PluginWindowProcInternal(HWND hWnd, UINT message,
                                                    WPARAM wParam,
                                                    LPARAM lParam);
 #endif
 
  protected:
-  virtual mozilla::ipc::IPCResult AnswerCreateChildPluginWindow(
-      NativeWindowHandle* aChildPluginWindow) override;
+  mozilla::ipc::IPCResult AnswerCreateChildPluginWindow(
+      NativeWindowHandle* aChildPluginWindow);
 
-  virtual mozilla::ipc::IPCResult RecvCreateChildPopupSurrogate(
-      const NativeWindowHandle& aNetscapeWindow) override;
+  mozilla::ipc::IPCResult RecvCreateChildPopupSurrogate(
+      const NativeWindowHandle& aNetscapeWindow);
 
-  virtual mozilla::ipc::IPCResult AnswerNPP_SetWindow(
-      const NPRemoteWindow& window) override;
+  mozilla::ipc::IPCResult AnswerNPP_SetWindow(const NPRemoteWindow& window);
 
-  virtual mozilla::ipc::IPCResult
-  AnswerNPP_GetValue_NPPVpluginWantsAllNetworkStreams(bool* wantsAllStreams,
-                                                      NPError* rv) override;
-  virtual mozilla::ipc::IPCResult
-  AnswerNPP_GetValue_NPPVpluginScriptableNPObject(
-      PPluginScriptableObjectChild** value, NPError* result) override;
-  virtual mozilla::ipc::IPCResult
-  AnswerNPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId(
-      nsCString* aPlugId, NPError* aResult) override;
-  virtual mozilla::ipc::IPCResult AnswerNPP_SetValue_NPNVprivateModeBool(
-      const bool& value, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPP_SetValue_NPNVmuteAudioBool(
-      const bool& value, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPP_SetValue_NPNVCSSZoomFactor(
-      const double& value, NPError* result) override;
+  mozilla::ipc::IPCResult AnswerNPP_GetValue_NPPVpluginWantsAllNetworkStreams(
+      bool* wantsAllStreams, NPError* rv);
+  mozilla::ipc::IPCResult AnswerNPP_GetValue_NPPVpluginScriptableNPObject(
+      PPluginScriptableObjectChild** value, NPError* result);
+  mozilla::ipc::IPCResult
+  AnswerNPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId(nsCString* aPlugId,
+                                                         NPError* aResult);
+  mozilla::ipc::IPCResult AnswerNPP_SetValue_NPNVprivateModeBool(
+      const bool& value, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPP_SetValue_NPNVmuteAudioBool(
+      const bool& value, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPP_SetValue_NPNVCSSZoomFactor(
+      const double& value, NPError* result);
 
-  virtual mozilla::ipc::IPCResult AnswerNPP_HandleEvent(
-      const NPRemoteEvent& event, int16_t* handled) override;
-  virtual mozilla::ipc::IPCResult AnswerNPP_HandleEvent_Shmem(
-      const NPRemoteEvent& event, Shmem&& mem, int16_t* handled,
-      Shmem* rtnmem) override;
-  virtual mozilla::ipc::IPCResult AnswerNPP_HandleEvent_IOSurface(
-      const NPRemoteEvent& event, const uint32_t& surface,
-      int16_t* handled) override;
+  mozilla::ipc::IPCResult AnswerNPP_HandleEvent(const NPRemoteEvent& event,
+                                                int16_t* handled);
+  mozilla::ipc::IPCResult AnswerNPP_HandleEvent_Shmem(
+      const NPRemoteEvent& event, Shmem&& mem, int16_t* handled, Shmem* rtnmem);
+  mozilla::ipc::IPCResult AnswerNPP_HandleEvent_IOSurface(
+      const NPRemoteEvent& event, const uint32_t& surface, int16_t* handled);
 
   // Async rendering
-  virtual mozilla::ipc::IPCResult RecvAsyncSetWindow(
-      const gfxSurfaceType& aSurfaceType,
-      const NPRemoteWindow& aWindow) override;
+  mozilla::ipc::IPCResult RecvAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
+                                             const NPRemoteWindow& aWindow);
 
   virtual void DoAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
                                 const NPRemoteWindow& aWindow, bool aIsAsync);
 
   PPluginSurfaceChild* AllocPPluginSurfaceChild(
       const WindowsSharedMemoryHandle&, const gfx::IntSize&, const bool&) {
     return new PPluginSurfaceChild();
   }
 
   bool DeallocPPluginSurfaceChild(PPluginSurfaceChild* s) {
     delete s;
     return true;
   }
 
-  virtual mozilla::ipc::IPCResult AnswerPaint(const NPRemoteEvent& event,
-                                              int16_t* handled) override {
+  mozilla::ipc::IPCResult AnswerPaint(const NPRemoteEvent& event,
+                                      int16_t* handled) {
     PaintTracker pt;
     if (!AnswerNPP_HandleEvent(event, handled)) {
       return IPC_FAIL_NO_REASON(this);
     }
     return IPC_OK();
   }
 
-  virtual mozilla::ipc::IPCResult RecvWindowPosChanged(
-      const NPRemoteEvent& event) override;
+  mozilla::ipc::IPCResult RecvWindowPosChanged(const NPRemoteEvent& event);
 
-  virtual mozilla::ipc::IPCResult RecvContentsScaleFactorChanged(
-      const double& aContentsScaleFactor) override;
+  mozilla::ipc::IPCResult RecvContentsScaleFactorChanged(
+      const double& aContentsScaleFactor);
 
-  virtual mozilla::ipc::IPCResult AnswerNPP_Destroy(NPError* result) override;
+  mozilla::ipc::IPCResult AnswerNPP_Destroy(NPError* result);
 
   PPluginScriptableObjectChild* AllocPPluginScriptableObjectChild();
 
   bool DeallocPPluginScriptableObjectChild(
       PPluginScriptableObjectChild* aObject);
 
   virtual mozilla::ipc::IPCResult RecvPPluginScriptableObjectConstructor(
       PPluginScriptableObjectChild* aActor) override;
 
   virtual mozilla::ipc::IPCResult RecvPBrowserStreamConstructor(
       PBrowserStreamChild* aActor, const nsCString& aURL,
       const uint32_t& aLength, const uint32_t& aLastmodified,
       PStreamNotifyChild* aNotifyData, const nsCString& aHeaders) override;
 
-  virtual mozilla::ipc::IPCResult AnswerNPP_NewStream(
-      PBrowserStreamChild* actor, const nsCString& mimeType,
-      const bool& seekable, NPError* rv, uint16_t* stype) override;
+  mozilla::ipc::IPCResult AnswerNPP_NewStream(PBrowserStreamChild* actor,
+                                              const nsCString& mimeType,
+                                              const bool& seekable, NPError* rv,
+                                              uint16_t* stype);
 
   PBrowserStreamChild* AllocPBrowserStreamChild(const nsCString& url,
                                                 const uint32_t& length,
                                                 const uint32_t& lastmodified,
                                                 PStreamNotifyChild* notifyData,
                                                 const nsCString& headers);
 
   bool DeallocPBrowserStreamChild(PBrowserStreamChild* stream);
 
   PStreamNotifyChild* AllocPStreamNotifyChild(
       const nsCString& url, const nsCString& target, const bool& post,
       const nsCString& buffer, const bool& file, NPError* result);
 
   bool DeallocPStreamNotifyChild(PStreamNotifyChild* notifyData);
 
-  virtual mozilla::ipc::IPCResult AnswerSetPluginFocus() override;
+  mozilla::ipc::IPCResult AnswerSetPluginFocus();
 
-  virtual mozilla::ipc::IPCResult AnswerUpdateWindow() override;
+  mozilla::ipc::IPCResult AnswerUpdateWindow();
 
-  virtual mozilla::ipc::IPCResult RecvNPP_DidComposite() override;
+  mozilla::ipc::IPCResult RecvNPP_DidComposite();
 
  public:
   PluginInstanceChild(const NPPluginFuncs* aPluginIface,
                       const nsCString& aMimeType,
                       const InfallibleTArray<nsCString>& aNames,
                       const InfallibleTArray<nsCString>& aValues);
 
   virtual ~PluginInstanceChild();
@@ -212,33 +206,33 @@ class PluginInstanceChild : public PPlug
   NPError NPN_InitAsyncSurface(NPSize* size, NPImageFormat format,
                                void* initData, NPAsyncSurface* surface);
   NPError NPN_FinalizeAsyncSurface(NPAsyncSurface* surface);
 
   void NPN_SetCurrentAsyncSurface(NPAsyncSurface* surface, NPRect* changed);
 
   void DoAsyncRedraw();
 
-  virtual mozilla::ipc::IPCResult RecvHandledWindowedPluginKeyEvent(
-      const NativeEventData& aKeyEventData, const bool& aIsConsumed) override;
+  mozilla::ipc::IPCResult RecvHandledWindowedPluginKeyEvent(
+      const NativeEventData& aKeyEventData, const bool& aIsConsumed);
 
 #if defined(XP_WIN)
   NPError DefaultAudioDeviceChanged(NPAudioDeviceChangeDetails& details);
   NPError AudioDeviceStateChanged(NPAudioDeviceStateChanged& aDeviceState);
 #endif
 
  private:
   friend class PluginModuleChild;
 
   NPError InternalGetNPObjectForValue(NPNVariable aValue, NPObject** aObject);
 
   bool IsUsingDirectDrawing();
 
-  virtual mozilla::ipc::IPCResult RecvUpdateBackground(
-      const SurfaceDescriptor& aBackground, const nsIntRect& aRect) override;
+  mozilla::ipc::IPCResult RecvUpdateBackground(
+      const SurfaceDescriptor& aBackground, const nsIntRect& aRect);
 
   PPluginBackgroundDestroyerChild* AllocPPluginBackgroundDestroyerChild();
 
   mozilla::ipc::IPCResult RecvPPluginBackgroundDestroyerConstructor(
       PPluginBackgroundDestroyerChild* aActor) override;
 
   bool DeallocPPluginBackgroundDestroyerChild(
       PPluginBackgroundDestroyerChild* aActor);
--- a/dom/plugins/ipc/PluginInstanceParent.h
+++ b/dom/plugins/ipc/PluginInstanceParent.h
@@ -78,126 +78,125 @@ class PluginInstanceParent : public PPlu
   bool DeallocPPluginScriptableObjectParent(
       PPluginScriptableObjectParent* aObject);
   PBrowserStreamParent* AllocPBrowserStreamParent(
       const nsCString& url, const uint32_t& length,
       const uint32_t& lastmodified, PStreamNotifyParent* notifyData,
       const nsCString& headers);
   bool DeallocPBrowserStreamParent(PBrowserStreamParent* stream);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVnetscapeWindow(
-      NativeWindowHandle* value, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVWindowNPObject(
-      PPluginScriptableObjectParent** value, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVPluginElementNPObject(
-      PPluginScriptableObjectParent** value, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVprivateModeBool(
-      bool* value, NPError* result) override;
+  mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVnetscapeWindow(
+      NativeWindowHandle* value, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVWindowNPObject(
+      PPluginScriptableObjectParent** value, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVPluginElementNPObject(
+      PPluginScriptableObjectParent** value, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVprivateModeBool(
+      bool* value, NPError* result);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValue_DrawingModelSupport(
-      const NPNVariable& model, bool* value) override;
+  mozilla::ipc::IPCResult AnswerNPN_GetValue_DrawingModelSupport(
+      const NPNVariable& model, bool* value);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVdocumentOrigin(
-      nsCString* value, NPError* result) override;
+  mozilla::ipc::IPCResult AnswerNPN_GetValue_NPNVdocumentOrigin(
+      nsCString* value, NPError* result);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValue_SupportsAsyncBitmapSurface(
-      bool* value) override;
+  mozilla::ipc::IPCResult AnswerNPN_GetValue_SupportsAsyncBitmapSurface(
+      bool* value);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValue_SupportsAsyncDXGISurface(
-      bool* value) override;
+  mozilla::ipc::IPCResult AnswerNPN_GetValue_SupportsAsyncDXGISurface(
+      bool* value);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValue_PreferredDXGIAdapter(
-      DxgiAdapterDesc* desc) override;
+  mozilla::ipc::IPCResult AnswerNPN_GetValue_PreferredDXGIAdapter(
+      DxgiAdapterDesc* desc);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginWindow(
-      const bool& windowed, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginTransparent(
-      const bool& transparent, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginUsesDOMForCursor(
-      const bool& useDOMForCursor, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginDrawingModel(
-      const int& drawingModel, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginEventModel(
-      const int& eventModel, NPError* result) override;
-  virtual mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginIsPlayingAudio(
-      const bool& isAudioPlaying, NPError* result) override;
+  mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginWindow(
+      const bool& windowed, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginTransparent(
+      const bool& transparent, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginUsesDOMForCursor(
+      const bool& useDOMForCursor, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginDrawingModel(
+      const int& drawingModel, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginEventModel(
+      const int& eventModel, NPError* result);
+  mozilla::ipc::IPCResult AnswerNPN_SetValue_NPPVpluginIsPlayingAudio(
+      const bool& isAudioPlaying, NPError* result);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetURL(const nsCString& url,
-                                                   const nsCString& target,
-                                                   NPError* result) override;
+  mozilla::ipc::IPCResult AnswerNPN_GetURL(const nsCString& url,
+                                           const nsCString& target,
+                                           NPError* result);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_PostURL(const nsCString& url,
-                                                    const nsCString& target,
-                                                    const nsCString& buffer,
-                                                    const bool& file,
-                                                    NPError* result) override;
+  mozilla::ipc::IPCResult AnswerNPN_PostURL(const nsCString& url,
+                                            const nsCString& target,
+                                            const nsCString& buffer,
+                                            const bool& file, NPError* result);
 
   PStreamNotifyParent* AllocPStreamNotifyParent(
       const nsCString& url, const nsCString& target, const bool& post,
       const nsCString& buffer, const bool& file, NPError* result);
 
   virtual mozilla::ipc::IPCResult AnswerPStreamNotifyConstructor(
       PStreamNotifyParent* actor, const nsCString& url, const nsCString& target,
       const bool& post, const nsCString& buffer, const bool& file,
       NPError* result) override;
 
   bool DeallocPStreamNotifyParent(PStreamNotifyParent* notifyData);
 
-  virtual mozilla::ipc::IPCResult RecvNPN_InvalidateRect(
-      const NPRect& rect) override;
+  mozilla::ipc::IPCResult RecvNPN_InvalidateRect(const NPRect& rect);
 
-  virtual mozilla::ipc::IPCResult RecvRevokeCurrentDirectSurface() override;
+  mozilla::ipc::IPCResult RecvRevokeCurrentDirectSurface();
 
-  virtual mozilla::ipc::IPCResult RecvInitDXGISurface(
-      const gfx::SurfaceFormat& format, const gfx::IntSize& size,
-      WindowsHandle* outHandle, NPError* outError) override;
-  virtual mozilla::ipc::IPCResult RecvFinalizeDXGISurface(
-      const WindowsHandle& handle) override;
+  mozilla::ipc::IPCResult RecvInitDXGISurface(const gfx::SurfaceFormat& format,
+                                              const gfx::IntSize& size,
+                                              WindowsHandle* outHandle,
+                                              NPError* outError);
+  mozilla::ipc::IPCResult RecvFinalizeDXGISurface(const WindowsHandle& handle);
 
-  virtual mozilla::ipc::IPCResult RecvShowDirectBitmap(
-      Shmem&& buffer, const gfx::SurfaceFormat& format, const uint32_t& stride,
-      const gfx::IntSize& size, const gfx::IntRect& dirty) override;
+  mozilla::ipc::IPCResult RecvShowDirectBitmap(Shmem&& buffer,
+                                               const gfx::SurfaceFormat& format,
+                                               const uint32_t& stride,
+                                               const gfx::IntSize& size,
+                                               const gfx::IntRect& dirty);
 
-  virtual mozilla::ipc::IPCResult RecvShowDirectDXGISurface(
-      const WindowsHandle& handle, const gfx::IntRect& rect) override;
+  mozilla::ipc::IPCResult RecvShowDirectDXGISurface(const WindowsHandle& handle,
+                                                    const gfx::IntRect& rect);
 
   // Async rendering
-  virtual mozilla::ipc::IPCResult RecvShow(
-      const NPRect& updatedRect, const SurfaceDescriptor& newSurface,
-      SurfaceDescriptor* prevSurface) override;
+  mozilla::ipc::IPCResult RecvShow(const NPRect& updatedRect,
+                                   const SurfaceDescriptor& newSurface,
+                                   SurfaceDescriptor* prevSurface);
 
   PPluginSurfaceParent* AllocPPluginSurfaceParent(
       const WindowsSharedMemoryHandle& handle,
       const mozilla::gfx::IntSize& size, const bool& transparent);
 
   bool DeallocPPluginSurfaceParent(PPluginSurfaceParent* s);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_PushPopupsEnabledState(
-      const bool& aState) override;
+  mozilla::ipc::IPCResult AnswerNPN_PushPopupsEnabledState(const bool& aState);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_PopPopupsEnabledState() override;
+  mozilla::ipc::IPCResult AnswerNPN_PopPopupsEnabledState();
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_GetValueForURL(
+  mozilla::ipc::IPCResult AnswerNPN_GetValueForURL(
       const NPNURLVariable& variable, const nsCString& url, nsCString* value,
-      NPError* result) override;
+      NPError* result);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_SetValueForURL(
+  mozilla::ipc::IPCResult AnswerNPN_SetValueForURL(
       const NPNURLVariable& variable, const nsCString& url,
-      const nsCString& value, NPError* result) override;
+      const nsCString& value, NPError* result);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_ConvertPoint(
+  mozilla::ipc::IPCResult AnswerNPN_ConvertPoint(
       const double& sourceX, const bool& ignoreDestX, const double& sourceY,
       const bool& ignoreDestY, const NPCoordinateSpace& sourceSpace,
       const NPCoordinateSpace& destSpace, double* destX, double* destY,
-      bool* result) override;
+      bool* result);
 
-  virtual mozilla::ipc::IPCResult RecvRedrawPlugin() override;
+  mozilla::ipc::IPCResult RecvRedrawPlugin();
 
-  virtual mozilla::ipc::IPCResult RecvSetNetscapeWindowAsParent(
-      const NativeWindowHandle& childWindow) override;
+  mozilla::ipc::IPCResult RecvSetNetscapeWindowAsParent(
+      const NativeWindowHandle& childWindow);
 
   NPError NPP_SetWindow(const NPWindow* aWindow);
 
   NPError NPP_GetValue(NPPVariable variable, void* retval);
   NPError NPP_SetValue(NPNVariable variable, void* value);
 
   void NPP_URLRedirectNotify(const char* url, int32_t status, void* notifyData);
 
@@ -221,18 +220,17 @@ class PluginInstanceParent : public PPlu
   void UnregisterNPObject(NPObject* aObject);
 
   PluginScriptableObjectParent* GetActorForNPObject(NPObject* aObject);
 
   NPP GetNPP() { return mNPP; }
 
   void GetSrcAttribute(nsACString& aOutput) const { aOutput = mSrcAttribute; }
 
-  virtual mozilla::ipc::IPCResult AnswerPluginFocusChange(
-      const bool& gotFocus) override;
+  mozilla::ipc::IPCResult AnswerPluginFocusChange(const bool& gotFocus);
 
   nsresult AsyncSetWindow(NPWindow* window);
   nsresult GetImageContainer(mozilla::layers::ImageContainer** aContainer);
   nsresult GetImageSize(nsIntSize* aSize);
 #ifdef XP_MACOSX
   nsresult IsRemoteDrawingCoreAnimation(bool* aDrawing);
 #endif
 #if defined(XP_MACOSX) || defined(XP_WIN)
@@ -249,30 +247,29 @@ class PluginInstanceParent : public PPlu
 #endif
   void DidComposite();
 
   bool IsUsingDirectDrawing();
 
   static PluginInstanceParent* Cast(NPP instance);
 
   // for IME hook
-  virtual mozilla::ipc::IPCResult RecvGetCompositionString(
-      const uint32_t& aIndex, nsTArray<uint8_t>* aBuffer,
-      int32_t* aLength) override;
-  virtual mozilla::ipc::IPCResult RecvSetCandidateWindow(
-      const mozilla::widget::CandidateWindowPosition& aPosition) override;
-  virtual mozilla::ipc::IPCResult RecvRequestCommitOrCancel(
-      const bool& aCommitted) override;
-  virtual mozilla::ipc::IPCResult RecvEnableIME(const bool& aEnable) override;
+  mozilla::ipc::IPCResult RecvGetCompositionString(const uint32_t& aIndex,
+                                                   nsTArray<uint8_t>* aBuffer,
+                                                   int32_t* aLength);
+  mozilla::ipc::IPCResult RecvSetCandidateWindow(
+      const mozilla::widget::CandidateWindowPosition& aPosition);
+  mozilla::ipc::IPCResult RecvRequestCommitOrCancel(const bool& aCommitted);
+  mozilla::ipc::IPCResult RecvEnableIME(const bool& aEnable);
 
   // for reserved shortcut key handling with windowed plugin on Windows
   nsresult HandledWindowedPluginKeyEvent(
       const mozilla::NativeEventData& aKeyEventData, bool aIsConsumed);
-  virtual mozilla::ipc::IPCResult RecvOnWindowedPluginKeyEvent(
-      const mozilla::NativeEventData& aKeyEventData) override;
+  mozilla::ipc::IPCResult RecvOnWindowedPluginKeyEvent(
+      const mozilla::NativeEventData& aKeyEventData);
 
  private:
   // Create an appropriate platform surface for a background of size
   // |aSize|.  Return true if successful.
   bool CreateBackground(const nsIntSize& aSize);
   void DestroyBackground();
   SurfaceDescriptor BackgroundDescriptor() /*const*/;
 
--- a/dom/plugins/ipc/PluginModuleChild.h
+++ b/dom/plugins/ipc/PluginModuleChild.h
@@ -46,75 +46,70 @@ class PluginModuleChild : public PPlugin
  protected:
   virtual mozilla::ipc::RacyInterruptPolicy MediateInterruptRace(
       const MessageInfo& parent, const MessageInfo& child) override {
     return MediateRace(parent, child);
   }
 
   virtual bool ShouldContinueFromReplyTimeout() override;
 
-  virtual mozilla::ipc::IPCResult RecvSettingChanged(
-      const PluginSettings& aSettings) override;
+  mozilla::ipc::IPCResult RecvSettingChanged(const PluginSettings& aSettings);
 
   // Implement the PPluginModuleChild interface
-  virtual mozilla::ipc::IPCResult RecvInitProfiler(
-      Endpoint<mozilla::PProfilerChild>&& aEndpoint) override;
-  virtual mozilla::ipc::IPCResult RecvDisableFlashProtectedMode() override;
-  virtual mozilla::ipc::IPCResult AnswerNP_GetEntryPoints(NPError* rv) override;
-  virtual mozilla::ipc::IPCResult AnswerNP_Initialize(
-      const PluginSettings& aSettings, NPError* rv) override;
-  virtual mozilla::ipc::IPCResult AnswerSyncNPP_New(
-      PPluginInstanceChild* aActor, NPError* rv) override;
+  mozilla::ipc::IPCResult RecvInitProfiler(
+      Endpoint<mozilla::PProfilerChild>&& aEndpoint);
+  mozilla::ipc::IPCResult RecvDisableFlashProtectedMode();
+  mozilla::ipc::IPCResult AnswerNP_GetEntryPoints(NPError* rv);
+  mozilla::ipc::IPCResult AnswerNP_Initialize(const PluginSettings& aSettings,
+                                              NPError* rv);
+  mozilla::ipc::IPCResult AnswerSyncNPP_New(PPluginInstanceChild* aActor,
+                                            NPError* rv);
 
-  virtual mozilla::ipc::IPCResult RecvInitPluginModuleChild(
-      Endpoint<PPluginModuleChild>&& endpoint) override;
+  mozilla::ipc::IPCResult RecvInitPluginModuleChild(
+      Endpoint<PPluginModuleChild>&& endpoint);
 
-  virtual mozilla::ipc::IPCResult RecvInitPluginFunctionBroker(
-      Endpoint<PFunctionBrokerChild>&& endpoint) override;
+  mozilla::ipc::IPCResult RecvInitPluginFunctionBroker(
+      Endpoint<PFunctionBrokerChild>&& endpoint);
 
   PPluginInstanceChild* AllocPPluginInstanceChild(
       const nsCString& aMimeType, const InfallibleTArray<nsCString>& aNames,
       const InfallibleTArray<nsCString>& aValues);
 
   bool DeallocPPluginInstanceChild(PPluginInstanceChild* aActor);
 
-  virtual mozilla::ipc::IPCResult RecvPPluginInstanceConstructor(
+  mozilla::ipc::IPCResult RecvPPluginInstanceConstructor(
       PPluginInstanceChild* aActor, const nsCString& aMimeType,
       InfallibleTArray<nsCString>&& aNames,
       InfallibleTArray<nsCString>&& aValues) override;
-  virtual mozilla::ipc::IPCResult AnswerNP_Shutdown(NPError* rv) override;
+  mozilla::ipc::IPCResult AnswerNP_Shutdown(NPError* rv);
+
+  mozilla::ipc::IPCResult AnswerOptionalFunctionsSupported(
+      bool* aURLRedirectNotify, bool* aClearSiteData, bool* aGetSitesWithData);
 
-  virtual mozilla::ipc::IPCResult AnswerOptionalFunctionsSupported(
-      bool* aURLRedirectNotify, bool* aClearSiteData,
-      bool* aGetSitesWithData) override;
-
-  virtual mozilla::ipc::IPCResult RecvNPP_ClearSiteData(
-      const nsCString& aSite, const uint64_t& aFlags, const uint64_t& aMaxAge,
-      const uint64_t& aCallbackId) override;
+  mozilla::ipc::IPCResult RecvNPP_ClearSiteData(const nsCString& aSite,
+                                                const uint64_t& aFlags,
+                                                const uint64_t& aMaxAge,
+                                                const uint64_t& aCallbackId);
 
-  virtual mozilla::ipc::IPCResult RecvNPP_GetSitesWithData(
-      const uint64_t& aCallbackId) override;
+  mozilla::ipc::IPCResult RecvNPP_GetSitesWithData(const uint64_t& aCallbackId);
 
-  virtual mozilla::ipc::IPCResult RecvSetAudioSessionData(
-      const nsID& aId, const nsString& aDisplayName,
-      const nsString& aIconPath) override;
+  mozilla::ipc::IPCResult RecvSetAudioSessionData(const nsID& aId,
+                                                  const nsString& aDisplayName,
+                                                  const nsString& aIconPath);
 
-  virtual mozilla::ipc::IPCResult RecvSetParentHangTimeout(
-      const uint32_t& aSeconds) override;
+  mozilla::ipc::IPCResult RecvSetParentHangTimeout(const uint32_t& aSeconds);
 
-  virtual mozilla::ipc::IPCResult AnswerInitCrashReporter(
-      Shmem&& aShmem, mozilla::dom::NativeThreadId* aId) override;
+  mozilla::ipc::IPCResult AnswerInitCrashReporter(
+      Shmem&& aShmem, mozilla::dom::NativeThreadId* aId);
 
   virtual void ActorDestroy(ActorDestroyReason why) override;
 
-  virtual mozilla::ipc::IPCResult RecvProcessNativeEventsInInterruptCall()
-      override;
+  mozilla::ipc::IPCResult RecvProcessNativeEventsInInterruptCall();
 
-  virtual mozilla::ipc::IPCResult AnswerModuleSupportsAsyncRender(
-      bool* aResult) override;
+  mozilla::ipc::IPCResult AnswerModuleSupportsAsyncRender(bool* aResult);
 
  public:
   explicit PluginModuleChild(bool aIsChrome);
   virtual ~PluginModuleChild();
 
   void CommonInit();
 
 #if defined(OS_WIN) && defined(MOZ_SANDBOX)
@@ -193,19 +188,19 @@ class PluginModuleChild : public PPlugin
 
   int GetQuirks() { return mQuirks; }
 
   const PluginSettings& Settings() const { return mCachedSettings; }
 
   NPError PluginRequiresAudioDeviceChanges(PluginInstanceChild* aInstance,
                                            NPBool aShouldRegister);
   mozilla::ipc::IPCResult RecvNPP_SetValue_NPNVaudioDeviceChangeDetails(
-      const NPAudioDeviceChangeDetailsIPC& detailsIPC) override;
+      const NPAudioDeviceChangeDetailsIPC& detailsIPC);
   mozilla::ipc::IPCResult RecvNPP_SetValue_NPNVaudioDeviceStateChanged(
-      const NPAudioDeviceStateChangedIPC& aDeviceStateIPC) override;
+      const NPAudioDeviceStateChangedIPC& aDeviceStateIPC);
 
  private:
   NPError DoNP_Initialize(const PluginSettings& aSettings);
   void AddQuirk(PluginQuirks quirk) {
     if (mQuirks == QUIRKS_NOT_INITIALIZED) mQuirks = 0;
     mQuirks |= quirk;
   }
   void InitQuirksModes(const nsCString& aMimeType);
--- a/dom/plugins/ipc/PluginModuleParent.h
+++ b/dom/plugins/ipc/PluginModuleParent.h
@@ -110,68 +110,62 @@ class PluginModuleParent : public PPlugi
   int GetQuirks() { return mQuirks; }
 
  protected:
   virtual mozilla::ipc::RacyInterruptPolicy MediateInterruptRace(
       const MessageInfo& parent, const MessageInfo& child) override {
     return MediateRace(parent, child);
   }
 
-  virtual mozilla::ipc::IPCResult RecvBackUpXResources(
-      const FileDescriptor& aXSocketFd) override;
+  mozilla::ipc::IPCResult RecvBackUpXResources(
+      const FileDescriptor& aXSocketFd);
 
-  virtual mozilla::ipc::IPCResult AnswerProcessSomeEvents() override;
+  mozilla::ipc::IPCResult AnswerProcessSomeEvents();
 
-  virtual mozilla::ipc::IPCResult RecvProcessNativeEventsInInterruptCall()
-      override;
+  mozilla::ipc::IPCResult RecvProcessNativeEventsInInterruptCall();
 
-  virtual mozilla::ipc::IPCResult RecvPluginShowWindow(
+  mozilla::ipc::IPCResult RecvPluginShowWindow(
       const uint32_t& aWindowId, const bool& aModal, const int32_t& aX,
-      const int32_t& aY, const size_t& aWidth, const size_t& aHeight) override;
-
-  virtual mozilla::ipc::IPCResult RecvPluginHideWindow(
-      const uint32_t& aWindowId) override;
+      const int32_t& aY, const size_t& aWidth, const size_t& aHeight);
 
-  virtual mozilla::ipc::IPCResult RecvSetCursor(
-      const NSCursorInfo& aCursorInfo) override;
+  mozilla::ipc::IPCResult RecvPluginHideWindow(const uint32_t& aWindowId);
 
-  virtual mozilla::ipc::IPCResult RecvShowCursor(const bool& aShow) override;
+  mozilla::ipc::IPCResult RecvSetCursor(const NSCursorInfo& aCursorInfo);
 
-  virtual mozilla::ipc::IPCResult RecvPushCursor(
-      const NSCursorInfo& aCursorInfo) override;
+  mozilla::ipc::IPCResult RecvShowCursor(const bool& aShow);
 
-  virtual mozilla::ipc::IPCResult RecvPopCursor() override;
+  mozilla::ipc::IPCResult RecvPushCursor(const NSCursorInfo& aCursorInfo);
+
+  mozilla::ipc::IPCResult RecvPopCursor();
 
-  virtual mozilla::ipc::IPCResult RecvNPN_SetException(
-      const nsCString& aMessage) override;
+  mozilla::ipc::IPCResult RecvNPN_SetException(const nsCString& aMessage);
 
-  virtual mozilla::ipc::IPCResult RecvNPN_ReloadPlugins(
-      const bool& aReloadPages) override;
+  mozilla::ipc::IPCResult RecvNPN_ReloadPlugins(const bool& aReloadPages);
 
   static BrowserStreamParent* StreamCast(NPP instance, NPStream* s);
 
   virtual mozilla::ipc::IPCResult
   AnswerNPN_SetValue_NPPVpluginRequiresAudioDeviceChanges(
-      const bool& shouldRegister, NPError* result) override;
+      const bool& shouldRegister, NPError* result);
 
  protected:
   void SetChildTimeout(const int32_t aChildTimeout);
   static void TimeoutChanged(const char* aPref, PluginModuleParent* aModule);
 
   virtual void UpdatePluginTimeout() {}
 
-  virtual mozilla::ipc::IPCResult RecvNotifyContentModuleDestroyed() override {
+  virtual mozilla::ipc::IPCResult RecvNotifyContentModuleDestroyed() {
     return IPC_OK();
   }
 
-  virtual mozilla::ipc::IPCResult RecvReturnClearSiteData(
-      const NPError& aRv, const uint64_t& aCallbackId) override;
+  mozilla::ipc::IPCResult RecvReturnClearSiteData(const NPError& aRv,
+                                                  const uint64_t& aCallbackId);
 
-  virtual mozilla::ipc::IPCResult RecvReturnSitesWithData(
-      nsTArray<nsCString>&& aSites, const uint64_t& aCallbackId) override;
+  mozilla::ipc::IPCResult RecvReturnSitesWithData(nsTArray<nsCString>&& aSites,
+                                                  const uint64_t& aCallbackId);
 
   void SetPluginFuncs(NPPluginFuncs* aFuncs);
 
   nsresult NPP_NewInternal(NPMIMEType pluginType, NPP instance,
                            InfallibleTArray<nsCString>& names,
                            InfallibleTArray<nsCString>& values,
                            NPSavedData* saved, NPError* error);
 
@@ -456,22 +450,22 @@ class PluginModuleChromeParent : public 
 
   virtual void UpdatePluginTimeout() override;
 
   void RegisterSettingsCallbacks();
   void UnregisterSettingsCallbacks();
 
   bool InitCrashReporter();
 
-  virtual mozilla::ipc::IPCResult RecvNotifyContentModuleDestroyed() override;
+  mozilla::ipc::IPCResult RecvNotifyContentModuleDestroyed() override;
 
   static void CachedSettingChanged(const char* aPref,
                                    PluginModuleChromeParent* aModule);
 
-  virtual mozilla::ipc::IPCResult
+  mozilla::ipc::IPCResult
   AnswerNPN_SetValue_NPPVpluginRequiresAudioDeviceChanges(
       const bool& shouldRegister, NPError* result) override;
 
   PluginProcessParent* mSubprocess;
   uint32_t mPluginId;
 
   ipc::TaskFactory<PluginModuleChromeParent> mChromeTaskFactory;
 
--- a/dom/plugins/ipc/PluginScriptableObjectChild.h
+++ b/dom/plugins/ipc/PluginScriptableObjectChild.h
@@ -39,53 +39,53 @@ class PluginScriptableObjectChild : publ
  public:
   explicit PluginScriptableObjectChild(ScriptableObjectType aType);
   virtual ~PluginScriptableObjectChild();
 
   bool InitializeProxy();
 
   void InitializeLocal(NPObject* aObject);
 
-  virtual mozilla::ipc::IPCResult AnswerInvalidate() override;
+  mozilla::ipc::IPCResult AnswerInvalidate();
 
-  virtual mozilla::ipc::IPCResult AnswerHasMethod(const PluginIdentifier& aId,
-                                                  bool* aHasMethod) override;
+  mozilla::ipc::IPCResult AnswerHasMethod(const PluginIdentifier& aId,
+                                          bool* aHasMethod);
 
-  virtual mozilla::ipc::IPCResult AnswerInvoke(
-      const PluginIdentifier& aId, InfallibleTArray<Variant>&& aArgs,
-      Variant* aResult, bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerInvoke(const PluginIdentifier& aId,
+                                       InfallibleTArray<Variant>&& aArgs,
+                                       Variant* aResult, bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerInvokeDefault(
-      InfallibleTArray<Variant>&& aArgs, Variant* aResult,
-      bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerInvokeDefault(InfallibleTArray<Variant>&& aArgs,
+                                              Variant* aResult, bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerHasProperty(
-      const PluginIdentifier& aId, bool* aHasProperty) override;
+  mozilla::ipc::IPCResult AnswerHasProperty(const PluginIdentifier& aId,
+                                            bool* aHasProperty);
 
-  virtual mozilla::ipc::IPCResult AnswerGetChildProperty(
-      const PluginIdentifier& aId, bool* aHasProperty, bool* aHasMethod,
-      Variant* aResult, bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerGetChildProperty(const PluginIdentifier& aId,
+                                                 bool* aHasProperty,
+                                                 bool* aHasMethod,
+                                                 Variant* aResult,
+                                                 bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerSetProperty(const PluginIdentifier& aId,
-                                                    const Variant& aValue,
-                                                    bool* aSuccess) override;
-
-  virtual mozilla::ipc::IPCResult AnswerRemoveProperty(
-      const PluginIdentifier& aId, bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerSetProperty(const PluginIdentifier& aId,
+                                            const Variant& aValue,
+                                            bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerEnumerate(
-      InfallibleTArray<PluginIdentifier>* aProperties, bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerRemoveProperty(const PluginIdentifier& aId,
+                                               bool* aSuccess);
+
+  mozilla::ipc::IPCResult AnswerEnumerate(
+      InfallibleTArray<PluginIdentifier>* aProperties, bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerConstruct(
-      InfallibleTArray<Variant>&& aArgs, Variant* aResult,
-      bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerConstruct(InfallibleTArray<Variant>&& aArgs,
+                                          Variant* aResult, bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult RecvProtect() override;
+  mozilla::ipc::IPCResult RecvProtect();
 
-  virtual mozilla::ipc::IPCResult RecvUnprotect() override;
+  mozilla::ipc::IPCResult RecvUnprotect();
 
   NPObject* GetObject(bool aCanResurrect);
 
   static const NPClass* GetClass() { return &sNPClass; }
 
   PluginInstanceChild* GetInstance() const { return mInstance; }
 
   // Protect only affects LocalObject actors. It is called by the
--- a/dom/plugins/ipc/PluginScriptableObjectParent.h
+++ b/dom/plugins/ipc/PluginScriptableObjectParent.h
@@ -38,54 +38,52 @@ class PluginScriptableObjectParent : pub
   virtual ~PluginScriptableObjectParent();
 
   void InitializeProxy();
 
   void InitializeLocal(NPObject* aObject);
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  virtual mozilla::ipc::IPCResult AnswerHasMethod(const PluginIdentifier& aId,
-                                                  bool* aHasMethod) override;
+  mozilla::ipc::IPCResult AnswerHasMethod(const PluginIdentifier& aId,
+                                          bool* aHasMethod);
 
-  virtual mozilla::ipc::IPCResult AnswerInvoke(
-      const PluginIdentifier& aId, InfallibleTArray<Variant>&& aArgs,
-      Variant* aResult, bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerInvoke(const PluginIdentifier& aId,
+                                       InfallibleTArray<Variant>&& aArgs,
+                                       Variant* aResult, bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerInvokeDefault(
-      InfallibleTArray<Variant>&& aArgs, Variant* aResult,
-      bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerInvokeDefault(InfallibleTArray<Variant>&& aArgs,
+                                              Variant* aResult, bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerHasProperty(
-      const PluginIdentifier& aId, bool* aHasProperty) override;
+  mozilla::ipc::IPCResult AnswerHasProperty(const PluginIdentifier& aId,
+                                            bool* aHasProperty);
 
-  virtual mozilla::ipc::IPCResult AnswerGetParentProperty(
-      const PluginIdentifier& aId, Variant* aResult, bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerGetParentProperty(const PluginIdentifier& aId,
+                                                  Variant* aResult,
+                                                  bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerSetProperty(const PluginIdentifier& aId,
-                                                    const Variant& aValue,
-                                                    bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerSetProperty(const PluginIdentifier& aId,
+                                            const Variant& aValue,
+                                            bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerRemoveProperty(
-      const PluginIdentifier& aId, bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerRemoveProperty(const PluginIdentifier& aId,
+                                               bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerEnumerate(
-      InfallibleTArray<PluginIdentifier>* aProperties, bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerEnumerate(
+      InfallibleTArray<PluginIdentifier>* aProperties, bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerConstruct(
-      InfallibleTArray<Variant>&& aArgs, Variant* aResult,
-      bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerConstruct(InfallibleTArray<Variant>&& aArgs,
+                                          Variant* aResult, bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult AnswerNPN_Evaluate(const nsCString& aScript,
-                                                     Variant* aResult,
-                                                     bool* aSuccess) override;
+  mozilla::ipc::IPCResult AnswerNPN_Evaluate(const nsCString& aScript,
+                                             Variant* aResult, bool* aSuccess);
 
-  virtual mozilla::ipc::IPCResult RecvProtect() override;
+  mozilla::ipc::IPCResult RecvProtect();
 
-  virtual mozilla::ipc::IPCResult RecvUnprotect() override;
+  mozilla::ipc::IPCResult RecvUnprotect();
 
   static const NPClass* GetClass() { return &sNPClass; }
 
   PluginInstanceParent* GetInstance() const { return mInstance; }
 
   NPObject* GetObject(bool aCanResurrect);
 
   // Protect only affects LocalObject actors. It is called by the
--- a/dom/plugins/ipc/StreamNotifyChild.h
+++ b/dom/plugins/ipc/StreamNotifyChild.h
@@ -29,17 +29,17 @@ class StreamNotifyChild : public PStream
 
   void NPP_URLNotify(NPReason reason);
 
  private:
   virtual mozilla::ipc::IPCResult Recv__delete__(
       const NPReason& reason) override;
 
   mozilla::ipc::IPCResult RecvRedirectNotify(const nsCString& url,
-                                             const int32_t& status) override;
+                                             const int32_t& status);
 
   /**
    * If a stream is created for this this URLNotify, we associate the objects
    * so that the NPP_URLNotify call is not fired before the stream data is
    * completely delivered. The BrowserStreamChild takes responsibility for
    * calling NPP_URLNotify and deleting this object.
    */
   void SetAssociatedStream(BrowserStreamChild* bs);
--- a/dom/plugins/ipc/StreamNotifyParent.h
+++ b/dom/plugins/ipc/StreamNotifyParent.h
@@ -25,18 +25,17 @@ class StreamNotifyParent : public PStrea
   // If we are destroyed within the call to NPN_GetURLNotify, notify the caller
   // 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) override;
 
  private:
-  mozilla::ipc::IPCResult RecvRedirectNotifyResponse(
-      const bool& allow) override;
+  mozilla::ipc::IPCResult RecvRedirectNotifyResponse(const bool& allow);
 
   bool* mDestructionFlag;
 };
 
 }  // namespace plugins
 }  // namespace mozilla
 
 #endif
--- a/dom/presentation/ipc/PresentationBuilderChild.h
+++ b/dom/presentation/ipc/PresentationBuilderChild.h
@@ -21,22 +21,21 @@ class PresentationBuilderChild final
   NS_DECL_NSIPRESENTATIONSESSIONTRANSPORTBUILDERLISTENER
 
   explicit PresentationBuilderChild(const nsString& aSessionId, uint8_t aRole);
 
   nsresult Init();
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  virtual mozilla::ipc::IPCResult RecvOnOffer(const nsString& aSDP) override;
+  mozilla::ipc::IPCResult RecvOnOffer(const nsString& aSDP);
 
-  virtual mozilla::ipc::IPCResult RecvOnAnswer(const nsString& aSDP) override;
+  mozilla::ipc::IPCResult RecvOnAnswer(const nsString& aSDP);
 
-  virtual mozilla::ipc::IPCResult RecvOnIceCandidate(
-      const nsString& aCandidate) override;
+  mozilla::ipc::IPCResult RecvOnIceCandidate(const nsString& aCandidate);
 
  private:
   virtual ~PresentationBuilderChild() = default;
 
   nsString mSessionId;
   uint8_t mRole;
   bool mActorDestroyed = false;
   nsCOMPtr<nsIPresentationDataChannelSessionTransportBuilder> mBuilder;
--- a/dom/presentation/ipc/PresentationBuilderParent.h
+++ b/dom/presentation/ipc/PresentationBuilderParent.h
@@ -19,31 +19,29 @@ class PresentationBuilderParent final
       public nsIPresentationDataChannelSessionTransportBuilder {
  public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIPRESENTATIONSESSIONTRANSPORTBUILDER
   NS_DECL_NSIPRESENTATIONDATACHANNELSESSIONTRANSPORTBUILDER
 
   explicit PresentationBuilderParent(PresentationParent* aParent);
 
-  virtual mozilla::ipc::IPCResult RecvSendOffer(const nsString& aSDP) override;
+  mozilla::ipc::IPCResult RecvSendOffer(const nsString& aSDP);
 
-  virtual mozilla::ipc::IPCResult RecvSendAnswer(const nsString& aSDP) override;
+  mozilla::ipc::IPCResult RecvSendAnswer(const nsString& aSDP);
 
-  virtual mozilla::ipc::IPCResult RecvSendIceCandidate(
-      const nsString& aCandidate) override;
+  mozilla::ipc::IPCResult RecvSendIceCandidate(const nsString& aCandidate);
 
-  virtual mozilla::ipc::IPCResult RecvClose(const nsresult& aReason) override;
+  mozilla::ipc::IPCResult RecvClose(const nsresult& aReason);
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  virtual mozilla::ipc::IPCResult RecvOnSessionTransport() override;
+  mozilla::ipc::IPCResult RecvOnSessionTransport();
 
-  virtual mozilla::ipc::IPCResult RecvOnSessionTransportError(
-      const nsresult& aReason) override;
+  mozilla::ipc::IPCResult RecvOnSessionTransportError(const nsresult& aReason);
 
  private:
   virtual ~PresentationBuilderParent();
   bool mNeedDestroyActor = false;
   RefPtr<PresentationParent> mParent;
   nsCOMPtr<nsIPresentationSessionTransportBuilderListener> mBuilderListener;
   nsCOMPtr<nsIPresentationSessionTransport> mIPCSessionTransport;
 };
--- a/dom/presentation/ipc/PresentationChild.h
+++ b/dom/presentation/ipc/PresentationChild.h
@@ -33,33 +33,33 @@ class PresentationChild final : public P
       PPresentationBuilderChild* aActor, const nsString& aSessionId,
       const uint8_t& aRole) override;
 
   PPresentationBuilderChild* AllocPPresentationBuilderChild(
       const nsString& aSessionId, const uint8_t& aRole);
 
   bool DeallocPPresentationBuilderChild(PPresentationBuilderChild* aActor);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyAvailableChange(
-      nsTArray<nsString>&& aAvailabilityUrls, const bool& aAvailable) override;
+  mozilla::ipc::IPCResult RecvNotifyAvailableChange(
+      nsTArray<nsString>&& aAvailabilityUrls, const bool& aAvailable);
 
-  virtual mozilla::ipc::IPCResult RecvNotifySessionStateChange(
+  mozilla::ipc::IPCResult RecvNotifySessionStateChange(
       const nsString& aSessionId, const uint16_t& aState,
-      const nsresult& aReason) override;
+      const nsresult& aReason);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyMessage(
-      const nsString& aSessionId, const nsCString& aData,
-      const bool& aIsBinary) override;
+  mozilla::ipc::IPCResult RecvNotifyMessage(const nsString& aSessionId,
+                                            const nsCString& aData,
+                                            const bool& aIsBinary);
 
-  virtual mozilla::ipc::IPCResult RecvNotifySessionConnect(
-      const uint64_t& aWindowId, const nsString& aSessionId) override;
+  mozilla::ipc::IPCResult RecvNotifySessionConnect(const uint64_t& aWindowId,
+                                                   const nsString& aSessionId);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyCloseSessionTransport(
+  mozilla::ipc::IPCResult RecvNotifyCloseSessionTransport(
       const nsString& aSessionId, const uint8_t& aRole,
-      const nsresult& aReason) override;
+      const nsresult& aReason);
 
  private:
   virtual ~PresentationChild();
 
   bool mActorDestroyed = false;
   RefPtr<PresentationIPCService> mService;
 };
 
@@ -69,18 +69,17 @@ class PresentationRequestChild final : p
  public:
   explicit PresentationRequestChild(nsIPresentationServiceCallback* aCallback);
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
   virtual mozilla::ipc::IPCResult Recv__delete__(
       const nsresult& aResult) override;
 
-  virtual mozilla::ipc::IPCResult RecvNotifyRequestUrlSelected(
-      const nsString& aUrl) override;
+  mozilla::ipc::IPCResult RecvNotifyRequestUrlSelected(const nsString& aUrl);
 
  private:
   virtual ~PresentationRequestChild();
 
   bool mActorDestroyed = false;
   nsCOMPtr<nsIPresentationServiceCallback> mCallback;
 };
 
--- a/dom/presentation/ipc/PresentationParent.h
+++ b/dom/presentation/ipc/PresentationParent.h
@@ -48,41 +48,41 @@ class PresentationParent final : public 
 
   PPresentationBuilderParent* AllocPPresentationBuilderParent(
       const nsString& aSessionId, const uint8_t& aRole);
 
   bool DeallocPPresentationBuilderParent(PPresentationBuilderParent* aActor);
 
   virtual mozilla::ipc::IPCResult Recv__delete__() override;
 
-  virtual mozilla::ipc::IPCResult RecvRegisterAvailabilityHandler(
-      nsTArray<nsString>&& aAvailabilityUrls) override;
+  mozilla::ipc::IPCResult RecvRegisterAvailabilityHandler(
+      nsTArray<nsString>&& aAvailabilityUrls);
 
-  virtual mozilla::ipc::IPCResult RecvUnregisterAvailabilityHandler(
-      nsTArray<nsString>&& aAvailabilityUrls) override;
+  mozilla::ipc::IPCResult RecvUnregisterAvailabilityHandler(
+      nsTArray<nsString>&& aAvailabilityUrls);
 
-  virtual mozilla::ipc::IPCResult RecvRegisterSessionHandler(
-      const nsString& aSessionId, const uint8_t& aRole) override;
+  mozilla::ipc::IPCResult RecvRegisterSessionHandler(const nsString& aSessionId,
+                                                     const uint8_t& aRole);
 
-  virtual mozilla::ipc::IPCResult RecvUnregisterSessionHandler(
-      const nsString& aSessionId, const uint8_t& aRole) override;
+  mozilla::ipc::IPCResult RecvUnregisterSessionHandler(
+      const nsString& aSessionId, const uint8_t& aRole);
 
-  virtual mozilla::ipc::IPCResult RecvRegisterRespondingHandler(
-      const uint64_t& aWindowId) override;
+  mozilla::ipc::IPCResult RecvRegisterRespondingHandler(
+      const uint64_t& aWindowId);
 
-  virtual mozilla::ipc::IPCResult RecvUnregisterRespondingHandler(
-      const uint64_t& aWindowId) override;
+  mozilla::ipc::IPCResult RecvUnregisterRespondingHandler(
+      const uint64_t& aWindowId);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyReceiverReady(
-      const nsString& aSessionId, const uint64_t& aWindowId,
-      const bool& aIsLoading) override;
+  mozilla::ipc::IPCResult RecvNotifyReceiverReady(const nsString& aSessionId,
+                                                  const uint64_t& aWindowId,
+                                                  const bool& aIsLoading);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyTransportClosed(
-      const nsString& aSessionId, const uint8_t& aRole,
-      const nsresult& aReason) override;
+  mozilla::ipc::IPCResult RecvNotifyTransportClosed(const nsString& aSessionId,
+                                                    const uint8_t& aRole,
+                                                    const nsresult& aReason);
 
  private:
   virtual ~PresentationParent();
 
   bool mActorDestroyed = false;
   nsCOMPtr<nsIPresentationService> mService;
   nsTArray<nsString> mSessionIdsAtController;
   nsTArray<nsString> mSessionIdsAtReceiver;
--- a/dom/serviceworkers/ServiceWorkerManagerChild.h
+++ b/dom/serviceworkers/ServiceWorkerManagerChild.h
@@ -23,30 +23,28 @@ namespace dom {
 class ServiceWorkerManagerChild final : public PServiceWorkerManagerChild {
   friend class mozilla::ipc::BackgroundChildImpl;
 
  public:
   NS_INLINE_DECL_REFCOUNTING(ServiceWorkerManagerChild)
 
   void ManagerShuttingDown() { mShuttingDown = true; }
 
-  virtual mozilla::ipc::IPCResult RecvNotifyRegister(
-      const ServiceWorkerRegistrationData& aData) override;
+  mozilla::ipc::IPCResult RecvNotifyRegister(
+      const ServiceWorkerRegistrationData& aData);
 
-  virtual mozilla::ipc::IPCResult RecvNotifySoftUpdate(
-      const OriginAttributes& aOriginAttributes,
-      const nsString& aScope) override;
+  mozilla::ipc::IPCResult RecvNotifySoftUpdate(
+      const OriginAttributes& aOriginAttributes, const nsString& aScope);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyUnregister(
-      const PrincipalInfo& aPrincipalInfo, const nsString& aScope) override;
+  mozilla::ipc::IPCResult RecvNotifyUnregister(
+      const PrincipalInfo& aPrincipalInfo, const nsString& aScope);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyRemove(
-      const nsCString& aHost) override;
+  mozilla::ipc::IPCResult RecvNotifyRemove(const nsCString& aHost);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyRemoveAll() override;
+  mozilla::ipc::IPCResult RecvNotifyRemoveAll();
 
   PServiceWorkerUpdaterChild* AllocPServiceWorkerUpdaterChild(
       const OriginAttributes& originAttributes, const nsCString& scope);
 
   bool DeallocPServiceWorkerUpdaterChild(PServiceWorkerUpdaterChild* aActor);
 
  private:
   ServiceWorkerManagerChild() : mShuttingDown(false) {}
--- a/dom/serviceworkers/ServiceWorkerManagerParent.h
+++ b/dom/serviceworkers/ServiceWorkerManagerParent.h
@@ -29,35 +29,33 @@ class ServiceWorkerManagerParent final :
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ServiceWorkerManagerParent)
 
   uint64_t ID() const { return mID; }
 
  private:
   ServiceWorkerManagerParent();
   ~ServiceWorkerManagerParent();
 
-  virtual mozilla::ipc::IPCResult RecvRegister(
-      const ServiceWorkerRegistrationData& aData) override;
+  mozilla::ipc::IPCResult RecvRegister(
+      const ServiceWorkerRegistrationData& aData);
 
-  virtual mozilla::ipc::IPCResult RecvUnregister(
-      const PrincipalInfo& aPrincipalInfo, const nsString& aScope) override;
+  mozilla::ipc::IPCResult RecvUnregister(const PrincipalInfo& aPrincipalInfo,
+                                         const nsString& aScope);
 
-  virtual mozilla::ipc::IPCResult RecvPropagateSoftUpdate(
-      const OriginAttributes& aOriginAttributes,
-      const nsString& aScope) override;
+  mozilla::ipc::IPCResult RecvPropagateSoftUpdate(
+      const OriginAttributes& aOriginAttributes, const nsString& aScope);
 
-  virtual mozilla::ipc::IPCResult RecvPropagateUnregister(
-      const PrincipalInfo& aPrincipalInfo, const nsString& aScope) override;
+  mozilla::ipc::IPCResult RecvPropagateUnregister(
+      const PrincipalInfo& aPrincipalInfo, const nsString& aScope);
 
-  virtual mozilla::ipc::IPCResult RecvPropagateRemove(
-      const nsCString& aHost) override;
+  mozilla::ipc::IPCResult RecvPropagateRemove(const nsCString& aHost);
 
-  virtual mozilla::ipc::IPCResult RecvPropagateRemoveAll() override;
+  mozilla::ipc::IPCResult RecvPropagateRemoveAll();
 
-  virtual mozilla::ipc::IPCResult RecvShutdown() override;
+  mozilla::ipc::IPCResult RecvShutdown();
 
   PServiceWorkerUpdaterParent* AllocPServiceWorkerUpdaterParent(
       const OriginAttributes& aOriginAttributes, const nsCString& aScope);
 
   virtual mozilla::ipc::IPCResult RecvPServiceWorkerUpdaterConstructor(
       PServiceWorkerUpdaterParent* aActor,
       const OriginAttributes& aOriginAttributes,
       const nsCString& aScope) override;
--- a/dom/webauthn/WebAuthnTransactionChild.h
+++ b/dom/webauthn/WebAuthnTransactionChild.h
@@ -22,24 +22,24 @@ namespace dom {
 
 class WebAuthnTransactionChild final : public PWebAuthnTransactionChild {
  public:
   NS_INLINE_DECL_REFCOUNTING(WebAuthnTransactionChild);
   explicit WebAuthnTransactionChild(WebAuthnManagerBase* aManager);
 
   mozilla::ipc::IPCResult RecvConfirmRegister(
       const uint64_t& aTransactionId,
-      const WebAuthnMakeCredentialResult& aResult) override;
+      const WebAuthnMakeCredentialResult& aResult);
 
   mozilla::ipc::IPCResult RecvConfirmSign(
       const uint64_t& aTransactionId,
-      const WebAuthnGetAssertionResult& aResult) override;
+      const WebAuthnGetAssertionResult& aResult);
 
   mozilla::ipc::IPCResult RecvAbort(const uint64_t& aTransactionId,
-                                    const nsresult& aError) override;
+                                    const nsresult& aError);
 
   void ActorDestroy(ActorDestroyReason why) override;
 
   void Disconnect();
 
  private:
   ~WebAuthnTransactionChild() = default;
 
--- a/dom/webauthn/WebAuthnTransactionParent.h
+++ b/dom/webauthn/WebAuthnTransactionParent.h
@@ -18,28 +18,27 @@
 namespace mozilla {
 namespace dom {
 
 class WebAuthnTransactionParent final : public PWebAuthnTransactionParent {
  public:
   NS_INLINE_DECL_REFCOUNTING(WebAuthnTransactionParent);
   WebAuthnTransactionParent() = default;
 
-  virtual mozilla::ipc::IPCResult RecvRequestRegister(
+  mozilla::ipc::IPCResult RecvRequestRegister(
       const uint64_t& aTransactionId,
-      const WebAuthnMakeCredentialInfo& aTransactionInfo) override;
+      const WebAuthnMakeCredentialInfo& aTransactionInfo);
 
-  virtual mozilla::ipc::IPCResult RecvRequestSign(
+  mozilla::ipc::IPCResult RecvRequestSign(
       const uint64_t& aTransactionId,
-      const WebAuthnGetAssertionInfo& aTransactionInfo) override;
+      const WebAuthnGetAssertionInfo& aTransactionInfo);
 
-  virtual mozilla::ipc::IPCResult RecvRequestCancel(
-      const uint64_t& aTransactionId) override;
+  mozilla::ipc::IPCResult RecvRequestCancel(const uint64_t& aTransactionId);
 
-  virtual mozilla::ipc::IPCResult RecvDestroyMe() override;
+  mozilla::ipc::IPCResult RecvDestroyMe();
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   ~WebAuthnTransactionParent() = default;
 };
 
 }  // namespace dom
--- a/dom/webbrowserpersist/WebBrowserPersistDocumentChild.h
+++ b/dom/webbrowserpersist/WebBrowserPersistDocumentChild.h
@@ -19,18 +19,17 @@ class WebBrowserPersistDocumentChild fin
   WebBrowserPersistDocumentChild();
   ~WebBrowserPersistDocumentChild();
 
   // This sends either Attributes or InitFailure and thereby causes
   // the actor to leave the START state.
   void Start(nsIWebBrowserPersistDocument* aDocument);
   void Start(dom::Document* aDocument);
 
-  virtual mozilla::ipc::IPCResult RecvSetPersistFlags(
-      const uint32_t& aNewFlags) override;
+  mozilla::ipc::IPCResult RecvSetPersistFlags(const uint32_t& aNewFlags);
 
   PWebBrowserPersistResourcesChild* AllocPWebBrowserPersistResourcesChild();
   virtual mozilla::ipc::IPCResult RecvPWebBrowserPersistResourcesConstructor(
       PWebBrowserPersistResourcesChild* aActor) override;
   bool DeallocPWebBrowserPersistResourcesChild(
       PWebBrowserPersistResourcesChild* aActor);
 
   PWebBrowserPersistSerializeChild* AllocPWebBrowserPersistSerializeChild(
--- a/dom/webbrowserpersist/WebBrowserPersistDocumentParent.h
+++ b/dom/webbrowserpersist/WebBrowserPersistDocumentParent.h
@@ -39,20 +39,19 @@ class WebBrowserPersistDocumentParent fi
   // Set a callback to be invoked when the actor leaves the START
   // state.  This method must be called exactly once while the actor
   // is still in the START state (or is unconstructed).
   void SetOnReady(nsIWebBrowserPersistDocumentReceiver* aOnReady);
 
   using Attrs = WebBrowserPersistDocumentAttrs;
 
   // IPDL methods:
-  virtual mozilla::ipc::IPCResult RecvAttributes(
-      const Attrs& aAttrs, const OptionalIPCStream& aPostStream) override;
-  virtual mozilla::ipc::IPCResult RecvInitFailure(
-      const nsresult& aFailure) override;
+  mozilla::ipc::IPCResult RecvAttributes(const Attrs& aAttrs,
+                                         const OptionalIPCStream& aPostStream);
+  mozilla::ipc::IPCResult RecvInitFailure(const nsresult& aFailure);
 
   PWebBrowserPersistResourcesParent* AllocPWebBrowserPersistResourcesParent();
   bool DeallocPWebBrowserPersistResourcesParent(
       PWebBrowserPersistResourcesParent* aActor);
 
   PWebBrowserPersistSerializeParent* AllocPWebBrowserPersistSerializeParent(
       const WebBrowserPersistURIMap& aMap,
       const nsCString& aRequestedContentType, const uint32_t& aEncoderFlags,
--- a/dom/workers/remoteworkers/RemoteWorkerChild.h
+++ b/dom/workers/remoteworkers/RemoteWorkerChild.h
@@ -48,17 +48,17 @@ class RemoteWorkerChild final : public P
 
  private:
   class InitializeWorkerRunnable;
 
   ~RemoteWorkerChild();
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  mozilla::ipc::IPCResult RecvExecOp(const RemoteWorkerOp& aOp) override;
+  mozilla::ipc::IPCResult RecvExecOp(const RemoteWorkerOp& aOp);
 
   void RecvExecOpOnMainThread(const RemoteWorkerOp& aOp);
 
   nsresult ExecWorkerOnMainThread(const RemoteWorkerData& aData);
 
   void ErrorPropagation(const ErrorValue& aValue);
 
   void ErrorPropagationDispatch(nsresult aError);
--- a/dom/workers/remoteworkers/RemoteWorkerParent.h
+++ b/dom/workers/remoteworkers/RemoteWorkerParent.h
@@ -26,21 +26,21 @@ class RemoteWorkerParent final : public 
 
   void SetController(RemoteWorkerController* aController);
 
  private:
   ~RemoteWorkerParent();
 
   void ActorDestroy(mozilla::ipc::IProtocol::ActorDestroyReason) override;
 
-  mozilla::ipc::IPCResult RecvError(const ErrorValue& aValue) override;
+  mozilla::ipc::IPCResult RecvError(const ErrorValue& aValue);
 
-  mozilla::ipc::IPCResult RecvClose() override;
+  mozilla::ipc::IPCResult RecvClose();
 
-  mozilla::ipc::IPCResult RecvCreated(const bool& aStatus) override;
+  mozilla::ipc::IPCResult RecvCreated(const bool& aStatus);
 
   RefPtr<RemoteWorkerController> mController;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif  // mozilla_dom_RemoteWorkerParent_h
--- a/dom/workers/sharedworkers/SharedWorkerChild.h
+++ b/dom/workers/sharedworkers/SharedWorkerChild.h
@@ -33,19 +33,19 @@ class SharedWorkerChild final : public m
 
   void SendFreeze();
 
   void SendThaw();
 
  private:
   ~SharedWorkerChild();
 
-  mozilla::ipc::IPCResult RecvError(const ErrorValue& aValue) override;
+  mozilla::ipc::IPCResult RecvError(const ErrorValue& aValue);
 
-  mozilla::ipc::IPCResult RecvTerminate() override;
+  mozilla::ipc::IPCResult RecvTerminate();
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
   // Raw pointer because mParent is set to null when released.
   SharedWorker* MOZ_NON_OWNING_REF mParent;
   bool mActive;
 };
 
--- a/dom/workers/sharedworkers/SharedWorkerParent.h
+++ b/dom/workers/sharedworkers/SharedWorkerParent.h
@@ -27,25 +27,25 @@ class SharedWorkerParent final : public 
 
   void Initialize(const RemoteWorkerData& aData, uint64_t aWindowID,
                   const MessagePortIdentifier& aPortIdentifier);
 
   void ManagerCreated(SharedWorkerManager* aWorkerManager);
 
   void ErrorPropagation(nsresult aError);
 
-  mozilla::ipc::IPCResult RecvClose() override;
+  mozilla::ipc::IPCResult RecvClose();
 
-  mozilla::ipc::IPCResult RecvSuspend() override;
+  mozilla::ipc::IPCResult RecvSuspend();
 
-  mozilla::ipc::IPCResult RecvResume() override;
+  mozilla::ipc::IPCResult RecvResume();
 
-  mozilla::ipc::IPCResult RecvFreeze() override;
+  mozilla::ipc::IPCResult RecvFreeze();
 
-  mozilla::ipc::IPCResult RecvThaw() override;
+  mozilla::ipc::IPCResult RecvThaw();
 
   bool IsSuspended() const { return mSuspended; }
 
   bool IsFrozen() const { return mFrozen; }
 
   uint64_t WindowID() const { return mWindowID; }
 
  private:
--- a/extensions/spellcheck/hunspell/glue/RemoteSpellCheckEngineParent.h
+++ b/extensions/spellcheck/hunspell/glue/RemoteSpellCheckEngineParent.h
@@ -16,31 +16,30 @@ class RemoteSpellcheckEngineParent : pub
  public:
   RemoteSpellcheckEngineParent();
 
   virtual ~RemoteSpellcheckEngineParent();
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
   virtual mozilla::ipc::IPCResult RecvSetDictionary(const nsString& aDictionary,
-                                                    bool* success) override;
+                                                    bool* success);
 
   virtual mozilla::ipc::IPCResult RecvSetDictionaryFromList(
-      nsTArray<nsString>&& aList,
-      SetDictionaryFromListResolver&& aResolve) override;
+      nsTArray<nsString>&& aList, SetDictionaryFromListResolver&& aResolve);
 
   virtual mozilla::ipc::IPCResult RecvCheck(const nsString& aWord,
-                                            bool* aIsMisspelled) override;
+                                            bool* aIsMisspelled);
 
-  virtual mozilla::ipc::IPCResult RecvCheckAsync(
-      nsTArray<nsString>&& aWord, CheckAsyncResolver&& aResolve) override;
+  virtual mozilla::ipc::IPCResult RecvCheckAsync(nsTArray<nsString>&& aWord,
+                                                 CheckAsyncResolver&& aResolve);
 
   virtual mozilla::ipc::IPCResult RecvCheckAndSuggest(
       const nsString& aWord, bool* aIsMisspelled,
-      InfallibleTArray<nsString>* aSuggestions) override;
+      InfallibleTArray<nsString>* aSuggestions);
 
  private:
   RefPtr<mozSpellChecker> mSpellChecker;
 };
 
 }  // namespace mozilla
 
 #endif
--- a/gfx/ipc/GPUChild.h
+++ b/gfx/ipc/GPUChild.h
@@ -37,53 +37,48 @@ class GPUChild final : public PGPUChild,
 
   PAPZInputBridgeChild* AllocPAPZInputBridgeChild(const LayersId& aLayersId);
   bool DeallocPAPZInputBridgeChild(PAPZInputBridgeChild* aActor);
 
   // gfxVarReceiver overrides.
   void OnVarChanged(const GfxVarUpdate& aVar) override;
 
   // PGPUChild overrides.
-  mozilla::ipc::IPCResult RecvInitComplete(const GPUDeviceData& aData) override;
-  mozilla::ipc::IPCResult RecvReportCheckerboard(
-      const uint32_t& aSeverity, const nsCString& aLog) override;
+  mozilla::ipc::IPCResult RecvInitComplete(const GPUDeviceData& aData);
+  mozilla::ipc::IPCResult RecvReportCheckerboard(const uint32_t& aSeverity,
+                                                 const nsCString& aLog);
   mozilla::ipc::IPCResult RecvInitCrashReporter(
-      Shmem&& shmem, const NativeThreadId& aThreadId) override;
-  mozilla::ipc::IPCResult RecvCreateVRProcess() override;
-  mozilla::ipc::IPCResult RecvShutdownVRProcess() override;
+      Shmem&& shmem, const NativeThreadId& aThreadId);
+  mozilla::ipc::IPCResult RecvCreateVRProcess();
+  mozilla::ipc::IPCResult RecvShutdownVRProcess();
 
   mozilla::ipc::IPCResult RecvAccumulateChildHistograms(
-      InfallibleTArray<HistogramAccumulation>&& aAccumulations) override;
+      InfallibleTArray<HistogramAccumulation>&& aAccumulations);
   mozilla::ipc::IPCResult RecvAccumulateChildKeyedHistograms(
-      InfallibleTArray<KeyedHistogramAccumulation>&& aAccumulations) override;
+      InfallibleTArray<KeyedHistogramAccumulation>&& aAccumulations);
   mozilla::ipc::IPCResult RecvUpdateChildScalars(
-      InfallibleTArray<ScalarAction>&& aScalarActions) override;
+      InfallibleTArray<ScalarAction>&& aScalarActions);
   mozilla::ipc::IPCResult RecvUpdateChildKeyedScalars(
-      InfallibleTArray<KeyedScalarAction>&& aScalarActions) override;
+      InfallibleTArray<KeyedScalarAction>&& aScalarActions);
   mozilla::ipc::IPCResult RecvRecordChildEvents(
-      nsTArray<ChildEventData>&& events) override;
+      nsTArray<ChildEventData>&& events);
   mozilla::ipc::IPCResult RecvRecordDiscardedData(
-      const DiscardedData& aDiscardedData) override;
+      const DiscardedData& aDiscardedData);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
-  mozilla::ipc::IPCResult RecvGraphicsError(const nsCString& aError) override;
-  mozilla::ipc::IPCResult RecvNotifyUiObservers(
-      const nsCString& aTopic) override;
-  mozilla::ipc::IPCResult RecvNotifyDeviceReset(
-      const GPUDeviceData& aData) override;
-  mozilla::ipc::IPCResult RecvAddMemoryReport(
-      const MemoryReport& aReport) override;
-  mozilla::ipc::IPCResult RecvFinishMemoryReport(
-      const uint32_t& aGeneration) override;
-  mozilla::ipc::IPCResult RecvUpdateFeature(
-      const Feature& aFeature, const FeatureFailure& aChange) override;
+  mozilla::ipc::IPCResult RecvGraphicsError(const nsCString& aError);
+  mozilla::ipc::IPCResult RecvNotifyUiObservers(const nsCString& aTopic);
+  mozilla::ipc::IPCResult RecvNotifyDeviceReset(const GPUDeviceData& aData);
+  mozilla::ipc::IPCResult RecvAddMemoryReport(const MemoryReport& aReport);
+  mozilla::ipc::IPCResult RecvFinishMemoryReport(const uint32_t& aGeneration);
+  mozilla::ipc::IPCResult RecvUpdateFeature(const Feature& aFeature,
+                                            const FeatureFailure& aChange);
   mozilla::ipc::IPCResult RecvUsedFallback(const Fallback& aFallback,
-                                           const nsCString& aMessage) override;
-  mozilla::ipc::IPCResult RecvBHRThreadHang(
-      const HangDetails& aDetails) override;
+                                           const nsCString& aMessage);
+  mozilla::ipc::IPCResult RecvBHRThreadHang(const HangDetails& aDetails);
 
   bool SendRequestMemoryReport(const uint32_t& aGeneration,
                                const bool& aAnonymize,
                                const bool& aMinimizeMemoryUsage,
                                const MaybeFileDesc& aDMDFile);
 
   static void Destroy(UniquePtr<GPUChild>&& aChild);
 
--- a/gfx/ipc/GPUParent.h
+++ b/gfx/ipc/GPUParent.h
@@ -32,59 +32,55 @@ class GPUParent final : public PGPUParen
 
   bool Init(base::ProcessId aParentPid, const char* aParentBuildID,
             MessageLoop* aIOLoop, IPC::Channel* aChannel);
   void NotifyDeviceReset();
 
   PAPZInputBridgeParent* AllocPAPZInputBridgeParent(const LayersId& aLayersId);
   bool DeallocPAPZInputBridgeParent(PAPZInputBridgeParent* aActor);
 
-  mozilla::ipc::IPCResult RecvInit(
-      nsTArray<GfxPrefSetting>&& prefs, nsTArray<GfxVarUpdate>&& vars,
-      const DevicePrefs& devicePrefs,
-      nsTArray<LayerTreeIdMapping>&& mappings) override;
+  mozilla::ipc::IPCResult RecvInit(nsTArray<GfxPrefSetting>&& prefs,
+                                   nsTArray<GfxVarUpdate>&& vars,
+                                   const DevicePrefs& devicePrefs,
+                                   nsTArray<LayerTreeIdMapping>&& mappings);
   mozilla::ipc::IPCResult RecvInitCompositorManager(
-      Endpoint<PCompositorManagerParent>&& aEndpoint) override;
+      Endpoint<PCompositorManagerParent>&& aEndpoint);
   mozilla::ipc::IPCResult RecvInitVsyncBridge(
-      Endpoint<PVsyncBridgeParent>&& aVsyncEndpoint) override;
+      Endpoint<PVsyncBridgeParent>&& aVsyncEndpoint);
   mozilla::ipc::IPCResult RecvInitImageBridge(
-      Endpoint<PImageBridgeParent>&& aEndpoint) override;
+      Endpoint<PImageBridgeParent>&& aEndpoint);
   mozilla::ipc::IPCResult RecvInitVRManager(
-      Endpoint<PVRManagerParent>&& aEndpoint) override;
-  mozilla::ipc::IPCResult RecvInitVR(
-      Endpoint<PVRGPUChild>&& aVRGPUChild) override;
+      Endpoint<PVRManagerParent>&& aEndpoint);
+  mozilla::ipc::IPCResult RecvInitVR(Endpoint<PVRGPUChild>&& aVRGPUChild);
   mozilla::ipc::IPCResult RecvInitUiCompositorController(
       const LayersId& aRootLayerTreeId,
-      Endpoint<PUiCompositorControllerParent>&& aEndpoint) override;
+      Endpoint<PUiCompositorControllerParent>&& aEndpoint);
   mozilla::ipc::IPCResult RecvInitProfiler(
-      Endpoint<PProfilerChild>&& aEndpoint) override;
-  mozilla::ipc::IPCResult RecvUpdatePref(const GfxPrefSetting& pref) override;
-  mozilla::ipc::IPCResult RecvUpdateVar(const GfxVarUpdate& pref) override;
+      Endpoint<PProfilerChild>&& aEndpoint);
+  mozilla::ipc::IPCResult RecvUpdatePref(const GfxPrefSetting& pref);
+  mozilla::ipc::IPCResult RecvUpdateVar(const GfxVarUpdate& pref);
   mozilla::ipc::IPCResult RecvNewContentCompositorManager(
-      Endpoint<PCompositorManagerParent>&& aEndpoint) override;
+      Endpoint<PCompositorManagerParent>&& aEndpoint);
   mozilla::ipc::IPCResult RecvNewContentImageBridge(
-      Endpoint<PImageBridgeParent>&& aEndpoint) override;
+      Endpoint<PImageBridgeParent>&& aEndpoint);
   mozilla::ipc::IPCResult RecvNewContentVRManager(
-      Endpoint<PVRManagerParent>&& aEndpoint) override;
+      Endpoint<PVRManagerParent>&& aEndpoint);
   mozilla::ipc::IPCResult RecvNewContentVideoDecoderManager(
-      Endpoint<PVideoDecoderManagerParent>&& aEndpoint) override;
-  mozilla::ipc::IPCResult RecvGetDeviceStatus(
-      GPUDeviceData* aOutStatus) override;
-  mozilla::ipc::IPCResult RecvSimulateDeviceReset(
-      GPUDeviceData* aOutStatus) override;
+      Endpoint<PVideoDecoderManagerParent>&& aEndpoint);
+  mozilla::ipc::IPCResult RecvGetDeviceStatus(GPUDeviceData* aOutStatus);
+  mozilla::ipc::IPCResult RecvSimulateDeviceReset(GPUDeviceData* aOutStatus);
   mozilla::ipc::IPCResult RecvAddLayerTreeIdMapping(
-      const LayerTreeIdMapping& aMapping) override;
+      const LayerTreeIdMapping& aMapping);
   mozilla::ipc::IPCResult RecvRemoveLayerTreeIdMapping(
-      const LayerTreeIdMapping& aMapping) override;
-  mozilla::ipc::IPCResult RecvNotifyGpuObservers(
-      const nsCString& aTopic) override;
+      const LayerTreeIdMapping& aMapping);
+  mozilla::ipc::IPCResult RecvNotifyGpuObservers(const nsCString& aTopic);
   mozilla::ipc::IPCResult RecvRequestMemoryReport(
       const uint32_t& generation, const bool& anonymize,
-      const bool& minimizeMemoryUsage, const MaybeFileDesc& DMDFile) override;
-  mozilla::ipc::IPCResult RecvShutdownVR() override;
+      const bool& minimizeMemoryUsage, const MaybeFileDesc& DMDFile);
+  mozilla::ipc::IPCResult RecvShutdownVR();
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   const TimeStamp mLaunchTime;
   RefPtr<VsyncBridgeParent> mVsyncBridge;
 #ifdef MOZ_GECKO_PROFILER
   RefPtr<ChildProfilerController> mProfilerController;
--- a/gfx/ipc/VsyncBridgeParent.h
+++ b/gfx/ipc/VsyncBridgeParent.h
@@ -19,17 +19,17 @@ namespace gfx {
 class VsyncBridgeParent final : public PVsyncBridgeParent {
  public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VsyncBridgeParent)
 
   static RefPtr<VsyncBridgeParent> Start(
       Endpoint<PVsyncBridgeParent>&& aEndpoint);
 
   mozilla::ipc::IPCResult RecvNotifyVsync(const VsyncEvent& aVsync,
-                                          const LayersId& aLayersId) override;
+                                          const LayersId& aLayersId);
   void ActorDestroy(ActorDestroyReason aWhy) override;
   void DeallocPVsyncBridgeParent() override;
 
   void Shutdown();
 
  private:
   VsyncBridgeParent();
   ~VsyncBridgeParent();
--- a/gfx/layers/ipc/APZCTreeManagerChild.h
+++ b/gfx/layers/ipc/APZCTreeManagerChild.h
@@ -65,25 +65,24 @@ class APZCTreeManagerChild : public IAPZ
   void ReleaseIPDLReference();
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  protected:
   mozilla::ipc::IPCResult RecvHandleTap(const TapType& aType,
                                         const LayoutDevicePoint& aPoint,
                                         const Modifiers& aModifiers,
                                         const ScrollableLayerGuid& aGuid,
-                                        const uint64_t& aInputBlockId) override;
+                                        const uint64_t& aInputBlockId);
 
   mozilla::ipc::IPCResult RecvNotifyPinchGesture(
       const PinchGestureType& aType, const ScrollableLayerGuid& aGuid,
-      const LayoutDeviceCoord& aSpanChange,
-      const Modifiers& aModifiers) override;
+      const LayoutDeviceCoord& aSpanChange, const Modifiers& aModifiers);
 
   mozilla::ipc::IPCResult RecvCancelAutoscroll(
-      const ScrollableLayerGuid::ViewID& aScrollId) override;
+      const ScrollableLayerGuid::ViewID& aScrollId);
 
   virtual ~APZCTreeManagerChild();
 
  private:
   MOZ_NON_OWNING_REF RemoteCompositorSession* mCompositorSession;
   RefPtr<APZInputBridgeChild> mInputBridge;
   bool mIPCOpen;
 };
--- a/gfx/layers/ipc/APZCTreeManagerParent.h
+++ b/gfx/layers/ipc/APZCTreeManagerParent.h
@@ -26,53 +26,46 @@ class APZCTreeManagerParent : public PAP
 
   /**
    * Called when the layer tree that this protocol is connected to
    * is adopted by another compositor, and we need to switch APZCTreeManagers.
    */
   void ChildAdopted(RefPtr<APZCTreeManager> aAPZCTreeManager,
                     RefPtr<APZUpdater> aAPZUpdater);
 
-  mozilla::ipc::IPCResult RecvSetKeyboardMap(
-      const KeyboardMap& aKeyboardMap) override;
+  mozilla::ipc::IPCResult RecvSetKeyboardMap(const KeyboardMap& aKeyboardMap);
 
   mozilla::ipc::IPCResult RecvZoomToRect(const ScrollableLayerGuid& aGuid,
                                          const CSSRect& aRect,
-                                         const uint32_t& aFlags) override;
+                                         const uint32_t& aFlags);
 
   mozilla::ipc::IPCResult RecvContentReceivedInputBlock(
-      const uint64_t& aInputBlockId, const bool& aPreventDefault) override;
+      const uint64_t& aInputBlockId, const bool& aPreventDefault);
 
   mozilla::ipc::IPCResult RecvSetTargetAPZC(
-      const uint64_t& aInputBlockId,
-      nsTArray<ScrollableLayerGuid>&& aTargets) override;
+      const uint64_t& aInputBlockId, nsTArray<ScrollableLayerGuid>&& aTargets);
 
   mozilla::ipc::IPCResult RecvUpdateZoomConstraints(
       const ScrollableLayerGuid& aGuid,
-      const MaybeZoomConstraints& aConstraints) override;
+      const MaybeZoomConstraints& aConstraints);
 
-  mozilla::ipc::IPCResult RecvSetDPI(const float& aDpiValue) override;
+  mozilla::ipc::IPCResult RecvSetDPI(const float& aDpiValue);
 
   mozilla::ipc::IPCResult RecvSetAllowedTouchBehavior(
-      const uint64_t& aInputBlockId,
-      nsTArray<TouchBehaviorFlags>&& aValues) override;
+      const uint64_t& aInputBlockId, nsTArray<TouchBehaviorFlags>&& aValues);
 
   mozilla::ipc::IPCResult RecvStartScrollbarDrag(
-      const ScrollableLayerGuid& aGuid,
-      const AsyncDragMetrics& aDragMetrics) override;
+      const ScrollableLayerGuid& aGuid, const AsyncDragMetrics& aDragMetrics);
 
   mozilla::ipc::IPCResult RecvStartAutoscroll(
-      const ScrollableLayerGuid& aGuid,
-      const ScreenPoint& aAnchorLocation) override;
+      const ScrollableLayerGuid& aGuid, const ScreenPoint& aAnchorLocation);
 
-  mozilla::ipc::IPCResult RecvStopAutoscroll(
-      const ScrollableLayerGuid& aGuid) override;
+  mozilla::ipc::IPCResult RecvStopAutoscroll(const ScrollableLayerGuid& aGuid);
 
-  mozilla::ipc::IPCResult RecvSetLongTapEnabled(
-      const bool& aTapGestureEnabled) override;
+  mozilla::ipc::IPCResult RecvSetLongTapEnabled(const bool& aTapGestureEnabled);
 
   void ActorDestroy(ActorDestroyReason aWhy) override {}
 
  private:
   LayersId mLayersId;
   RefPtr<APZCTreeManager> mTreeManager;
   RefPtr<APZUpdater> mUpdater;
 };
--- a/gfx/layers/ipc/APZChild.h
+++ b/gfx/layers/ipc/APZChild.h
@@ -20,43 +20,43 @@ class GeckoContentController;
  * that lives in a different process than where APZ lives.
  */
 class APZChild final : public PAPZChild {
  public:
   explicit APZChild(RefPtr<GeckoContentController> aController);
   ~APZChild();
 
   mozilla::ipc::IPCResult RecvRequestContentRepaint(
-      const RepaintRequest& aRequest) override;
+      const RepaintRequest& aRequest);
 
   mozilla::ipc::IPCResult RecvUpdateOverscrollVelocity(
-      const float& aX, const float& aY, const bool& aIsRootContent) override;
+      const float& aX, const float& aY, const bool& aIsRootContent);
 
   mozilla::ipc::IPCResult RecvUpdateOverscrollOffset(
-      const float& aX, const float& aY, const bool& aIsRootContent) override;
+      const float& aX, const float& aY, const bool& aIsRootContent);
 
-  mozilla::ipc::IPCResult RecvNotifyMozMouseScrollEvent(
-      const ViewID& aScrollId, const nsString& aEvent) override;
+  mozilla::ipc::IPCResult RecvNotifyMozMouseScrollEvent(const ViewID& aScrollId,
+                                                        const nsString& aEvent);
 
   mozilla::ipc::IPCResult RecvNotifyAPZStateChange(
       const ScrollableLayerGuid& aGuid, const APZStateChange& aChange,
-      const int& aArg) override;
+      const int& aArg);
 
-  mozilla::ipc::IPCResult RecvNotifyFlushComplete() override;
+  mozilla::ipc::IPCResult RecvNotifyFlushComplete();
 
   mozilla::ipc::IPCResult RecvNotifyAsyncScrollbarDragInitiated(
       const uint64_t& aDragBlockId, const ViewID& aScrollId,
-      const ScrollDirection& aDirection) override;
+      const ScrollDirection& aDirection);
   mozilla::ipc::IPCResult RecvNotifyAsyncScrollbarDragRejected(
-      const ViewID& aScrollId) override;
+      const ViewID& aScrollId);
 
   mozilla::ipc::IPCResult RecvNotifyAsyncAutoscrollRejected(
-      const ViewID& aScrollId) override;
+      const ViewID& aScrollId);
 
-  mozilla::ipc::IPCResult RecvDestroy() override;
+  mozilla::ipc::IPCResult RecvDestroy();
 
  private:
   RefPtr<GeckoContentController> mController;
 };
 
 }  // namespace layers
 
 }  // namespace mozilla
--- a/gfx/layers/ipc/APZInputBridgeParent.h
+++ b/gfx/layers/ipc/APZInputBridgeParent.h
@@ -18,56 +18,54 @@ class APZInputBridgeParent : public PAPZ
   NS_INLINE_DECL_REFCOUNTING(APZInputBridgeParent)
 
  public:
   explicit APZInputBridgeParent(const LayersId& aLayersId);
 
   mozilla::ipc::IPCResult RecvReceiveMultiTouchInputEvent(
       const MultiTouchInput& aEvent, nsEventStatus* aOutStatus,
       MultiTouchInput* aOutEvent, ScrollableLayerGuid* aOutTargetGuid,
-      uint64_t* aOutInputBlockId) override;
+      uint64_t* aOutInputBlockId);
 
   mozilla::ipc::IPCResult RecvReceiveMouseInputEvent(
       const MouseInput& aEvent, nsEventStatus* aOutStatus,
       MouseInput* aOutEvent, ScrollableLayerGuid* aOutTargetGuid,
-      uint64_t* aOutInputBlockId) override;
+      uint64_t* aOutInputBlockId);
 
   mozilla::ipc::IPCResult RecvReceivePanGestureInputEvent(
       const PanGestureInput& aEvent, nsEventStatus* aOutStatus,
       PanGestureInput* aOutEvent, ScrollableLayerGuid* aOutTargetGuid,
-      uint64_t* aOutInputBlockId) override;
+      uint64_t* aOutInputBlockId);
 
   mozilla::ipc::IPCResult RecvReceivePinchGestureInputEvent(
       const PinchGestureInput& aEvent, nsEventStatus* aOutStatus,
       PinchGestureInput* aOutEvent, ScrollableLayerGuid* aOutTargetGuid,
-      uint64_t* aOutInputBlockId) override;
+      uint64_t* aOutInputBlockId);
 
   mozilla::ipc::IPCResult RecvReceiveTapGestureInputEvent(
       const TapGestureInput& aEvent, nsEventStatus* aOutStatus,
       TapGestureInput* aOutEvent, ScrollableLayerGuid* aOutTargetGuid,
-      uint64_t* aOutInputBlockId) override;
+      uint64_t* aOutInputBlockId);
 
   mozilla::ipc::IPCResult RecvReceiveScrollWheelInputEvent(
       const ScrollWheelInput& aEvent, nsEventStatus* aOutStatus,
       ScrollWheelInput* aOutEvent, ScrollableLayerGuid* aOutTargetGuid,
-      uint64_t* aOutInputBlockId) override;
+      uint64_t* aOutInputBlockId);
 
   mozilla::ipc::IPCResult RecvReceiveKeyboardInputEvent(
       const KeyboardInput& aEvent, nsEventStatus* aOutStatus,
       KeyboardInput* aOutEvent, ScrollableLayerGuid* aOutTargetGuid,
-      uint64_t* aOutInputBlockId) override;
+      uint64_t* aOutInputBlockId);
 
   mozilla::ipc::IPCResult RecvUpdateWheelTransaction(
-      const LayoutDeviceIntPoint& aRefPoint,
-      const EventMessage& aEventMessage) override;
+      const LayoutDeviceIntPoint& aRefPoint, const EventMessage& aEventMessage);
 
   mozilla::ipc::IPCResult RecvProcessUnhandledEvent(
       const LayoutDeviceIntPoint& aRefPoint, LayoutDeviceIntPoint* aOutRefPoint,
-      ScrollableLayerGuid* aOutTargetGuid,
-      uint64_t* aOutFocusSequenceNumber) override;
+      ScrollableLayerGuid* aOutTargetGuid, uint64_t* aOutFocusSequenceNumber);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  protected:
   virtual ~APZInputBridgeParent();
 
  private:
   RefPtr<IAPZCTreeManager> mTreeManager;
--- a/gfx/layers/ipc/CompositorBridgeChild.h
+++ b/gfx/layers/ipc/CompositorBridgeChild.h
@@ -81,48 +81,45 @@ class CompositorBridgeChild final : publ
   static CompositorBridgeChild* Get();
 
   static bool ChildProcessHasCompositorBridge();
 
   // Returns whether the compositor is in the GPU process (false if in the UI
   // process). This may only be called on the main thread.
   static bool CompositorIsInGPUProcess();
 
-  virtual mozilla::ipc::IPCResult RecvDidComposite(
-      const LayersId& aId, const TransactionId& aTransactionId,
-      const TimeStamp& aCompositeStart,
-      const TimeStamp& aCompositeEnd) override;
+  mozilla::ipc::IPCResult RecvDidComposite(const LayersId& aId,
+                                           const TransactionId& aTransactionId,
+                                           const TimeStamp& aCompositeStart,
+                                           const TimeStamp& aCompositeEnd);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyFrameStats(
-      nsTArray<FrameStats>&& aFrameStats) override;
+  mozilla::ipc::IPCResult RecvNotifyFrameStats(
+      nsTArray<FrameStats>&& aFrameStats);
 
-  virtual mozilla::ipc::IPCResult RecvInvalidateLayers(
-      const LayersId& aLayersId) override;
+  mozilla::ipc::IPCResult RecvInvalidateLayers(const LayersId& aLayersId);
 
-  virtual mozilla::ipc::IPCResult RecvUpdatePluginConfigurations(
+  mozilla::ipc::IPCResult RecvUpdatePluginConfigurations(
       const LayoutDeviceIntPoint& aContentOffset,
       const LayoutDeviceIntRegion& aVisibleRegion,
-      nsTArray<PluginWindowData>&& aPlugins) override;
+      nsTArray<PluginWindowData>&& aPlugins);
 
-  virtual mozilla::ipc::IPCResult RecvCaptureAllPlugins(
-      const uintptr_t& aParentWidget) override;
+  mozilla::ipc::IPCResult RecvCaptureAllPlugins(const uintptr_t& aParentWidget);
 
-  virtual mozilla::ipc::IPCResult RecvHideAllPlugins(
-      const uintptr_t& aParentWidget) override;
+  mozilla::ipc::IPCResult RecvHideAllPlugins(const uintptr_t& aParentWidget);
 
   PTextureChild* AllocPTextureChild(
       const SurfaceDescriptor& aSharedData, const ReadLockDescriptor& aReadLock,
       const LayersBackend& aLayersBackend, const TextureFlags& aFlags,
       const LayersId& aId, const uint64_t& aSerial,
       const wr::MaybeExternalImageId& aExternalImageId);
 
   bool DeallocPTextureChild(PTextureChild* actor);
 
-  virtual mozilla::ipc::IPCResult RecvParentAsyncMessages(
-      InfallibleTArray<AsyncParentMessageData>&& aMessages) override;
+  mozilla::ipc::IPCResult RecvParentAsyncMessages(
+      InfallibleTArray<AsyncParentMessageData>&& aMessages);
   virtual PTextureChild* CreateTexture(
       const SurfaceDescriptor& aSharedData, const ReadLockDescriptor& aReadLock,
       LayersBackend aLayersBackend, TextureFlags aFlags, uint64_t aSerial,
       wr::MaybeExternalImageId& aExternalImageId,
       nsIEventTarget* aTarget) override;
 
   /**
    * Request that the parent tell us when graphics are ready on GPU.
@@ -265,32 +262,32 @@ class CompositorBridgeChild final : publ
 
   PLayerTransactionChild* AllocPLayerTransactionChild(
       const nsTArray<LayersBackend>& aBackendHints, const LayersId& aId);
 
   bool DeallocPLayerTransactionChild(PLayerTransactionChild* aChild);
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  virtual mozilla::ipc::IPCResult RecvSharedCompositorFrameMetrics(
+  mozilla::ipc::IPCResult RecvSharedCompositorFrameMetrics(
       const mozilla::ipc::SharedMemoryBasic::Handle& metrics,
       const CrossProcessMutexHandle& handle, const LayersId& aLayersId,
-      const uint32_t& aAPZCId) override;
+      const uint32_t& aAPZCId);
 
-  virtual mozilla::ipc::IPCResult RecvReleaseSharedCompositorFrameMetrics(
-      const ViewID& aId, const uint32_t& aAPZCId) override;
+  mozilla::ipc::IPCResult RecvReleaseSharedCompositorFrameMetrics(
+      const ViewID& aId, const uint32_t& aAPZCId);
 
-  virtual mozilla::ipc::IPCResult RecvRemotePaintIsReady() override;
+  mozilla::ipc::IPCResult RecvRemotePaintIsReady();
 
   mozilla::ipc::IPCResult RecvObserveLayersUpdate(
       const LayersId& aLayersId, const LayersObserverEpoch& aEpoch,
-      const bool& aActive) override;
+      const bool& aActive);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyWebRenderError(
-      const WebRenderError& aError) override;
+  mozilla::ipc::IPCResult RecvNotifyWebRenderError(
+      const WebRenderError& aError);
 
   uint64_t GetNextResourceId();
 
   void ClearSharedFrameMetricsData(LayersId aLayersId);
 
   // Class used to store the shared FrameMetrics, mutex, and APZCId  in a hash
   // table
   class SharedFrameMetricsData {
--- a/gfx/layers/ipc/CompositorBridgeParent.h
+++ b/gfx/layers/ipc/CompositorBridgeParent.h
@@ -143,17 +143,17 @@ class CompositorBridgeParentBase : publi
       const InfallibleTArray<CompositionPayload>& aPayload) {}
 
   ShmemAllocator* AsShmemAllocator() override { return this; }
 
   CompositorBridgeParentBase* AsCompositorBridgeParentBase() override {
     return this;
   }
 
-  mozilla::ipc::IPCResult RecvSyncWithCompositor() override { return IPC_OK(); }
+  mozilla::ipc::IPCResult RecvSyncWithCompositor() { return IPC_OK(); }
 
   mozilla::ipc::IPCResult Recv__delete__() override { return IPC_OK(); }
 
   virtual void ObserveLayersUpdate(LayersId aLayersId,
                                    LayersObserverEpoch aEpoch,
                                    bool aActive) = 0;
 
   // HostIPCAllocator
@@ -225,16 +225,49 @@ class CompositorBridgeParentBase : publi
   virtual bool DeallocPWebRenderBridgeParent(
       PWebRenderBridgeParent* aActor) = 0;
 
   virtual PCompositorWidgetParent* AllocPCompositorWidgetParent(
       const CompositorWidgetInitData& aInitData) = 0;
   virtual bool DeallocPCompositorWidgetParent(
       PCompositorWidgetParent* aActor) = 0;
 
+  virtual mozilla::ipc::IPCResult RecvRemotePluginsReady() = 0;
+  virtual mozilla::ipc::IPCResult RecvAdoptChild(const LayersId& id) = 0;
+  virtual mozilla::ipc::IPCResult RecvFlushRenderingAsync() = 0;
+  virtual mozilla::ipc::IPCResult RecvForcePresent() = 0;
+  virtual mozilla::ipc::IPCResult RecvNotifyRegionInvalidated(
+      const nsIntRegion& region) = 0;
+  virtual mozilla::ipc::IPCResult RecvRequestNotifyAfterRemotePaint() = 0;
+  virtual mozilla::ipc::IPCResult RecvAllPluginsCaptured() = 0;
+  virtual mozilla::ipc::IPCResult RecvInitialize(
+      const LayersId& rootLayerTreeId) = 0;
+  virtual mozilla::ipc::IPCResult RecvGetFrameUniformity(
+      FrameUniformityData* data) = 0;
+  virtual mozilla::ipc::IPCResult RecvWillClose() = 0;
+  virtual mozilla::ipc::IPCResult RecvPause() = 0;
+  virtual mozilla::ipc::IPCResult RecvResume() = 0;
+  virtual mozilla::ipc::IPCResult RecvNotifyChildCreated(
+      const LayersId& id, CompositorOptions* compositorOptions) = 0;
+  virtual mozilla::ipc::IPCResult RecvMapAndNotifyChildCreated(
+      const LayersId& id, const ProcessId& owner,
+      CompositorOptions* compositorOptions) = 0;
+  virtual mozilla::ipc::IPCResult RecvNotifyChildRecreated(
+      const LayersId& id, CompositorOptions* compositorOptions) = 0;
+  virtual mozilla::ipc::IPCResult RecvMakeSnapshot(
+      const SurfaceDescriptor& inSnapshot, const IntRect& dirtyRect) = 0;
+  virtual mozilla::ipc::IPCResult RecvFlushRendering() = 0;
+  virtual mozilla::ipc::IPCResult RecvWaitOnTransactionProcessed() = 0;
+  virtual mozilla::ipc::IPCResult RecvStartFrameTimeRecording(
+      const int32_t& bufferSize, uint32_t* startIndex) = 0;
+  virtual mozilla::ipc::IPCResult RecvStopFrameTimeRecording(
+      const uint32_t& startIndex, nsTArray<float>* intervals) = 0;
+  virtual mozilla::ipc::IPCResult RecvCheckContentOnlyTDR(
+      const uint32_t& sequenceNum, bool* isContentOnlyTDR) = 0;
+
   bool mCanSend;
 
  private:
   RefPtr<CompositorManagerParent> mCompositorManager;
 };
 
 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(
     CompositorBridgeParentBase::TransformsToSkip)
--- a/gfx/layers/ipc/CompositorManagerParent.h
+++ b/gfx/layers/ipc/CompositorManagerParent.h
@@ -35,27 +35,25 @@ class CompositorManagerParent final : pu
 
   static already_AddRefed<CompositorBridgeParent>
   CreateSameProcessWidgetCompositorBridge(CSSToLayoutDeviceScale aScale,
                                           const CompositorOptions& aOptions,
                                           bool aUseExternalSurfaceSize,
                                           const gfx::IntSize& aSurfaceSize);
 
   mozilla::ipc::IPCResult RecvAddSharedSurface(
-      const wr::ExternalImageId& aId,
-      const SurfaceDescriptorShared& aDesc) override;
+      const wr::ExternalImageId& aId, const SurfaceDescriptorShared& aDesc);
   mozilla::ipc::IPCResult RecvRemoveSharedSurface(
-      const wr::ExternalImageId& aId) override;
+      const wr::ExternalImageId& aId);
   mozilla::ipc::IPCResult RecvReportSharedSurfacesMemory(
-      ReportSharedSurfacesMemoryResolver&&) override;
+      ReportSharedSurfacesMemoryResolver&&);
 
-  virtual mozilla::ipc::IPCResult RecvNotifyMemoryPressure() override;
+  mozilla::ipc::IPCResult RecvNotifyMemoryPressure();
 
-  virtual mozilla::ipc::IPCResult RecvReportMemory(
-      ReportMemoryResolver&&) override;
+  mozilla::ipc::IPCResult RecvReportMemory(ReportMemoryResolver&&);
 
   void BindComplete();
   void ActorDestroy(ActorDestroyReason aReason) override;
 
   bool DeallocPCompositorBridgeParent(PCompositorBridgeParent* aActor);
   PCompositorBridgeParent* AllocPCompositorBridgeParent(
       const CompositorBridgeOptions& aOpt);
 
--- a/gfx/layers/ipc/ImageBridgeChild.h
+++ b/gfx/layers/ipc/ImageBridgeChild.h
@@ -186,24 +186,24 @@ class ImageBridgeChild final : public PI
       const wr::MaybeExternalImageId& aExternalImageId);
 
   bool DeallocPTextureChild(PTextureChild* actor);
 
   PMediaSystemResourceManagerChild* AllocPMediaSystemResourceManagerChild();
   bool DeallocPMediaSystemResourceManagerChild(
       PMediaSystemResourceManagerChild* aActor);
 
-  virtual mozilla::ipc::IPCResult RecvParentAsyncMessages(
-      InfallibleTArray<AsyncParentMessageData>&& aMessages) override;
+  mozilla::ipc::IPCResult RecvParentAsyncMessages(
+      InfallibleTArray<AsyncParentMessageData>&& aMessages);
 
-  virtual mozilla::ipc::IPCResult RecvDidComposite(
-      InfallibleTArray<ImageCompositeNotification>&& aNotifications) override;
+  mozilla::ipc::IPCResult RecvDidComposite(
+      InfallibleTArray<ImageCompositeNotification>&& aNotifications);
 
-  virtual mozilla::ipc::IPCResult RecvReportFramesDropped(
-      const CompositableHandle& aHandle, const uint32_t& aFrames) override;
+  mozilla::ipc::IPCResult RecvReportFramesDropped(
+      const CompositableHandle& aHandle, const uint32_t& aFrames);
 
   // Create an ImageClient from any thread.
   RefPtr<ImageClient> CreateImageClient(CompositableType aType,
                                         ImageContainer* aImageContainer);
 
   // Create an ImageClient from the ImageBridge thread.
   RefPtr<ImageClient> CreateImageClientNow(CompositableType aType,
                                            ImageContainer* aImageContainer);
--- a/gfx/layers/ipc/ImageBridgeParent.h
+++ b/gfx/layers/ipc/ImageBridgeParent.h
@@ -69,39 +69,39 @@ class ImageBridgeParent final : public P
       const InfallibleTArray<AsyncParentMessageData>& aMessage) override;
 
   virtual void NotifyNotUsed(PTextureParent* aTexture,
                              uint64_t aTransactionId) override;
 
   virtual base::ProcessId GetChildProcessId() override { return OtherPid(); }
 
   // PImageBridge
-  virtual mozilla::ipc::IPCResult RecvUpdate(
-      EditArray&& aEdits, OpDestroyArray&& aToDestroy,
-      const uint64_t& aFwdTransactionId) override;
+  mozilla::ipc::IPCResult RecvUpdate(EditArray&& aEdits,
+                                     OpDestroyArray&& aToDestroy,
+                                     const uint64_t& aFwdTransactionId);
 
   PTextureParent* AllocPTextureParent(
       const SurfaceDescriptor& aSharedData, const ReadLockDescriptor& aReadLock,
       const LayersBackend& aLayersBackend, const TextureFlags& aFlags,
       const uint64_t& aSerial,
       const wr::MaybeExternalImageId& aExternalImageId);
   bool DeallocPTextureParent(PTextureParent* actor);
 
-  virtual mozilla::ipc::IPCResult RecvNewCompositable(
+  mozilla::ipc::IPCResult RecvNewCompositable(
       const CompositableHandle& aHandle, const TextureInfo& aInfo,
-      const LayersBackend& aLayersBackend) override;
-  virtual mozilla::ipc::IPCResult RecvReleaseCompositable(
-      const CompositableHandle& aHandle) override;
+      const LayersBackend& aLayersBackend);
+  mozilla::ipc::IPCResult RecvReleaseCompositable(
+      const CompositableHandle& aHandle);
 
   PMediaSystemResourceManagerParent* AllocPMediaSystemResourceManagerParent();
   bool DeallocPMediaSystemResourceManagerParent(
       PMediaSystemResourceManagerParent* aActor);
 
   // Shutdown step 1
-  virtual mozilla::ipc::IPCResult RecvWillClose() override;
+  mozilla::ipc::IPCResult RecvWillClose();
 
   MessageLoop* GetMessageLoop() const { return mMessageLoop; }
 
   // ShmemAllocator
 
   virtual bool AllocShmem(size_t aSize,
                           ipc::SharedMemory::SharedMemoryType aType,
                           ipc::Shmem* aShmem) override;
--- a/gfx/layers/ipc/LayerTransactionParent.h
+++ b/gfx/layers/ipc/LayerTransactionParent.h
@@ -92,58 +92,53 @@ class LayerTransactionParent final : pub
   void SetAboutToSendAsyncMessages() override;
 
   void NotifyNotUsed(PTextureParent* aTexture,
                      uint64_t aTransactionId) override;
 
   base::ProcessId GetChildProcessId() override { return OtherPid(); }
 
  protected:
-  mozilla::ipc::IPCResult RecvShutdown() override;
-  mozilla::ipc::IPCResult RecvShutdownSync() override;
+  mozilla::ipc::IPCResult RecvShutdown();
+  mozilla::ipc::IPCResult RecvShutdownSync();
 
-  mozilla::ipc::IPCResult RecvPaintTime(
-      const TransactionId& aTransactionId,
-      const TimeDuration& aPaintTime) override;
+  mozilla::ipc::IPCResult RecvPaintTime(const TransactionId& aTransactionId,
+                                        const TimeDuration& aPaintTime);
 
-  mozilla::ipc::IPCResult RecvUpdate(const TransactionInfo& aInfo) override;
+  mozilla::ipc::IPCResult RecvUpdate(const TransactionInfo& aInfo);
 
   mozilla::ipc::IPCResult RecvSetLayersObserverEpoch(
-      const LayersObserverEpoch& aChildEpoch) override;
-  mozilla::ipc::IPCResult RecvNewCompositable(
-      const CompositableHandle& aHandle, const TextureInfo& aInfo) override;
-  mozilla::ipc::IPCResult RecvReleaseLayer(const LayerHandle& aHandle) override;
+      const LayersObserverEpoch& aChildEpoch);
+  mozilla::ipc::IPCResult RecvNewCompositable(const CompositableHandle& aHandle,
+                                              const TextureInfo& aInfo);
+  mozilla::ipc::IPCResult RecvReleaseLayer(const LayerHandle& aHandle);
   mozilla::ipc::IPCResult RecvReleaseCompositable(
-      const CompositableHandle& aHandle) override;
+      const CompositableHandle& aHandle);
 
-  mozilla::ipc::IPCResult RecvClearCachedResources() override;
-  mozilla::ipc::IPCResult RecvScheduleComposite() override;
-  mozilla::ipc::IPCResult RecvSetTestSampleTime(
-      const TimeStamp& aTime) override;
-  mozilla::ipc::IPCResult RecvLeaveTestMode() override;
+  mozilla::ipc::IPCResult RecvClearCachedResources();
+  mozilla::ipc::IPCResult RecvScheduleComposite();
+  mozilla::ipc::IPCResult RecvSetTestSampleTime(const TimeStamp& aTime);
+  mozilla::ipc::IPCResult RecvLeaveTestMode();
   mozilla::ipc::IPCResult RecvGetAnimationValue(
-      const uint64_t& aCompositorAnimationsId, OMTAValue* aValue) override;
+      const uint64_t& aCompositorAnimationsId, OMTAValue* aValue);
   mozilla::ipc::IPCResult RecvGetTransform(const LayerHandle& aHandle,
-                                           MaybeTransform* aTransform) override;
+                                           MaybeTransform* aTransform);
   mozilla::ipc::IPCResult RecvSetAsyncScrollOffset(
-      const ScrollableLayerGuid::ViewID& aId, const float& aX,
-      const float& aY) override;
+      const ScrollableLayerGuid::ViewID& aId, const float& aX, const float& aY);
   mozilla::ipc::IPCResult RecvSetAsyncZoom(
-      const ScrollableLayerGuid::ViewID& aId, const float& aValue) override;
-  mozilla::ipc::IPCResult RecvFlushApzRepaints() override;
-  mozilla::ipc::IPCResult RecvGetAPZTestData(APZTestData* aOutData) override;
+      const ScrollableLayerGuid::ViewID& aId, const float& aValue);
+  mozilla::ipc::IPCResult RecvFlushApzRepaints();
+  mozilla::ipc::IPCResult RecvGetAPZTestData(APZTestData* aOutData);
   mozilla::ipc::IPCResult RecvRequestProperty(const nsString& aProperty,
-                                              float* aValue) override;
+                                              float* aValue);
   mozilla::ipc::IPCResult RecvSetConfirmedTargetAPZC(
-      const uint64_t& aBlockId,
-      nsTArray<ScrollableLayerGuid>&& aTargets) override;
-  mozilla::ipc::IPCResult RecvRecordPaintTimes(
-      const PaintTiming& aTiming) override;
+      const uint64_t& aBlockId, nsTArray<ScrollableLayerGuid>&& aTargets);
+  mozilla::ipc::IPCResult RecvRecordPaintTimes(const PaintTiming& aTiming);
   mozilla::ipc::IPCResult RecvGetTextureFactoryIdentifier(
-      TextureFactoryIdentifier* aIdentifier) override;
+      TextureFactoryIdentifier* aIdentifier);
 
   bool SetLayerAttributes(const OpSetLayerAttributes& aOp);
 
   void ActorDestroy(ActorDestroyReason why) override;
 
   template <typename T>
   bool BindLayer(const RefPtr<Layer>& aLayer, const T& aCreateOp) {
     return BindLayerToHandle(aLayer, aCreateOp.layer());
--- a/gfx/layers/ipc/UiCompositorControllerChild.h
+++ b/gfx/layers/ipc/UiCompositorControllerChild.h
@@ -53,21 +53,21 @@ class UiCompositorControllerChild final
   bool DeallocPixelBuffer(Shmem& aMem);
 
  protected:
   void ActorDestroy(ActorDestroyReason aWhy) override;
   void DeallocPUiCompositorControllerChild() override;
   void ProcessingError(Result aCode, const char* aReason) override;
   virtual void HandleFatalError(const char* aMsg) const override;
   mozilla::ipc::IPCResult RecvToolbarAnimatorMessageFromCompositor(
-      const int32_t& aMessage) override;
-  mozilla::ipc::IPCResult RecvRootFrameMetrics(
-      const ScreenPoint& aScrollOffset, const CSSToScreenScale& aZoom) override;
+      const int32_t& aMessage);
+  mozilla::ipc::IPCResult RecvRootFrameMetrics(const ScreenPoint& aScrollOffset,
+                                               const CSSToScreenScale& aZoom);
   mozilla::ipc::IPCResult RecvScreenPixels(ipc::Shmem&& aMem,
-                                           const ScreenIntSize& aSize) override;
+                                           const ScreenIntSize& aSize);
 
  private:
   explicit UiCompositorControllerChild(const uint64_t& aProcessToken);
   ~UiCompositorControllerChild();
   void OpenForSameProcess();
   void OpenForGPUProcess(Endpoint<PUiCompositorControllerChild>&& aEndpoint);
   void SendCachedValues();
 
--- a/gfx/layers/ipc/UiCompositorControllerParent.h
+++ b/gfx/layers/ipc/UiCompositorControllerParent.h
@@ -29,35 +29,34 @@ class UiCompositorControllerParent final
 
   static RefPtr<UiCompositorControllerParent> GetFromRootLayerTreeId(
       const LayersId& aRootLayerTreeId);
   static RefPtr<UiCompositorControllerParent> Start(
       const LayersId& aRootLayerTreeId,
       Endpoint<PUiCompositorControllerParent>&& aEndpoint);
 
   // PUiCompositorControllerParent functions
-  mozilla::ipc::IPCResult RecvPause() override;
-  mozilla::ipc::IPCResult RecvResume() override;
+  mozilla::ipc::IPCResult RecvPause();
+  mozilla::ipc::IPCResult RecvResume();
   mozilla::ipc::IPCResult RecvResumeAndResize(const int32_t& aX,
                                               const int32_t& aY,
                                               const int32_t& aHeight,
-                                              const int32_t& aWidth) override;
-  mozilla::ipc::IPCResult RecvInvalidateAndRender() override;
-  mozilla::ipc::IPCResult RecvMaxToolbarHeight(const int32_t& aHeight) override;
+                                              const int32_t& aWidth);
+  mozilla::ipc::IPCResult RecvInvalidateAndRender();
+  mozilla::ipc::IPCResult RecvMaxToolbarHeight(const int32_t& aHeight);
   mozilla::ipc::IPCResult RecvPinned(const bool& aPinned,
-                                     const int32_t& aReason) override;
+                                     const int32_t& aReason);
   mozilla::ipc::IPCResult RecvToolbarAnimatorMessageFromUI(
-      const int32_t& aMessage) override;
-  mozilla::ipc::IPCResult RecvDefaultClearColor(
-      const uint32_t& aColor) override;
-  mozilla::ipc::IPCResult RecvRequestScreenPixels() override;
+      const int32_t& aMessage);
+  mozilla::ipc::IPCResult RecvDefaultClearColor(const uint32_t& aColor);
+  mozilla::ipc::IPCResult RecvRequestScreenPixels();
   mozilla::ipc::IPCResult RecvEnableLayerUpdateNotifications(
-      const bool& aEnable) override;
+      const bool& aEnable);
   mozilla::ipc::IPCResult RecvToolbarPixelsToCompositor(
-      Shmem&& aMem, const ScreenIntSize& aSize) override;
+      Shmem&& aMem, const ScreenIntSize& aSize);
   void ActorDestroy(ActorDestroyReason aWhy) override;
   void DeallocPUiCompositorControllerParent() override;
 
   // Class specific functions
 #if defined(MOZ_WIDGET_ANDROID)
   void RegisterAndroidDynamicToolbarAnimator(
       AndroidDynamicToolbarAnimator* aAnimator);
 #endif  // MOZ_WIDGET_ANDROID
--- a/gfx/layers/wr/WebRenderBridgeChild.h
+++ b/gfx/layers/wr/WebRenderBridgeChild.h
@@ -209,19 +209,19 @@ class WebRenderBridgeChild final : publi
   bool InForwarderThread() override;
 
   void ActorDestroy(ActorDestroyReason why) override;
 
   void DoDestroy();
 
   mozilla::ipc::IPCResult RecvWrUpdated(
       const wr::IdNamespace& aNewIdNamespace,
-      const TextureFactoryIdentifier& textureFactoryIdentifier) override;
+      const TextureFactoryIdentifier& textureFactoryIdentifier);
   mozilla::ipc::IPCResult RecvWrReleasedImages(
-      nsTArray<wr::ExternalImageKeyPair>&& aPairs) override;
+      nsTArray<wr::ExternalImageKeyPair>&& aPairs);
 
   void AddIPDLReference() {
     MOZ_ASSERT(mIPCOpen == false);
     mIPCOpen = true;
     AddRef();
   }
   void ReleaseIPDLReference() {
     MOZ_ASSERT(mIPCOpen == true);
--- a/gfx/vr/ipc/VRChild.h
+++ b/gfx/vr/ipc/VRChild.h
@@ -29,22 +29,22 @@ class VRChild final : public PVRChild, p
   ~VRChild() = default;
 
   static void Destroy(UniquePtr<VRChild>&& aChild);
   void Init();
   virtual void OnVarChanged(const GfxVarUpdate& aVar) override;
 
  protected:
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
-  virtual mozilla::ipc::IPCResult RecvOpenVRControllerActionPathToParent(
-      const nsCString& aPath) override;
-  virtual mozilla::ipc::IPCResult RecvOpenVRControllerManifestPathToParent(
-      const OpenVRControllerType& aType, const nsCString& aPath) override;
-  virtual mozilla::ipc::IPCResult RecvInitCrashReporter(
-      Shmem&& shmem, const NativeThreadId& aThreadId) override;
+  mozilla::ipc::IPCResult RecvOpenVRControllerActionPathToParent(
+      const nsCString& aPath);
+  mozilla::ipc::IPCResult RecvOpenVRControllerManifestPathToParent(
+      const OpenVRControllerType& aType, const nsCString& aPath);
+  mozilla::ipc::IPCResult RecvInitCrashReporter(
+      Shmem&& shmem, const NativeThreadId& aThreadId);
 
  private:
   VRProcessParent* mHost;
   UniquePtr<ipc::CrashReporterHost> mCrashReporter;
 };
 
 }  // namespace gfx
 }  // namespace mozilla
--- a/gfx/vr/ipc/VRGPUParent.h
+++ b/gfx/vr/ipc/VRGPUParent.h
@@ -20,18 +20,18 @@ class VRGPUParent final : public PVRGPUP
 
  public:
   static RefPtr<VRGPUParent> CreateForGPU(Endpoint<PVRGPUParent>&& aEndpoint);
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
   bool IsClosed();
 
  protected:
   void Bind(Endpoint<PVRGPUParent>&& aEndpoint);
-  virtual mozilla::ipc::IPCResult RecvStartVRService() override;
-  virtual mozilla::ipc::IPCResult RecvStopVRService() override;
+  mozilla::ipc::IPCResult RecvStartVRService();
+  mozilla::ipc::IPCResult RecvStopVRService();
 
  private:
   explicit VRGPUParent(ProcessId aChildProcessId);
   ~VRGPUParent();
 
   void DeferredDestroy();
 
   RefPtr<VRGPUParent> mSelfRef;
--- a/gfx/vr/ipc/VRManagerChild.h
+++ b/gfx/vr/ipc/VRManagerChild.h
@@ -91,33 +91,32 @@ class VRManagerChild : public PVRManager
   ~VRManagerChild();
   void Destroy();
   static void DeferredDestroy(RefPtr<VRManagerChild> aVRManagerChild);
 
   PVRLayerChild* AllocPVRLayerChild(const uint32_t& aDisplayID,
                                     const uint32_t& aGroup);
   bool DeallocPVRLayerChild(PVRLayerChild* actor);
 
-  virtual mozilla::ipc::IPCResult RecvUpdateDisplayInfo(
-      nsTArray<VRDisplayInfo>&& aDisplayUpdates) override;
+  mozilla::ipc::IPCResult RecvUpdateDisplayInfo(
+      nsTArray<VRDisplayInfo>&& aDisplayUpdates);
 
-  virtual mozilla::ipc::IPCResult RecvDispatchSubmitFrameResult(
-      const uint32_t& aDisplayID,
-      const VRSubmitFrameResultInfo& aResult) override;
-  virtual mozilla::ipc::IPCResult RecvGamepadUpdate(
-      const GamepadChangeEvent& aGamepadEvent) override;
-  virtual mozilla::ipc::IPCResult RecvReplyGamepadVibrateHaptic(
-      const uint32_t& aPromiseID) override;
+  mozilla::ipc::IPCResult RecvDispatchSubmitFrameResult(
+      const uint32_t& aDisplayID, const VRSubmitFrameResultInfo& aResult);
+  mozilla::ipc::IPCResult RecvGamepadUpdate(
+      const GamepadChangeEvent& aGamepadEvent);
+  mozilla::ipc::IPCResult RecvReplyGamepadVibrateHaptic(
+      const uint32_t& aPromiseID);
 
-  virtual mozilla::ipc::IPCResult RecvReplyCreateVRServiceTestDisplay(
+  mozilla::ipc::IPCResult RecvReplyCreateVRServiceTestDisplay(
       const nsCString& aID, const uint32_t& aPromiseID,
-      const uint32_t& aDeviceID) override;
-  virtual mozilla::ipc::IPCResult RecvReplyCreateVRServiceTestController(
+      const uint32_t& aDeviceID);
+  mozilla::ipc::IPCResult RecvReplyCreateVRServiceTestController(
       const nsCString& aID, const uint32_t& aPromiseID,
-      const uint32_t& aDeviceID) override;
+      const uint32_t& aDeviceID);
   bool IsSameProcess() const { return OtherPid() == base::GetCurrentProcId(); }
 
  private:
   void FireDOMVRDisplayMountedEventInternal(uint32_t aDisplayID);
   void FireDOMVRDisplayUnmountedEventInternal(uint32_t aDisplayID);
   void FireDOMVRDisplayConnectEventInternal(uint32_t aDisplayID);
   void FireDOMVRDisplayDisconnectEventInternal(uint32_t aDisplayID);
   void FireDOMVRDisplayPresentChangeEventInternal(uint32_t aDisplayID);
--- a/gfx/vr/ipc/VRManagerParent.h
+++ b/gfx/vr/ipc/VRManagerParent.h
@@ -50,54 +50,50 @@ class VRManagerParent final : public PVR
 
   PVRLayerParent* AllocPVRLayerParent(const uint32_t& aDisplayID,
                                       const uint32_t& aGroup);
   bool DeallocPVRLayerParent(PVRLayerParent* actor);
 
   virtual void ActorDestroy(ActorDestroyReason why) override;
   void OnChannelConnected(int32_t pid) override;
 
-  virtual mozilla::ipc::IPCResult RecvRefreshDisplays() override;
-  virtual mozilla::ipc::IPCResult RecvResetSensor(
-      const uint32_t& aDisplayID) override;
-  virtual mozilla::ipc::IPCResult RecvSetGroupMask(
-      const uint32_t& aDisplayID, const uint32_t& aGroupMask) override;
-  virtual mozilla::ipc::IPCResult RecvSetHaveEventListener(
-      const bool& aHaveEventListener) override;
-  virtual mozilla::ipc::IPCResult RecvControllerListenerAdded() override;
-  virtual mozilla::ipc::IPCResult RecvControllerListenerRemoved() override;
-  virtual mozilla::ipc::IPCResult RecvVibrateHaptic(
-      const uint32_t& aControllerIdx, const uint32_t& aHapticIndex,
-      const double& aIntensity, const double& aDuration,
-      const uint32_t& aPromiseID) override;
-  virtual mozilla::ipc::IPCResult RecvStopVibrateHaptic(
-      const uint32_t& aControllerIdx) override;
-  virtual mozilla::ipc::IPCResult RecvCreateVRTestSystem() override;
-  virtual mozilla::ipc::IPCResult RecvCreateVRServiceTestDisplay(
-      const nsCString& aID, const uint32_t& aPromiseID) override;
-  virtual mozilla::ipc::IPCResult RecvCreateVRServiceTestController(
-      const nsCString& aID, const uint32_t& aPromiseID) override;
-  virtual mozilla::ipc::IPCResult RecvSetDisplayInfoToMockDisplay(
-      const uint32_t& aDeviceID, const VRDisplayInfo& aDisplayInfo) override;
-  virtual mozilla::ipc::IPCResult RecvSetSensorStateToMockDisplay(
-      const uint32_t& aDeviceID, const VRHMDSensorState& aSensorState) override;
-  virtual mozilla::ipc::IPCResult RecvNewButtonEventToMockController(
-      const uint32_t& aDeviceID, const long& aButton,
-      const bool& aPressed) override;
-  virtual mozilla::ipc::IPCResult RecvNewAxisMoveEventToMockController(
-      const uint32_t& aDeviceID, const long& aAxis,
-      const double& aValue) override;
-  virtual mozilla::ipc::IPCResult RecvNewPoseMoveToMockController(
-      const uint32_t& aDeviceID, const GamepadPoseState& pose) override;
-  virtual mozilla::ipc::IPCResult RecvStartVRNavigation(
-      const uint32_t& aDeviceID) override;
-  virtual mozilla::ipc::IPCResult RecvStopVRNavigation(
-      const uint32_t& aDeviceID, const TimeDuration& aTimeout) override;
-  virtual mozilla::ipc::IPCResult RecvStartActivity() override;
-  virtual mozilla::ipc::IPCResult RecvStopActivity() override;
+  mozilla::ipc::IPCResult RecvRefreshDisplays();
+  mozilla::ipc::IPCResult RecvResetSensor(const uint32_t& aDisplayID);
+  mozilla::ipc::IPCResult RecvSetGroupMask(const uint32_t& aDisplayID,
+                                           const uint32_t& aGroupMask);
+  mozilla::ipc::IPCResult RecvSetHaveEventListener(
+      const bool& aHaveEventListener);
+  mozilla::ipc::IPCResult RecvControllerListenerAdded();
+  mozilla::ipc::IPCResult RecvControllerListenerRemoved();
+  mozilla::ipc::IPCResult RecvVibrateHaptic(const uint32_t& aControllerIdx,
+                                            const uint32_t& aHapticIndex,
+                                            const double& aIntensity,
+                                            const double& aDuration,
+                                            const uint32_t& aPromiseID);
+  mozilla::ipc::IPCResult RecvStopVibrateHaptic(const uint32_t& aControllerIdx);
+  mozilla::ipc::IPCResult RecvCreateVRTestSystem();
+  mozilla::ipc::IPCResult RecvCreateVRServiceTestDisplay(
+      const nsCString& aID, const uint32_t& aPromiseID);
+  mozilla::ipc::IPCResult RecvCreateVRServiceTestController(
+      const nsCString& aID, const uint32_t& aPromiseID);
+  mozilla::ipc::IPCResult RecvSetDisplayInfoToMockDisplay(
+      const uint32_t& aDeviceID, const VRDisplayInfo& aDisplayInfo);
+  mozilla::ipc::IPCResult RecvSetSensorStateToMockDisplay(
+      const uint32_t& aDeviceID, const VRHMDSensorState& aSensorState);
+  mozilla::ipc::IPCResult RecvNewButtonEventToMockController(
+      const uint32_t& aDeviceID, const long& aButton, const bool& aPressed);
+  mozilla::ipc::IPCResult RecvNewAxisMoveEventToMockController(
+      const uint32_t& aDeviceID, const long& aAxis, const double& aValue);
+  mozilla::ipc::IPCResult RecvNewPoseMoveToMockController(
+      const uint32_t& aDeviceID, const GamepadPoseState& pose);
+  mozilla::ipc::IPCResult RecvStartVRNavigation(const uint32_t& aDeviceID);
+  mozilla::ipc::IPCResult RecvStopVRNavigation(const uint32_t& aDeviceID,
+                                               const TimeDuration& aTimeout);
+  mozilla::ipc::IPCResult RecvStartActivity();
+  mozilla::ipc::IPCResult RecvStopActivity();
 
  private:
   void RegisterWithManager();
   void UnregisterFromManager();
 
   void Bind(Endpoint<PVRManagerParent>&& aEndpoint);
 
   static void RegisterVRManagerInCompositorThread(VRManagerParent* aVRManager);
--- a/gfx/vr/ipc/VRParent.h
+++ b/gfx/vr/ipc/VRParent.h
@@ -29,31 +29,28 @@ class VRParent final : public PVRParent 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
   bool GetOpenVRControllerActionPath(nsCString* aPath);
   bool GetOpenVRControllerManifestPath(OpenVRControllerType aType,
                                        nsCString* aPath);
 
  protected:
   ~VRParent() = default;
 
-  virtual mozilla::ipc::IPCResult RecvNewGPUVRManager(
-      Endpoint<PVRGPUParent>&& aEndpoint) override;
-  virtual mozilla::ipc::IPCResult RecvInit(
-      nsTArray<GfxPrefSetting>&& prefs, nsTArray<GfxVarUpdate>&& vars,
-      const DevicePrefs& devicePrefs) override;
-  virtual mozilla::ipc::IPCResult RecvNotifyVsync(
-      const TimeStamp& vsyncTimestamp) override;
-  virtual mozilla::ipc::IPCResult RecvUpdatePref(
-      const GfxPrefSetting& setting) override;
-  virtual mozilla::ipc::IPCResult RecvUpdateVar(
-      const GfxVarUpdate& pref) override;
-  virtual mozilla::ipc::IPCResult RecvOpenVRControllerActionPathToVR(
-      const nsCString& aPath) override;
-  virtual mozilla::ipc::IPCResult RecvOpenVRControllerManifestPathToVR(
-      const OpenVRControllerType& aType, const nsCString& aPath) override;
+  mozilla::ipc::IPCResult RecvNewGPUVRManager(
+      Endpoint<PVRGPUParent>&& aEndpoint);
+  mozilla::ipc::IPCResult RecvInit(nsTArray<GfxPrefSetting>&& prefs,
+                                   nsTArray<GfxVarUpdate>&& vars,
+                                   const DevicePrefs& devicePrefs);
+  mozilla::ipc::IPCResult RecvNotifyVsync(const TimeStamp& vsyncTimestamp);
+  mozilla::ipc::IPCResult RecvUpdatePref(const GfxPrefSetting& setting);
+  mozilla::ipc::IPCResult RecvUpdateVar(const GfxVarUpdate& pref);
+  mozilla::ipc::IPCResult RecvOpenVRControllerActionPathToVR(
+      const nsCString& aPath);
+  mozilla::ipc::IPCResult RecvOpenVRControllerManifestPathToVR(
+      const OpenVRControllerType& aType, const nsCString& aPath);
 
  private:
   nsCString mOpenVRControllerAction;
   nsDataHashtable<nsUint32HashKey, nsCString> mOpenVRControllerManifest;
   RefPtr<VRGPUParent> mVRGPUParent;
   DISALLOW_COPY_AND_ASSIGN(VRParent);
 };
 
--- a/ipc/glue/FileDescriptorSetChild.h
+++ b/ipc/glue/FileDescriptorSetChild.h
@@ -34,16 +34,16 @@ class FileDescriptorSetChild final : pub
 
  public:
   void ForgetFileDescriptors(nsTArray<FileDescriptor>& aFileDescriptors);
 
  private:
   explicit FileDescriptorSetChild(const FileDescriptor& aFileDescriptor);
   ~FileDescriptorSetChild();
 
-  virtual mozilla::ipc::IPCResult RecvAddFileDescriptor(
-      const FileDescriptor& aFileDescriptor) override;
+  mozilla::ipc::IPCResult RecvAddFileDescriptor(
+      const FileDescriptor& aFileDescriptor);
 };
 
 }  // namespace ipc
 }  // namespace mozilla
 
 #endif  // mozilla_ipc_FileDescriptorSetChild_h__
--- a/ipc/glue/FileDescriptorSetParent.h
+++ b/ipc/glue/FileDescriptorSetParent.h
@@ -36,16 +36,16 @@ class FileDescriptorSetParent final : pu
   void ForgetFileDescriptors(nsTArray<FileDescriptor>& aFileDescriptors);
 
  private:
   explicit FileDescriptorSetParent(const FileDescriptor& aFileDescriptor);
   ~FileDescriptorSetParent();
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  virtual mozilla::ipc::IPCResult RecvAddFileDescriptor(
-      const FileDescriptor& aFileDescriptor) override;
+  mozilla::ipc::IPCResult RecvAddFileDescriptor(
+      const FileDescriptor& aFileDescriptor);
 };
 
 }  // namespace ipc
 }  // namespace mozilla
 
 #endif  // mozilla_ipc_FileDescriptorSetParent_h__
--- a/ipc/ipdl/ipdl/lower.py
+++ b/ipc/ipdl/ipdl/lower.py
@@ -3152,17 +3152,19 @@ class _GenerateProtocolActorCode(ipdl.as
                                             side=self.side, implicit=implicit),
                     ret=Type('mozilla::ipc::IPCResult'),
                     methodspec=MethodSpec.VIRTUAL)
 
                 if isctor or isdtor:
                     defaultRecv = MethodDefn(recvDecl)
                     defaultRecv.addstmt(StmtReturn(ExprCall(ExprVar('IPC_OK'))))
                     self.cls.addstmt(defaultRecv)
-                else:
+                elif (self.protocol.name, self.side) in VIRTUAL_CALL_CLASSES:
+                    # If we're using virtual calls, we need the methods to be
+                    # declared on the base class.
                     recvDecl.methodspec = MethodSpec.PURE
                     self.cls.addstmt(StmtDecl(recvDecl))
 
         # If we're using virtual calls, we need the methods to be declared on
         # the base class.
         if (self.protocol.name, self.side) in VIRTUAL_CALL_CLASSES:
             for md in p.messageDecls:
                 managed = md.decl.type.constructedType()
--- a/ipc/testshell/TestShellChild.h
+++ b/ipc/testshell/TestShellChild.h
@@ -16,17 +16,17 @@ namespace mozilla {
 namespace ipc {
 
 class XPCShellEnvironment;
 
 class TestShellChild : public PTestShellChild {
  public:
   TestShellChild();
 
-  mozilla::ipc::IPCResult RecvExecuteCommand(const nsString& aCommand) override;
+  mozilla::ipc::IPCResult RecvExecuteCommand(const nsString& aCommand);
 
   PTestShellCommandChild* AllocPTestShellCommandChild(const nsString& aCommand);
 
   mozilla::ipc::IPCResult RecvPTestShellCommandConstructor(
       PTestShellCommandChild* aActor, const nsString& aCommand) override;
 
   bool DeallocPTestShellCommandChild(PTestShellCommandChild* aCommand);
 
--- a/layout/ipc/VsyncChild.h
+++ b/layout/ipc/VsyncChild.h
@@ -48,19 +48,18 @@ class VsyncChild final : public PVsyncCh
   // TimeDuration::Forever() if mVsyncRate hasn't been set by calling
   // GetVsyncRate.
   TimeDuration VsyncRate();
 
  private:
   VsyncChild();
   virtual ~VsyncChild();
 
-  virtual mozilla::ipc::IPCResult RecvNotify(const VsyncEvent& aVsync) override;
-  virtual mozilla::ipc::IPCResult RecvVsyncRate(
-      const float& aVsyncRate) override;
+  mozilla::ipc::IPCResult RecvNotify(const VsyncEvent& aVsync);
+  mozilla::ipc::IPCResult RecvVsyncRate(const float& aVsyncRate);
   virtual void ActorDestroy(ActorDestroyReason aActorDestroyReason) override;
 
   bool mObservingVsync;
   bool mIsShutdown;
 
   // The content side vsync observer.
   RefPtr<VsyncObserver> mObserver;
   TimeDuration mVsyncRate;
--- a/layout/ipc/VsyncParent.h
+++ b/layout/ipc/VsyncParent.h
@@ -31,20 +31,20 @@ class VsyncParent final : public PVsyncP
 
  private:
   static already_AddRefed<VsyncParent> Create();
 
   VsyncParent();
   virtual ~VsyncParent();
 
   virtual bool NotifyVsync(const VsyncEvent& aVsync) override;
-  virtual mozilla::ipc::IPCResult RecvRequestVsyncRate() override;
+  mozilla::ipc::IPCResult RecvRequestVsyncRate();
 
-  virtual mozilla::ipc::IPCResult RecvObserve() override;
-  virtual mozilla::ipc::IPCResult RecvUnobserve() override;
+  mozilla::ipc::IPCResult RecvObserve();
+  mozilla::ipc::IPCResult RecvUnobserve();
   virtual void ActorDestroy(ActorDestroyReason aActorDestroyReason) override;
 
   void DispatchVsyncEvent(const VsyncEvent& aVsync);
 
   bool mObservingVsync;
   bool mDestroyed;
   nsCOMPtr<nsIThread> mBackgroundThread;
   RefPtr<RefreshTimerVsyncDispatcher> mVsyncDispatcher;
--- a/layout/printing/ipc/RemotePrintJobChild.h
+++ b/layout/printing/ipc/RemotePrintJobChild.h
@@ -28,23 +28,23 @@ class RemotePrintJobChild final : public
 
   void ActorDestroy(ActorDestroyReason aWhy) final;
 
   nsresult InitializePrint(const nsString& aDocumentTitle,
                            const nsString& aPrintToFile,
                            const int32_t& aStartPage, const int32_t& aEndPage);
 
   mozilla::ipc::IPCResult RecvPrintInitializationResult(
-      const nsresult& aRv, const FileDescriptor& aFd) final;
+      const nsresult& aRv, const FileDescriptor& aFd);
 
   void ProcessPage();
 
-  mozilla::ipc::IPCResult RecvPageProcessed(const FileDescriptor& aFd) final;
+  mozilla::ipc::IPCResult RecvPageProcessed(const FileDescriptor& aFd);
 
-  mozilla::ipc::IPCResult RecvAbortPrint(const nsresult& aRv) final;
+  mozilla::ipc::IPCResult RecvAbortPrint(const nsresult& aRv);
 
   void SetPagePrintTimer(nsPagePrintTimer* aPagePrintTimer);
 
   void SetPrintJob(nsPrintJob* aPrintJob);
 
   PRFileDesc* GetNextPageFD();
 
  private:
--- a/layout/printing/ipc/RemotePrintJobParent.h
+++ b/layout/printing/ipc/RemotePrintJobParent.h
@@ -29,32 +29,33 @@ class RemotePrintJobParent final : publi
  public:
   explicit RemotePrintJobParent(nsIPrintSettings* aPrintSettings);
 
   void ActorDestroy(ActorDestroyReason aWhy) final;
 
   mozilla::ipc::IPCResult RecvInitializePrint(const nsString& aDocumentTitle,
                                               const nsString& aPrintToFile,
                                               const int32_t& aStartPage,
-                                              const int32_t& aEndPage) final;
+                                              const int32_t& aEndPage);
 
-  mozilla::ipc::IPCResult RecvProcessPage() final;
+  mozilla::ipc::IPCResult RecvProcessPage();
 
-  mozilla::ipc::IPCResult RecvFinalizePrint() final;
+  mozilla::ipc::IPCResult RecvFinalizePrint();
 
-  mozilla::ipc::IPCResult RecvAbortPrint(const nsresult& aRv) final;
+  mozilla::ipc::IPCResult RecvAbortPrint(const nsresult& aRv);
 
   mozilla::ipc::IPCResult RecvStateChange(const long& aStateFlags,
-                                          const nsresult& aStatus) final;
+                                          const nsresult& aStatus);
 
-  mozilla::ipc::IPCResult RecvProgressChange(
-      const long& aCurSelfProgress, const long& aMaxSelfProgress,
-      const long& aCurTotalProgress, const long& aMaxTotalProgress) final;
+  mozilla::ipc::IPCResult RecvProgressChange(const long& aCurSelfProgress,
+                                             const long& aMaxSelfProgress,
+                                             const long& aCurTotalProgress,
+                                             const long& aMaxTotalProgress);
 
-  mozilla::ipc::IPCResult RecvStatusChange(const nsresult& aStatus) final;
+  mozilla::ipc::IPCResult RecvStatusChange(const nsresult& aStatus);
 
   /**
    * Register a progress listener to receive print progress updates.
    *
    * @param aListener the progress listener to register. Must not be null.
    */
   void RegisterListener(nsIWebProgressListener* aListener);
 
--- a/netwerk/cookie/CookieServiceChild.h
+++ b/netwerk/cookie/CookieServiceChild.h
@@ -81,31 +81,30 @@ class CookieServiceChild : public PCooki
 
   uint32_t CountCookiesFromHashTable(const nsCString &aBaseDomain,
                                      const OriginAttributes &aOriginAttrs);
 
   void PrefChanged(nsIPrefBranch *aPrefBranch);
 
   bool RequireThirdPartyCheck();
 
-  virtual mozilla::ipc::IPCResult RecvTrackCookiesLoad(
-      nsTArray<CookieStruct> &&aCookiesList,
-      const OriginAttributes &aAttrs) override;
+  mozilla::ipc::IPCResult RecvTrackCookiesLoad(
+      nsTArray<CookieStruct> &&aCookiesList, const OriginAttributes &aAttrs);
 
-  virtual mozilla::ipc::IPCResult RecvRemoveAll() override;
+  mozilla::ipc::IPCResult RecvRemoveAll();
 
-  virtual mozilla::ipc::IPCResult RecvRemoveBatchDeletedCookies(
+  mozilla::ipc::IPCResult RecvRemoveBatchDeletedCookies(
       nsTArray<CookieStruct> &&aCookiesList,
-      nsTArray<OriginAttributes> &&aAttrsList) override;
+      nsTArray<OriginAttributes> &&aAttrsList);
 
-  virtual mozilla::ipc::IPCResult RecvRemoveCookie(
-      const CookieStruct &aCookie, const OriginAttributes &aAttrs) override;
+  mozilla::ipc::IPCResult RecvRemoveCookie(const CookieStruct &aCookie,
+                                           const OriginAttributes &aAttrs);
 
-  virtual mozilla::ipc::IPCResult RecvAddCookie(
-      const CookieStruct &aCookie, const OriginAttributes &aAttrs) override;
+  mozilla::ipc::IPCResult RecvAddCookie(const CookieStruct &aCookie,
+                                        const OriginAttributes &aAttrs);
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
   CookiesMap mCookiesMap;
   nsCOMPtr<nsITimer> mCookieTimer;
   nsCOMPtr<mozIThirdPartyUtil> mThirdPartyUtil;
   nsCOMPtr<nsIEffectiveTLDService> mTLDService;
   uint8_t mCookieBehavior;
--- a/netwerk/cookie/CookieServiceParent.h
+++ b/netwerk/cookie/CookieServiceParent.h
@@ -39,28 +39,28 @@ class CookieServiceParent : public PCook
   // an update from the content process. This is used in ContentParent to make
   // sure that we are only forwarding those cookie updates to other content
   // processes, not the one they originated from.
   bool ProcessingCookie() { return mProcessingCookie; }
 
  protected:
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  virtual mozilla::ipc::IPCResult RecvSetCookieString(
+  mozilla::ipc::IPCResult RecvSetCookieString(
       const URIParams &aHost, const OptionalURIParams &aChannelURI,
       const bool &aIsForeign, const bool &aIsTrackingResource,
       const bool &aFirstPartyStorageAccessGranted,
       const nsCString &aCookieString, const nsCString &aServerTime,
-      const OriginAttributes &aAttrs, const bool &aFromHttp) override;
-  virtual mozilla::ipc::IPCResult RecvPrepareCookieList(
+      const OriginAttributes &aAttrs, const bool &aFromHttp);
+  mozilla::ipc::IPCResult RecvPrepareCookieList(
       const URIParams &aHost, const bool &aIsForeign,
       const bool &aIsTackingResource,
       const bool &aFirstPartyStorageAccessGranted,
       const bool &aIsSafeTopLevelNav, const bool &aIsSameSiteForeign,
-      const OriginAttributes &aAttrs) override;
+      const OriginAttributes &aAttrs);
 
   void SerialializeCookieList(const nsTArray<nsCookie *> &aFoundCookieList,
                               nsTArray<CookieStruct> &aCookiesList,
                               nsIURI *aHostURI);
 
   RefPtr<nsCookieService> mCookieService;
   bool mProcessingCookie;
 };
--- a/netwerk/dns/DNSRequestChild.h
+++ b/netwerk/dns/DNSRequestChild.h
@@ -37,18 +37,17 @@ class DNSRequestChild final : public PDN
   void CallOnLookupComplete();
   void CallOnLookupByTypeComplete();
 
  protected:
   friend class CancelDNSRequestEvent;
   friend class ChildDNSService;
   virtual ~DNSRequestChild() {}
 
-  virtual mozilla::ipc::IPCResult RecvLookupCompleted(
-      const DNSRequestResponse& reply) override;
+  mozilla::ipc::IPCResult RecvLookupCompleted(const DNSRequestResponse& reply);
   virtual void ActorDestroy(ActorDestroyReason why) override;
 
   nsCOMPtr<nsIDNSListener> mListener;
   nsCOMPtr<nsIEventTarget> mTarget;
   nsCOMPtr<nsIDNSRecord> mResultRecord;
   nsCOMPtr<nsIDNSByTypeRecord>
       mResultByTypeRecords;  // the result of a by-type
                              // query (mType must not be
--- a/netwerk/dns/DNSRequestParent.h
+++ b/netwerk/dns/DNSRequestParent.h
@@ -24,17 +24,17 @@ class DNSRequestParent : public PDNSRequ
   void DoAsyncResolve(const nsACString& hostname,
                       const OriginAttributes& originAttributes, uint32_t flags);
 
   // Pass args here rather than storing them in the parent; they are only
   // needed if the request is to be canceled.
   mozilla::ipc::IPCResult RecvCancelDNSRequest(
       const nsCString& hostName, const uint16_t& type,
       const OriginAttributes& originAttributes, const uint32_t& flags,
-      const nsresult& reason) override;
+      const nsresult& reason);
   mozilla::ipc::IPCResult Recv__delete__() override;
 
  protected:
   virtual void ActorDestroy(ActorDestroyReason why) override;
 
  private:
   virtual ~DNSRequestParent() = default;
 
--- a/netwerk/ipc/NeckoChild.h
+++ b/netwerk/ipc/NeckoChild.h
@@ -74,34 +74,31 @@ class NeckoChild : public PNeckoChild {
   bool DeallocPFileChannelChild(PFileChannelChild* child);
   PSimpleChannelChild* AllocPSimpleChannelChild(const uint32_t& channelId);
   bool DeallocPSimpleChannelChild(PSimpleChannelChild* child);
   PChannelDiverterChild* AllocPChannelDiverterChild(
       const ChannelDiverterArgs& channel);
   bool DeallocPChannelDiverterChild(PChannelDiverterChild* actor);
   PTransportProviderChild* AllocPTransportProviderChild();
   bool DeallocPTransportProviderChild(PTransportProviderChild* aActor);
-  virtual mozilla::ipc::IPCResult RecvAsyncAuthPromptForNestedFrame(
+  mozilla::ipc::IPCResult RecvAsyncAuthPromptForNestedFrame(
       const TabId& aNestedFrameId, const nsCString& aUri,
-      const nsString& aRealm, const uint64_t& aCallbackId) override;
+      const nsString& aRealm, const uint64_t& aCallbackId);
   PWebSocketEventListenerChild* AllocPWebSocketEventListenerChild(
       const uint64_t& aInnerWindowID);
   bool DeallocPWebSocketEventListenerChild(PWebSocketEventListenerChild*);
 
   /* Predictor Messsages */
-  virtual mozilla::ipc::IPCResult RecvPredOnPredictPrefetch(
-      const URIParams& aURI, const uint32_t& aHttpStatus) override;
-  virtual mozilla::ipc::IPCResult RecvPredOnPredictPreconnect(
-      const URIParams& aURI) override;
-  virtual mozilla::ipc::IPCResult RecvPredOnPredictDNS(
-      const URIParams& aURI) override;
+  mozilla::ipc::IPCResult RecvPredOnPredictPrefetch(
+      const URIParams& aURI, const uint32_t& aHttpStatus);
+  mozilla::ipc::IPCResult RecvPredOnPredictPreconnect(const URIParams& aURI);
+  mozilla::ipc::IPCResult RecvPredOnPredictDNS(const URIParams& aURI);
 
-  virtual mozilla::ipc::IPCResult RecvSpeculativeConnectRequest() override;
-  virtual mozilla::ipc::IPCResult RecvNetworkChangeNotification(
-      nsCString const& type) override;
+  mozilla::ipc::IPCResult RecvSpeculativeConnectRequest();
+  mozilla::ipc::IPCResult RecvNetworkChangeNotification(nsCString const& type);
 
   PTrackingDummyChannelChild* AllocPTrackingDummyChannelChild(
       nsIURI* aURI, nsIURI* aTopWindowURI, const nsresult& aTopWindowURIResult,
       const OptionalLoadInfoArgs& aLoadInfo);
 
   bool DeallocPTrackingDummyChannelChild(PTrackingDummyChannelChild* aChannel);
 };
 
--- a/netwerk/ipc/NeckoParent.h
+++ b/netwerk/ipc/NeckoParent.h
@@ -147,27 +147,26 @@ class NeckoParent : public PNeckoParent 
   PDNSRequestParent* AllocPDNSRequestParent(
       const nsCString& aHost, const OriginAttributes& aOriginAttributes,
       const uint32_t& aFlags);
   virtual mozilla::ipc::IPCResult RecvPDNSRequestConstructor(
       PDNSRequestParent* actor, const nsCString& hostName,
       const OriginAttributes& aOriginAttributes,
       const uint32_t& flags) override;
   bool DeallocPDNSRequestParent(PDNSRequestParent*);
-  virtual mozilla::ipc::IPCResult RecvSpeculativeConnect(
-      const URIParams& aURI, const Principal& aPrincipal,
-      const bool& aAnonymous) override;
-  virtual mozilla::ipc::IPCResult RecvHTMLDNSPrefetch(
+  mozilla::ipc::IPCResult RecvSpeculativeConnect(const URIParams& aURI,
+                                                 const Principal& aPrincipal,
+                                                 const bool& aAnonymous);
+  mozilla::ipc::IPCResult RecvHTMLDNSPrefetch(
       const nsString& hostname, const bool& isHttps,
-      const OriginAttributes& aOriginAttributes,
-      const uint16_t& flags) override;
-  virtual mozilla::ipc::IPCResult RecvCancelHTMLDNSPrefetch(
+      const OriginAttributes& aOriginAttributes, const uint16_t& flags);
+  mozilla::ipc::IPCResult RecvCancelHTMLDNSPrefetch(
       const nsString& hostname, const bool& isHttps,
       const OriginAttributes& aOriginAttributes, const uint16_t& flags,
-      const nsresult& reason) override;
+      const nsresult& reason);
   PWebSocketEventListenerParent* AllocPWebSocketEventListenerParent(
       const uint64_t& aInnerWindowID);
   bool DeallocPWebSocketEventListenerParent(PWebSocketEventListenerParent*);
 
   PDataChannelParent* AllocPDataChannelParent(const uint32_t& channelId);
   bool DeallocPDataChannelParent(PDataChannelParent* parent);
 
   virtual mozilla::ipc::IPCResult RecvPDataChannelConstructor(
@@ -189,62 +188,60 @@ class NeckoParent : public PNeckoParent 
       const ChannelDiverterArgs& channel);
   virtual mozilla::ipc::IPCResult RecvPChannelDiverterConstructor(
       PChannelDiverterParent* actor,
       const ChannelDiverterArgs& channel) override;
   bool DeallocPChannelDiverterParent(PChannelDiverterParent* actor);
   PTransportProviderParent* AllocPTransportProviderParent();
   bool DeallocPTransportProviderParent(PTransportProviderParent* aActor);
 
-  virtual mozilla::ipc::IPCResult RecvOnAuthAvailable(
-      const uint64_t& aCallbackId, const nsString& aUser,
-      const nsString& aPassword, const nsString& aDomain) override;
-  virtual mozilla::ipc::IPCResult RecvOnAuthCancelled(
-      const uint64_t& aCallbackId, const bool& aUserCancel) override;
+  mozilla::ipc::IPCResult RecvOnAuthAvailable(const uint64_t& aCallbackId,
+                                              const nsString& aUser,
+                                              const nsString& aPassword,
+                                              const nsString& aDomain);
+  mozilla::ipc::IPCResult RecvOnAuthCancelled(const uint64_t& aCallbackId,
+                                              const bool& aUserCancel);
 
   /* Predictor Messages */
-  virtual mozilla::ipc::IPCResult RecvPredPredict(
+  mozilla::ipc::IPCResult RecvPredPredict(
       const ipc::OptionalURIParams& aTargetURI,
       const ipc::OptionalURIParams& aSourceURI,
       const PredictorPredictReason& aReason,
-      const OriginAttributes& aOriginAttributes,
-      const bool& hasVerifier) override;
+      const OriginAttributes& aOriginAttributes, const bool& hasVerifier);
 
-  virtual mozilla::ipc::IPCResult RecvPredLearn(
+  mozilla::ipc::IPCResult RecvPredLearn(
       const ipc::URIParams& aTargetURI,
       const ipc::OptionalURIParams& aSourceURI,
       const PredictorPredictReason& aReason,
-      const OriginAttributes& aOriginAttributes) override;
-  virtual mozilla::ipc::IPCResult RecvPredReset() override;
+      const OriginAttributes& aOriginAttributes);
+  mozilla::ipc::IPCResult RecvPredReset();
 
-  virtual mozilla::ipc::IPCResult RecvRequestContextLoadBegin(
-      const uint64_t& rcid) override;
-  virtual mozilla::ipc::IPCResult RecvRequestContextAfterDOMContentLoaded(
-      const uint64_t& rcid) override;
-  virtual mozilla::ipc::IPCResult RecvRemoveRequestContext(
-      const uint64_t& rcid) override;
+  mozilla::ipc::IPCResult RecvRequestContextLoadBegin(const uint64_t& rcid);
+  mozilla::ipc::IPCResult RecvRequestContextAfterDOMContentLoaded(
+      const uint64_t& rcid);
+  mozilla::ipc::IPCResult RecvRemoveRequestContext(const uint64_t& rcid);
 
   /* WebExtensions */
-  virtual mozilla::ipc::IPCResult RecvGetExtensionStream(
-      const URIParams& aURI, GetExtensionStreamResolver&& aResolve) override;
+  mozilla::ipc::IPCResult RecvGetExtensionStream(
+      const URIParams& aURI, GetExtensionStreamResolver&& aResolve);
 
-  virtual mozilla::ipc::IPCResult RecvGetExtensionFD(
-      const URIParams& aURI, GetExtensionFDResolver&& aResolve) override;
+  mozilla::ipc::IPCResult RecvGetExtensionFD(const URIParams& aURI,
+                                             GetExtensionFDResolver&& aResolve);
 
   PTrackingDummyChannelParent* AllocPTrackingDummyChannelParent(
       nsIURI* aURI, nsIURI* aTopWindowURI, const nsresult& aTopWindowURIResult,
       const OptionalLoadInfoArgs& aLoadInfo);
 
   bool DeallocPTrackingDummyChannelParent(PTrackingDummyChannelParent* aChild);
 
   virtual mozilla::ipc::IPCResult RecvPTrackingDummyChannelConstructor(
       PTrackingDummyChannelParent* aActor, nsIURI* aURI, nsIURI* aTopWindowURI,
       const nsresult& aTopWindowURIResult,
       const OptionalLoadInfoArgs& aLoadInfo) override;
 
-  virtual mozilla::ipc::IPCResult RecvInitSocketProcessBridge(
-      InitSocketProcessBridgeResolver&& aResolver) override;
+  mozilla::ipc::IPCResult RecvInitSocketProcessBridge(
+      InitSocketProcessBridgeResolver&& aResolver);
 };
 
 }  // namespace net
 }  // namespace mozilla
 
 #endif  // mozilla_net_NeckoParent_h
--- a/netwerk/ipc/SocketProcessBridgeChild.h
+++ b/netwerk/ipc/SocketProcessBridgeChild.h
@@ -22,17 +22,17 @@ class SocketProcessBridgeChild final : p
   NS_DECL_ISUPPORTS
   NS_DECL_NSIOBSERVER
 
   static bool Create(Endpoint<PSocketProcessBridgeChild>&& aEndpoint);
   static already_AddRefed<SocketProcessBridgeChild> GetSingleton();
   static void EnsureSocketProcessBridge(std::function<void()>&& aOnSuccess,
                                         std::function<void()>&& aOnFailure);
 
-  mozilla::ipc::IPCResult RecvTest() override;
+  mozilla::ipc::IPCResult RecvTest();
   void ActorDestroy(ActorDestroyReason aWhy) override;
   void DeferredDestroy();
   bool IsShuttingDown() const { return mShuttingDown; };
   bool Inited() const { return mInited; };
   ProcessId SocketProcessPid() const { return mSocketProcessPid; };
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SocketProcessBridgeChild);
--- a/netwerk/ipc/SocketProcessBridgeParent.h
+++ b/netwerk/ipc/SocketProcessBridgeParent.h
@@ -17,19 +17,19 @@ namespace net {
 // called to destroy this actor.
 class SocketProcessBridgeParent final : public PSocketProcessBridgeParent {
  public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SocketProcessBridgeParent)
 
   explicit SocketProcessBridgeParent(
       ProcessId aId, Endpoint<PSocketProcessBridgeParent>&& aEndpoint);
 
-  mozilla::ipc::IPCResult RecvTest() override;
+  mozilla::ipc::IPCResult RecvTest();
   mozilla::ipc::IPCResult RecvInitBackground(
-      Endpoint<PBackgroundParent>&& aEndpoint) override;
+      Endpoint<PBackgroundParent>&& aEndpoint);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
   void DeferredDestroy();
 
  private:
   ~SocketProcessBridgeParent();
 
   ProcessId mId;
--- a/netwerk/ipc/SocketProcessChild.h
+++ b/netwerk/ipc/SocketProcessChild.h
@@ -27,27 +27,27 @@ class SocketProcessChild final : public 
 
   static SocketProcessChild* GetSingleton();
 
   bool Init(base::ProcessId aParentPid, const char* aParentBuildID,
             MessageLoop* aIOLoop, IPC::Channel* aChannel);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  mozilla::ipc::IPCResult RecvPreferenceUpdate(const Pref& aPref) override;
+  mozilla::ipc::IPCResult RecvPreferenceUpdate(const Pref& aPref);
   mozilla::ipc::IPCResult RecvRequestMemoryReport(
       const uint32_t& generation, const bool& anonymize,
-      const bool& minimizeMemoryUsage, const MaybeFileDesc& DMDFile) override;
-  mozilla::ipc::IPCResult RecvSetOffline(const bool& aOffline) override;
+      const bool& minimizeMemoryUsage, const MaybeFileDesc& DMDFile);
+  mozilla::ipc::IPCResult RecvSetOffline(const bool& aOffline);
   mozilla::ipc::IPCResult RecvInitSocketProcessBridgeParent(
       const ProcessId& aContentProcessId,
-      Endpoint<mozilla::net::PSocketProcessBridgeParent>&& aEndpoint) override;
+      Endpoint<mozilla::net::PSocketProcessBridgeParent>&& aEndpoint);
   mozilla::ipc::IPCResult RecvInitProfiler(
-      Endpoint<mozilla::PProfilerChild>&& aEndpoint) override;
-  mozilla::ipc::IPCResult RecvSocketProcessTelemetryPing() override;
+      Endpoint<mozilla::PProfilerChild>&& aEndpoint);
+  mozilla::ipc::IPCResult RecvSocketProcessTelemetryPing();
 
   void CleanUp();
   void DestroySocketProcessBridgeParent(ProcessId aId);
 
  private:
   // Mapping of content process id and the SocketProcessBridgeParent.
   // This table keeps SocketProcessBridgeParent alive in socket process.
   nsRefPtrHashtable<nsUint32HashKey, SocketProcessBridgeParent>
--- a/netwerk/ipc/SocketProcessParent.h
+++ b/netwerk/ipc/SocketProcessParent.h
@@ -31,33 +31,31 @@ class SocketProcessParent final : public
   friend class SocketProcessHost;
 
   explicit SocketProcessParent(SocketProcessHost* aHost);
   ~SocketProcessParent();
 
   static SocketProcessParent* GetSingleton();
 
   mozilla::ipc::IPCResult RecvInitCrashReporter(
-      Shmem&& aShmem, const NativeThreadId& aThreadId) override;
-  mozilla::ipc::IPCResult RecvAddMemoryReport(
-      const MemoryReport& aReport) override;
-  mozilla::ipc::IPCResult RecvFinishMemoryReport(
-      const uint32_t& aGeneration) override;
+      Shmem&& aShmem, const NativeThreadId& aThreadId);
+  mozilla::ipc::IPCResult RecvAddMemoryReport(const MemoryReport& aReport);
+  mozilla::ipc::IPCResult RecvFinishMemoryReport(const uint32_t& aGeneration);
   mozilla::ipc::IPCResult RecvAccumulateChildHistograms(
-      InfallibleTArray<HistogramAccumulation>&& aAccumulations) override;
+      InfallibleTArray<HistogramAccumulation>&& aAccumulations);
   mozilla::ipc::IPCResult RecvAccumulateChildKeyedHistograms(
-      InfallibleTArray<KeyedHistogramAccumulation>&& aAccumulations) override;
+      InfallibleTArray<KeyedHistogramAccumulation>&& aAccumulations);
   mozilla::ipc::IPCResult RecvUpdateChildScalars(
-      InfallibleTArray<ScalarAction>&& aScalarActions) override;
+      InfallibleTArray<ScalarAction>&& aScalarActions);
   mozilla::ipc::IPCResult RecvUpdateChildKeyedScalars(
-      InfallibleTArray<KeyedScalarAction>&& aScalarActions) override;
+      InfallibleTArray<KeyedScalarAction>&& aScalarActions);
   mozilla::ipc::IPCResult RecvRecordChildEvents(
-      nsTArray<ChildEventData>&& events) override;
+      nsTArray<ChildEventData>&& events);
   mozilla::ipc::IPCResult RecvRecordDiscardedData(
-      const DiscardedData& aDiscardedData) override;
+      const DiscardedData& aDiscardedData);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
   bool SendRequestMemoryReport(const uint32_t& aGeneration,
                                const bool& aAnonymize,
                                const bool& aMinimizeMemoryUsage,
                                const MaybeFileDesc& aDMDFile);
 
  private:
--- a/netwerk/protocol/http/AltDataOutputStreamChild.h
+++ b/netwerk/protocol/http/AltDataOutputStreamChild.h
@@ -19,18 +19,18 @@ class AltDataOutputStreamChild : public 
  public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIOUTPUTSTREAM
   explicit AltDataOutputStreamChild();
 
   void AddIPDLReference();
   void ReleaseIPDLReference();
   // Saves an error code which will be reported to the writer on the next call.
-  virtual mozilla::ipc::IPCResult RecvError(const nsresult& err) override;
-  virtual mozilla::ipc::IPCResult RecvDeleteSelf() override;
+  virtual mozilla::ipc::IPCResult RecvError(const nsresult& err);
+  virtual mozilla::ipc::IPCResult RecvDeleteSelf();
 
  private:
   virtual ~AltDataOutputStreamChild() = default;
   // Sends data to the parent process in 256k chunks.
   bool WriteDataInChunks(const nsDependentCSubstring& data);
 
   bool mIPCOpen;
   // If there was an error opening the output stream or writing to it on the
--- a/netwerk/protocol/http/AltDataOutputStreamParent.h
+++ b/netwerk/protocol/http/AltDataOutputStreamParent.h
@@ -22,25 +22,25 @@ class AltDataOutputStreamParent : public
 
   // Called from NeckoParent::AllocPAltDataOutputStreamParent which also opens
   // the output stream.
   // aStream may be null
   explicit AltDataOutputStreamParent(nsIOutputStream* aStream);
 
   // Called when data is received from the content process.
   // We proceed to write that data to the output stream.
-  virtual mozilla::ipc::IPCResult RecvWriteData(const nsCString& data) override;
+  mozilla::ipc::IPCResult RecvWriteData(const nsCString& data);
   // Called when AltDataOutputStreamChild::Close() is
   // Closes and nulls the output stream.
-  virtual mozilla::ipc::IPCResult RecvClose() override;
+  mozilla::ipc::IPCResult RecvClose();
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
   // Sets an error that will be reported to the content process.
   void SetError(nsresult status) { mStatus = status; }
-  virtual mozilla::ipc::IPCResult RecvDeleteSelf() override;
+  mozilla::ipc::IPCResult RecvDeleteSelf();
 
  private:
   virtual ~AltDataOutputStreamParent();
   nsCOMPtr<nsIOutputStream> mOutputStream;
   // In case any error occurs mStatus will be != NS_OK, and this status code
   // will be sent to the content process asynchronously.
   nsresult mStatus;
   bool mIPCOpen;
--- a/netwerk/protocol/http/HttpBackgroundChannelChild.h
+++ b/netwerk/protocol/http/HttpBackgroundChannelChild.h
@@ -41,47 +41,47 @@ class HttpBackgroundChannelChild final :
   // Enqueued messages in background channel will be flushed.
   void OnStartRequestReceived();
 
  protected:
   IPCResult RecvOnTransportAndData(const nsresult& aChannelStatus,
                                    const nsresult& aTransportStatus,
                                    const uint64_t& aOffset,
                                    const uint32_t& aCount,
-                                   const nsCString& aData) override;
+                                   const nsCString& aData);
 
-  IPCResult RecvOnStopRequest(
-      const nsresult& aChannelStatus, const ResourceTimingStruct& aTiming,
-      const TimeStamp& aLastActiveTabOptHit,
-      const nsHttpHeaderArray& aResponseTrailers) override;
+  IPCResult RecvOnStopRequest(const nsresult& aChannelStatus,
+                              const ResourceTimingStruct& aTiming,
+                              const TimeStamp& aLastActiveTabOptHit,
+                              const nsHttpHeaderArray& aResponseTrailers);
 
   IPCResult RecvOnProgress(const int64_t& aProgress,
-                           const int64_t& aProgressMax) override;
+                           const int64_t& aProgressMax);
 
-  IPCResult RecvOnStatus(const nsresult& aStatus) override;
+  IPCResult RecvOnStatus(const nsresult& aStatus);
 
-  IPCResult RecvFlushedForDiversion() override;
+  IPCResult RecvFlushedForDiversion();
 
-  IPCResult RecvDivertMessages() override;
+  IPCResult RecvDivertMessages();
 
-  IPCResult RecvOnStartRequestSent() override;
+  IPCResult RecvOnStartRequestSent();
 
   IPCResult RecvNotifyChannelClassifierProtectionDisabled(
-      const uint32_t& aAcceptedReason) override;
+      const uint32_t& aAcceptedReason);
 
-  IPCResult RecvNotifyCookieAllowed() override;
+  IPCResult RecvNotifyCookieAllowed();
 
-  IPCResult RecvNotifyCookieBlocked(const uint32_t& aRejectedReason) override;
+  IPCResult RecvNotifyCookieBlocked(const uint32_t& aRejectedReason);
 
-  IPCResult RecvNotifyTrackingResource(const bool& aIsThirdParty) override;
+  IPCResult RecvNotifyTrackingResource(const bool& aIsThirdParty);
 
   IPCResult RecvNotifyFlashPluginStateChanged(
-      const nsIHttpChannel::FlashPluginState& aState) override;
+      const nsIHttpChannel::FlashPluginState& aState);
 
-  IPCResult RecvSetClassifierMatchedInfo(const ClassifierInfo& info) override;
+  IPCResult RecvSetClassifierMatchedInfo(const ClassifierInfo& info);
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   virtual ~HttpBackgroundChannelChild();
 
   // Initiate the creation of the PBckground IPC channel.
   // Return false if failed.
--- a/netwerk/protocol/websocket/WebSocketChannelChild.h
+++ b/netwerk/protocol/websocket/WebSocketChannelChild.h
@@ -49,25 +49,23 @@ class WebSocketChannelChild final : publ
   bool IsEncrypted() const override;
 
  private:
   ~WebSocketChannelChild();
 
   mozilla::ipc::IPCResult RecvOnStart(const nsCString& aProtocol,
                                       const nsCString& aExtensions,
                                       const nsString& aEffectiveURL,
-                                      const bool& aSecure) override;
-  mozilla::ipc::IPCResult RecvOnStop(const nsresult& aStatusCode) override;
-  mozilla::ipc::IPCResult RecvOnMessageAvailable(
-      const nsCString& aMsg) override;
-  mozilla::ipc::IPCResult RecvOnBinaryMessageAvailable(
-      const nsCString& aMsg) override;
-  mozilla::ipc::IPCResult RecvOnAcknowledge(const uint32_t& aSize) override;
+                                      const bool& aSecure);
+  mozilla::ipc::IPCResult RecvOnStop(const nsresult& aStatusCode);
+  mozilla::ipc::IPCResult RecvOnMessageAvailable(const nsCString& aMsg);
+  mozilla::ipc::IPCResult RecvOnBinaryMessageAvailable(const nsCString& aMsg);
+  mozilla::ipc::IPCResult RecvOnAcknowledge(const uint32_t& aSize);
   mozilla::ipc::IPCResult RecvOnServerClose(const uint16_t& aCode,
-                                            const nsCString& aReason) override;
+                                            const nsCString& aReason);
 
   void OnStart(const nsCString& aProtocol, const nsCString& aExtensions,
                const nsString& aEffectiveURL, const bool& aSecure);
   void OnStop(const nsresult& aStatusCode);
   void OnMessageAvailable(const nsCString& aMsg);
   void OnBinaryMessageAvailable(const nsCString& aMsg);
   void OnAcknowledge(const uint32_t& aSize);
   void OnServerClose(const uint16_t& aCode, const nsCString& aReason);
--- a/netwerk/protocol/websocket/WebSocketChannelParent.h
+++ b/netwerk/protocol/websocket/WebSocketChannelParent.h
@@ -41,24 +41,24 @@ class WebSocketChannelParent : public PW
   mozilla::ipc::IPCResult RecvAsyncOpen(
       const OptionalURIParams& aURI, const nsCString& aOrigin,
       const uint64_t& aInnerWindowID, const nsCString& aProtocol,
       const bool& aSecure, const uint32_t& aPingInterval,
       const bool& aClientSetPingInterval, const uint32_t& aPingTimeout,
       const bool& aClientSetPingTimeout,
       const OptionalLoadInfoArgs& aLoadInfoArgs,
       const OptionalTransportProvider& aTransportProvider,
-      const nsCString& aNegotiatedExtensions) override;
+      const nsCString& aNegotiatedExtensions);
   mozilla::ipc::IPCResult RecvClose(const uint16_t& code,
-                                    const nsCString& reason) override;
-  mozilla::ipc::IPCResult RecvSendMsg(const nsCString& aMsg) override;
-  mozilla::ipc::IPCResult RecvSendBinaryMsg(const nsCString& aMsg) override;
-  mozilla::ipc::IPCResult RecvSendBinaryStream(
-      const IPCStream& aStream, const uint32_t& aLength) override;
-  mozilla::ipc::IPCResult RecvDeleteSelf() override;
+                                    const nsCString& reason);
+  mozilla::ipc::IPCResult RecvSendMsg(const nsCString& aMsg);
+  mozilla::ipc::IPCResult RecvSendBinaryMsg(const nsCString& aMsg);
+  mozilla::ipc::IPCResult RecvSendBinaryStream(const IPCStream& aStream,
+                                               const uint32_t& aLength);
+  mozilla::ipc::IPCResult RecvDeleteSelf();
 
   void ActorDestroy(ActorDestroyReason why) override;
 
   nsCOMPtr<nsIAuthPromptProvider> mAuthProvider;
   nsCOMPtr<nsIWebSocketChannel> mChannel;
   nsCOMPtr<nsILoadContext> mLoadContext;
   bool mIPCOpen;
 
--- a/netwerk/protocol/websocket/WebSocketEventListenerChild.h
+++ b/netwerk/protocol/websocket/WebSocketEventListenerChild.h
@@ -20,37 +20,35 @@ class WebSocketEventListenerChild final 
  public:
   NS_INLINE_DECL_REFCOUNTING(WebSocketEventListenerChild)
 
   explicit WebSocketEventListenerChild(uint64_t aInnerWindowID,
                                        nsIEventTarget* aTarget);
 
   mozilla::ipc::IPCResult RecvWebSocketCreated(
       const uint32_t& aWebSocketSerialID, const nsString& aURI,
-      const nsCString& aProtocols) override;
+      const nsCString& aProtocols);
 
   mozilla::ipc::IPCResult RecvWebSocketOpened(
       const uint32_t& aWebSocketSerialID, const nsString& aEffectiveURI,
-      const nsCString& aProtocols, const nsCString& aExtensions) override;
+      const nsCString& aProtocols, const nsCString& aExtensions);
 
   mozilla::ipc::IPCResult RecvWebSocketMessageAvailable(
       const uint32_t& aWebSocketSerialID, const nsCString& aData,
-      const uint16_t& aMessageType) override;
+      const uint16_t& aMessageType);
 
   mozilla::ipc::IPCResult RecvWebSocketClosed(
       const uint32_t& aWebSocketSerialID, const bool& aWasClean,
-      const uint16_t& aCode, const nsString& aReason) override;
+      const uint16_t& aCode, const nsString& aReason);
 
   mozilla::ipc::IPCResult RecvFrameReceived(
-      const uint32_t& aWebSocketSerialID,
-      const WebSocketFrameData& aFrameData) override;
+      const uint32_t& aWebSocketSerialID, const WebSocketFrameData& aFrameData);
 
-  mozilla::ipc::IPCResult RecvFrameSent(
-      const uint32_t& aWebSocketSerialID,
-      const WebSocketFrameData& aFrameData) override;
+  mozilla::ipc::IPCResult RecvFrameSent(const uint32_t& aWebSocketSerialID,
+                                        const WebSocketFrameData& aFrameData);
 
   void Close();
 
  private:
   ~WebSocketEventListenerChild();
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
--- a/netwerk/protocol/websocket/WebSocketEventListenerParent.h
+++ b/netwerk/protocol/websocket/WebSocketEventListenerParent.h
@@ -23,17 +23,17 @@ class WebSocketEventListenerParent final
   NS_DECL_ISUPPORTS
   NS_DECL_NSIWEBSOCKETEVENTLISTENER
 
   explicit WebSocketEventListenerParent(uint64_t aInnerWindowID);
 
  private:
   ~WebSocketEventListenerParent();
 
-  virtual mozilla::ipc::IPCResult RecvClose() override;
+  mozilla::ipc::IPCResult RecvClose();
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
   void UnregisterListener();
 
   RefPtr<WebSocketEventService> mService;
   uint64_t mInnerWindowID;
 };
--- a/netwerk/protocol/wyciwyg/WyciwygChannelParent.h
+++ b/netwerk/protocol/wyciwyg/WyciwygChannelParent.h
@@ -31,39 +31,35 @@ class WyciwygChannelParent : public PWyc
   NS_DECL_NSISTREAMLISTENER
   NS_DECL_NSIINTERFACEREQUESTOR
 
   WyciwygChannelParent();
 
  protected:
   virtual ~WyciwygChannelParent() = default;
 
-  virtual mozilla::ipc::IPCResult RecvInit(
+  mozilla::ipc::IPCResult RecvInit(
       const URIParams& uri, const ipc::PrincipalInfo& aRequestingPrincipalInfo,
       const ipc::PrincipalInfo& aTriggeringPrincipalInfo,
       const ipc::PrincipalInfo& aPrincipalToInheritInfo,
-      const uint32_t& aSecurityFlags,
-      const uint32_t& aContentPolicyType) override;
-  virtual mozilla::ipc::IPCResult RecvAsyncOpen(
+      const uint32_t& aSecurityFlags, const uint32_t& aContentPolicyType);
+  mozilla::ipc::IPCResult RecvAsyncOpen(
       const URIParams& original, const uint32_t& loadFlags,
       const IPC::SerializedLoadContext& loadContext,
-      const PBrowserOrId& parent) override;
-  virtual mozilla::ipc::IPCResult RecvWriteToCacheEntry(
-      const nsDependentSubstring& data) override;
-  virtual mozilla::ipc::IPCResult RecvCloseCacheEntry(
-      const nsresult& reason) override;
-  virtual mozilla::ipc::IPCResult RecvSetCharsetAndSource(
-      const int32_t& source, const nsCString& charset) override;
-  virtual mozilla::ipc::IPCResult RecvSetSecurityInfo(
-      const nsCString& securityInfo) override;
-  virtual mozilla::ipc::IPCResult RecvCancel(
-      const nsresult& statusCode) override;
-  virtual mozilla::ipc::IPCResult RecvAppData(
+      const PBrowserOrId& parent);
+  mozilla::ipc::IPCResult RecvWriteToCacheEntry(
+      const nsDependentSubstring& data);
+  mozilla::ipc::IPCResult RecvCloseCacheEntry(const nsresult& reason);
+  mozilla::ipc::IPCResult RecvSetCharsetAndSource(const int32_t& source,
+                                                  const nsCString& charset);
+  mozilla::ipc::IPCResult RecvSetSecurityInfo(const nsCString& securityInfo);
+  mozilla::ipc::IPCResult RecvCancel(const nsresult& statusCode);
+  mozilla::ipc::IPCResult RecvAppData(
       const IPC::SerializedLoadContext& loadContext,
-      const PBrowserOrId& parent) override;
+      const PBrowserOrId& parent);
 
   virtual void ActorDestroy(ActorDestroyReason why) override;
 
   bool SetupAppData(const IPC::SerializedLoadContext& loadContext,
                     const PBrowserOrId& aParent);
 
   nsCOMPtr<nsIWyciwygChannel> mChannel;
   bool mIPCClosed;
--- a/security/manager/ssl/PSMContentListener.h
+++ b/security/manager/ssl/PSMContentListener.h
@@ -51,32 +51,30 @@ class PSMContentStreamListener : public 
 
 // Parent actor for importing a remote cert when the load was started by the
 // child.
 class PSMContentDownloaderParent : public PPSMContentDownloaderParent,
                                    public PSMContentStreamListener {
  public:
   explicit PSMContentDownloaderParent(uint32_t type);
 
-  virtual mozilla::ipc::IPCResult RecvOnStartRequest(
-      const uint32_t &contentLength) override;
-  virtual mozilla::ipc::IPCResult RecvOnDataAvailable(
-      const nsCString &data, const uint64_t &offset,
-      const uint32_t &count) override;
-  virtual mozilla::ipc::IPCResult RecvOnStopRequest(
-      const nsresult &code) override;
+  mozilla::ipc::IPCResult RecvOnStartRequest(const uint32_t &contentLength);
+  mozilla::ipc::IPCResult RecvOnDataAvailable(const nsCString &data,
+                                              const uint64_t &offset,
+                                              const uint32_t &count);
+  mozilla::ipc::IPCResult RecvOnStopRequest(const nsresult &code);
 
   // We inherit most of nsIStreamListener from PSMContentStreamListener, but
   // we have to override OnStopRequest to know when we're done with our IPC
   // ref.
   NS_IMETHOD OnStopRequest(nsIRequest *request, nsISupports *aContext,
                            nsresult code) override;
 
-  virtual mozilla::ipc::IPCResult RecvDivertToParentUsing(
-      mozilla::net::PChannelDiverterParent *diverter) override;
+  mozilla::ipc::IPCResult RecvDivertToParentUsing(
+      mozilla::net::PChannelDiverterParent *diverter);
 
  protected:
   virtual ~PSMContentDownloaderParent();
 
   virtual void ActorDestroy(ActorDestroyReason why) override;
   bool mIPCOpen;
 };
 
--- a/toolkit/components/extensions/webrequest/StreamFilterChild.h
+++ b/toolkit/components/extensions/webrequest/StreamFilterChild.h
@@ -84,25 +84,25 @@ class StreamFilterChild final : public P
 
   State GetState() const { return mState; }
 
   StreamFilterStatus Status() const;
 
   void RecvInitialized(bool aSuccess);
 
  protected:
-  virtual IPCResult RecvStartRequest() override;
-  virtual IPCResult RecvData(Data&& data) override;
-  virtual IPCResult RecvStopRequest(const nsresult& aStatus) override;
-  virtual IPCResult RecvError(const nsCString& aError) override;
+  IPCResult RecvStartRequest();
+  IPCResult RecvData(Data&& data);
+  IPCResult RecvStopRequest(const nsresult& aStatus);
+  IPCResult RecvError(const nsCString& aError);
 
-  virtual IPCResult RecvClosed() override;
-  virtual IPCResult RecvSuspended() override;
-  virtual IPCResult RecvResumed() override;
-  virtual IPCResult RecvFlushData() override;
+  IPCResult RecvClosed();
+  IPCResult RecvSuspended();
+  IPCResult RecvResumed();
+  IPCResult RecvFlushData();
 
   virtual void DeallocPStreamFilterChild() override;
 
   void SetStreamFilter(StreamFilter* aStreamFilter) {
     mStreamFilter = aStreamFilter;
   }
 
  private:
--- a/toolkit/components/extensions/webrequest/StreamFilterParent.h
+++ b/toolkit/components/extensions/webrequest/StreamFilterParent.h
@@ -83,23 +83,23 @@ class StreamFilterParent final : public 
     // The channel has been disconnected from the child, and all further data
     // and events will be passed directly to the output listener.
     Disconnected,
   };
 
  protected:
   virtual ~StreamFilterParent();
 
-  virtual IPCResult RecvWrite(Data&& aData) override;
-  virtual IPCResult RecvFlushedData() override;
-  virtual IPCResult RecvSuspend() override;
-  virtual IPCResult RecvResume() override;
-  virtual IPCResult RecvClose() override;
-  virtual IPCResult RecvDisconnect() override;
-  virtual IPCResult RecvDestroy() override;
+  IPCResult RecvWrite(Data&& aData);
+  IPCResult RecvFlushedData();
+  IPCResult RecvSuspend();
+  IPCResult RecvResume();
+  IPCResult RecvClose();
+  IPCResult RecvDisconnect();
+  IPCResult RecvDestroy();
 
   virtual void DeallocPStreamFilterParent() override;
 
  private:
   bool IPCActive() {
     return (mState != State::Closed && mState != State::Disconnecting &&
             mState != State::Disconnected);
   }
--- a/toolkit/components/printingui/ipc/PrintingParent.h
+++ b/toolkit/components/printingui/ipc/PrintingParent.h
@@ -23,27 +23,26 @@ class RemotePrintJobParent;
 }  // namespace layout
 
 namespace embedding {
 
 class PrintingParent final : public PPrintingParent {
  public:
   NS_INLINE_DECL_REFCOUNTING(PrintingParent)
 
-  virtual mozilla::ipc::IPCResult RecvShowProgress(
+  mozilla::ipc::IPCResult RecvShowProgress(
       PBrowserParent* parent, PPrintProgressDialogParent* printProgressDialog,
-      PRemotePrintJobParent* remotePrintJob,
-      const bool& isForPrinting) override;
-  virtual mozilla::ipc::IPCResult RecvShowPrintDialog(
+      PRemotePrintJobParent* remotePrintJob, const bool& isForPrinting);
+  mozilla::ipc::IPCResult RecvShowPrintDialog(
       PPrintSettingsDialogParent* aDialog, PBrowserParent* aParent,
-      const PrintData& aData) override;
+      const PrintData& aData);
 
-  virtual mozilla::ipc::IPCResult RecvSavePrintSettings(
+  mozilla::ipc::IPCResult RecvSavePrintSettings(
       const PrintData& data, const bool& usePrinterNamePrefix,
-      const uint32_t& flags, nsresult* rv) override;
+      const uint32_t& flags, nsresult* rv);
 
   PPrintProgressDialogParent* AllocPPrintProgressDialogParent();
 
   bool DeallocPPrintProgressDialogParent(PPrintProgressDialogParent* aActor);
 
   PPrintSettingsDialogParent* AllocPPrintSettingsDialogParent();
 
   bool DeallocPPrintSettingsDialogParent(PPrintSettingsDialogParent* aActor);
--- a/uriloader/exthandler/ExternalHelperAppChild.h
+++ b/uriloader/exthandler/ExternalHelperAppChild.h
@@ -26,17 +26,17 @@ class ExternalHelperAppChild : public PE
   NS_DECL_NSIREQUESTOBSERVER
 
   ExternalHelperAppChild();
 
   // Give the listener a real nsExternalAppHandler to complete processing on
   // the child.
   void SetHandler(nsExternalAppHandler *handler) { mHandler = handler; }
 
-  virtual mozilla::ipc::IPCResult RecvCancel(const nsresult &aStatus) override;
+  mozilla::ipc::IPCResult RecvCancel(const nsresult &aStatus);
 
  private:
   virtual ~ExternalHelperAppChild();
   MOZ_MUST_USE nsresult DivertToParent(nsIDivertableChannel *divertable,
                                        nsIRequest *request, TabChild *tabChild);
 
   RefPtr<nsExternalAppHandler> mHandler;
   nsresult mStatus;
--- a/uriloader/prefetch/OfflineCacheUpdateChild.h
+++ b/uriloader/prefetch/OfflineCacheUpdateChild.h
@@ -24,24 +24,24 @@ namespace mozilla {
 namespace docshell {
 
 class OfflineCacheUpdateChild : public nsIOfflineCacheUpdate,
                                 public POfflineCacheUpdateChild {
  public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIOFFLINECACHEUPDATE
 
-  virtual mozilla::ipc::IPCResult RecvNotifyStateEvent(
-      const uint32_t& stateEvent, const uint64_t& byteProgress) override;
+  mozilla::ipc::IPCResult RecvNotifyStateEvent(const uint32_t& stateEvent,
+                                               const uint64_t& byteProgress);
 
-  virtual mozilla::ipc::IPCResult RecvAssociateDocuments(
-      const nsCString& cacheGroupId, const nsCString& cacheClientId) override;
+  mozilla::ipc::IPCResult RecvAssociateDocuments(
+      const nsCString& cacheGroupId, const nsCString& cacheClientId);
 
-  virtual mozilla::ipc::IPCResult RecvFinish(const bool& succeeded,
-                                             const bool& isUpgrade) override;
+  mozilla::ipc::IPCResult RecvFinish(const bool& succeeded,
+                                     const bool& isUpgrade);
 
   explicit OfflineCacheUpdateChild(nsPIDOMWindowInner* aWindow);
 
   void SetDocument(dom::Document* aDocument);
 
  private:
   ~OfflineCacheUpdateChild();