Bug 1240411: P5. Clean up GMP headers. r=cpearce
authorJean-Yves Avenard <jyavenard@mozilla.com>
Mon, 18 Jan 2016 14:40:49 +1100
changeset 315673 48d96340d424ee60efd502228c0ef2b80720ef19
parent 315672 8a7c295f149a248ff9459079058a8a97d1f1da9f
child 315674 e1f4f479595d37d14235d5c6b211b2ade132e245
push id5703
push userraliiev@mozilla.com
push dateMon, 07 Mar 2016 14:18:41 +0000
treeherdermozilla-beta@31e373ad5b5f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerscpearce
bugs1240411
milestone46.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 1240411: P5. Clean up GMP headers. r=cpearce Remove redundant virtual keywords
dom/media/gmp-plugin/gmp-test-decryptor.h
dom/media/gmp-plugin/gmp-test-storage.cpp
dom/media/gmp/GMPAudioDecoderChild.h
dom/media/gmp/GMPAudioDecoderParent.h
dom/media/gmp/GMPAudioHost.h
dom/media/gmp/GMPChild.h
dom/media/gmp/GMPContentChild.h
dom/media/gmp/GMPContentParent.h
dom/media/gmp/GMPDecryptorChild.h
dom/media/gmp/GMPDecryptorParent.h
dom/media/gmp/GMPEncryptedBufferDataImpl.h
dom/media/gmp/GMPLoader.cpp
dom/media/gmp/GMPParent.h
dom/media/gmp/GMPPlatform.h
dom/media/gmp/GMPProcessChild.h
dom/media/gmp/GMPProcessParent.h
dom/media/gmp/GMPService.cpp
dom/media/gmp/GMPServiceChild.cpp
dom/media/gmp/GMPServiceChild.h
dom/media/gmp/GMPServiceParent.cpp
dom/media/gmp/GMPServiceParent.h
dom/media/gmp/GMPStorageChild.cpp
dom/media/gmp/GMPStorageChild.h
dom/media/gmp/GMPStorageParent.h
dom/media/gmp/GMPTimerChild.h
dom/media/gmp/GMPTimerParent.h
dom/media/gmp/GMPVideoDecoderChild.h
dom/media/gmp/GMPVideoDecoderParent.h
dom/media/gmp/GMPVideoEncodedFrameImpl.h
dom/media/gmp/GMPVideoEncoderChild.h
dom/media/gmp/GMPVideoEncoderParent.h
dom/media/gmp/GMPVideoHost.h
dom/media/gmp/GMPVideoPlaneImpl.h
dom/media/gmp/GMPVideoi420FrameImpl.h
--- a/dom/media/gmp-plugin/gmp-test-decryptor.h
+++ b/dom/media/gmp-plugin/gmp-test-decryptor.h
@@ -11,66 +11,66 @@
 #include <string>
 #include "mozilla/Attributes.h"
 
 class FakeDecryptor : public GMPDecryptor {
 public:
 
   explicit FakeDecryptor(GMPDecryptorHost* aHost);
 
-  virtual void Init(GMPDecryptorCallback* aCallback) override {
+  void Init(GMPDecryptorCallback* aCallback) override {
     mCallback = aCallback;
   }
 
-  virtual void CreateSession(uint32_t aCreateSessionToken,
-                             uint32_t aPromiseId,
-                             const char* aInitDataType,
-                             uint32_t aInitDataTypeSize,
-                             const uint8_t* aInitData,
-                             uint32_t aInitDataSize,
-                             GMPSessionType aSessionType) override
+  void CreateSession(uint32_t aCreateSessionToken,
+                     uint32_t aPromiseId,
+                     const char* aInitDataType,
+                     uint32_t aInitDataTypeSize,
+                     const uint8_t* aInitData,
+                     uint32_t aInitDataSize,
+                     GMPSessionType aSessionType) override
   {
   }
 
-  virtual void LoadSession(uint32_t aPromiseId,
-                           const char* aSessionId,
-                           uint32_t aSessionIdLength) override
+  void LoadSession(uint32_t aPromiseId,
+                   const char* aSessionId,
+                   uint32_t aSessionIdLength) override
   {
   }
 
-  virtual void UpdateSession(uint32_t aPromiseId,
-                             const char* aSessionId,
-                             uint32_t aSessionIdLength,
-                             const uint8_t* aResponse,
-                             uint32_t aResponseSize) override;
+  void UpdateSession(uint32_t aPromiseId,
+                     const char* aSessionId,
+                     uint32_t aSessionIdLength,
+                     const uint8_t* aResponse,
+                     uint32_t aResponseSize) override;
 
-  virtual void CloseSession(uint32_t aPromiseId,
-                            const char* aSessionId,
-                            uint32_t aSessionIdLength) override
+  void CloseSession(uint32_t aPromiseId,
+                    const char* aSessionId,
+                    uint32_t aSessionIdLength) override
   {
   }
 
-  virtual void RemoveSession(uint32_t aPromiseId,
-                             const char* aSessionId,
-                             uint32_t aSessionIdLength) override
+  void RemoveSession(uint32_t aPromiseId,
+                     const char* aSessionId,
+                     uint32_t aSessionIdLength) override
   {
   }
 
-  virtual void SetServerCertificate(uint32_t aPromiseId,
-                                    const uint8_t* aServerCert,
-                                    uint32_t aServerCertSize) override
+  void SetServerCertificate(uint32_t aPromiseId,
+                            const uint8_t* aServerCert,
+                            uint32_t aServerCertSize) override
   {
   }
 
-  virtual void Decrypt(GMPBuffer* aBuffer,
-                       GMPEncryptedBufferMetadata* aMetadata) override
+  void Decrypt(GMPBuffer* aBuffer,
+               GMPEncryptedBufferMetadata* aMetadata) override
   {
   }
 
-  virtual void DecryptingComplete() override;
+  void DecryptingComplete() override;
 
   static void Message(const std::string& aMessage);
 
   void ProcessRecordNames(GMPRecordIterator* aRecordIterator,
                           GMPErr aStatus);
 
 private:
 
@@ -84,14 +84,14 @@ private:
 };
 
 class TestAsyncShutdown : public GMPAsyncShutdown {
 public:
   explicit TestAsyncShutdown(GMPAsyncShutdownHost* aHost)
     : mHost(aHost)
   {
   }
-  virtual void BeginShutdown() override;
+  void BeginShutdown() override;
 private:
   GMPAsyncShutdownHost* mHost;
 };
 
 #endif
--- a/dom/media/gmp-plugin/gmp-test-storage.cpp
+++ b/dom/media/gmp-plugin/gmp-test-storage.cpp
@@ -18,30 +18,30 @@ public:
               uint32_t aDataSize) {
     mRecord = aRecord;
     mOnSuccess = aOnSuccess;
     mOnFailure = aOnFailure;
     mData.insert(mData.end(), aData, aData + aDataSize);
     return mRecord->Open();
   }
 
-  virtual void OpenComplete(GMPErr aStatus) override {
+  void OpenComplete(GMPErr aStatus) override {
     if (GMP_SUCCEEDED(aStatus)) {
       mRecord->Write(mData.size() ? &mData.front() : nullptr, mData.size());
     } else {
       GMPRunOnMainThread(mOnFailure);
       mOnSuccess->Destroy();
     }
   }
 
-  virtual void ReadComplete(GMPErr aStatus,
-                            const uint8_t* aData,
-                            uint32_t aDataSize) override {}
+  void ReadComplete(GMPErr aStatus,
+                    const uint8_t* aData,
+                    uint32_t aDataSize) override {}
 
-  virtual void WriteComplete(GMPErr aStatus) override {
+  void WriteComplete(GMPErr aStatus) override {
     // Note: Call Close() before running continuation, in case the
     // continuation tries to open the same record; if we call Close()
     // after running the continuation, the Close() call will arrive
     // just after the Open() call succeeds, immediately closing the
     // record we just opened.
     mRecord->Close();
     if (GMP_SUCCEEDED(aStatus)) {
       GMPRunOnMainThread(mOnSuccess);
@@ -98,39 +98,39 @@ class ReadRecordClient : public GMPRecor
 public:
   GMPErr Init(GMPRecord* aRecord,
               ReadContinuation* aContinuation) {
     mRecord = aRecord;
     mContinuation = aContinuation;
     return mRecord->Open();
   }
 
-  virtual void OpenComplete(GMPErr aStatus) override {
+  void OpenComplete(GMPErr aStatus) override {
     auto err = mRecord->Read();
     if (GMP_FAILED(err)) {
       mContinuation->ReadComplete(err, "");
       delete this;
     }
   }
 
-  virtual void ReadComplete(GMPErr aStatus,
-                            const uint8_t* aData,
-                            uint32_t aDataSize) override {
+  void ReadComplete(GMPErr aStatus,
+                    const uint8_t* aData,
+                    uint32_t aDataSize) override {
     // Note: Call Close() before running continuation, in case the
     // continuation tries to open the same record; if we call Close()
     // after running the continuation, the Close() call will arrive
     // just after the Open() call succeeds, immediately closing the
     // record we just opened.
     mRecord->Close();
     std::string data((const char*)aData, aDataSize);
     mContinuation->ReadComplete(GMPNoErr, data);
     delete this;
   }
 
-  virtual void WriteComplete(GMPErr aStatus) override {
+  void WriteComplete(GMPErr aStatus) override {
   }
 
 private:
   GMPRecord* mRecord;
   ReadContinuation* mContinuation;
 };
 
 GMPErr
@@ -176,27 +176,27 @@ public:
    * delete them when done.
    */
   static void Open(const std::string& aRecordName,
             OpenContinuation* aContinuation) {
     MOZ_ASSERT(aContinuation);
     (new OpenRecordClient(aContinuation))->Do(aRecordName);
   }
 
-  virtual void OpenComplete(GMPErr aStatus) override {
+  void OpenComplete(GMPErr aStatus) override {
     Done(aStatus);
   }
 
-  virtual void ReadComplete(GMPErr aStatus,
-                            const uint8_t* aData,
-                            uint32_t aDataSize) override {
+  void ReadComplete(GMPErr aStatus,
+                    const uint8_t* aData,
+                    uint32_t aDataSize) override {
     MOZ_CRASH("Should not reach here.");
   }
 
-  virtual void WriteComplete(GMPErr aStatus) override {
+  void WriteComplete(GMPErr aStatus) override {
     MOZ_CRASH("Should not reach here.");
   }
 
 private:
   explicit OpenRecordClient(OpenContinuation* aContinuation)
     : mRecord(nullptr), mContinuation(aContinuation) {}
 
   void Do(const std::string& aName) {
--- a/dom/media/gmp/GMPAudioDecoderChild.h
+++ b/dom/media/gmp/GMPAudioDecoderChild.h
@@ -21,29 +21,29 @@ class GMPAudioDecoderChild : public PGMP
 public:
   explicit GMPAudioDecoderChild(GMPContentChild* aPlugin);
   virtual ~GMPAudioDecoderChild();
 
   void Init(GMPAudioDecoder* aDecoder);
   GMPAudioHostImpl& Host();
 
   // GMPAudioDecoderCallback
-  virtual void Decoded(GMPAudioSamples* aEncodedSamples) override;
-  virtual void InputDataExhausted() override;
-  virtual void DrainComplete() override;
-  virtual void ResetComplete() override;
-  virtual void Error(GMPErr aError) override;
+  void Decoded(GMPAudioSamples* aEncodedSamples) override;
+  void InputDataExhausted() override;
+  void DrainComplete() override;
+  void ResetComplete() override;
+  void Error(GMPErr aError) override;
 
 private:
   // PGMPAudioDecoderChild
-  virtual bool RecvInitDecode(const GMPAudioCodecData& codecSettings) override;
-  virtual bool RecvDecode(const GMPAudioEncodedSampleData& input) override;
-  virtual bool RecvReset() override;
-  virtual bool RecvDrain() override;
-  virtual bool RecvDecodingComplete() override;
+  bool RecvInitDecode(const GMPAudioCodecData& codecSettings) override;
+  bool RecvDecode(const GMPAudioEncodedSampleData& input) override;
+  bool RecvReset() override;
+  bool RecvDrain() override;
+  bool RecvDecodingComplete() override;
 
   GMPContentChild* mPlugin;
   GMPAudioDecoder* mAudioDecoder;
   GMPAudioHostImpl mAudioHost;
 };
 
 } // namespace gmp
 } // namespace mozilla
--- a/dom/media/gmp/GMPAudioDecoderParent.h
+++ b/dom/media/gmp/GMPAudioDecoderParent.h
@@ -24,39 +24,39 @@ class GMPAudioDecoderParent final : publ
 public:
   NS_INLINE_DECL_REFCOUNTING(GMPAudioDecoderParent)
 
   explicit GMPAudioDecoderParent(GMPContentParent *aPlugin);
 
   nsresult Shutdown();
 
   // GMPAudioDecoderProxy
-  virtual nsresult InitDecode(GMPAudioCodecType aCodecType,
-                              uint32_t aChannelCount,
-                              uint32_t aBitsPerChannel,
-                              uint32_t aSamplesPerSecond,
-                              nsTArray<uint8_t>& aExtraData,
-                              GMPAudioDecoderCallbackProxy* aCallback) override;
-  virtual nsresult Decode(GMPAudioSamplesImpl& aInput) override;
-  virtual nsresult Reset() override;
-  virtual nsresult Drain() override;
-  virtual nsresult Close() override;
+  nsresult InitDecode(GMPAudioCodecType aCodecType,
+                      uint32_t aChannelCount,
+                      uint32_t aBitsPerChannel,
+                      uint32_t aSamplesPerSecond,
+                      nsTArray<uint8_t>& aExtraData,
+                      GMPAudioDecoderCallbackProxy* aCallback) override;
+  nsresult Decode(GMPAudioSamplesImpl& aInput) override;
+  nsresult Reset() override;
+  nsresult Drain() override;
+  nsresult Close() override;
 
 private:
   ~GMPAudioDecoderParent();
 
   // PGMPAudioDecoderParent
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
-  virtual bool RecvDecoded(const GMPAudioDecodedSampleData& aDecoded) override;
-  virtual bool RecvInputDataExhausted() override;
-  virtual bool RecvDrainComplete() override;
-  virtual bool RecvResetComplete() override;
-  virtual bool RecvError(const GMPErr& aError) override;
-  virtual bool RecvShutdown() override;
-  virtual bool Recv__delete__() override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+  bool RecvDecoded(const GMPAudioDecodedSampleData& aDecoded) override;
+  bool RecvInputDataExhausted() override;
+  bool RecvDrainComplete() override;
+  bool RecvResetComplete() override;
+  bool RecvError(const GMPErr& aError) override;
+  bool RecvShutdown() override;
+  bool Recv__delete__() override;
 
   void UnblockResetAndDrain();
 
   bool mIsOpen;
   bool mShuttingDown;
   bool mActorDestroyed;
   bool mIsAwaitingResetComplete;
   bool mIsAwaitingDrainComplete;
--- a/dom/media/gmp/GMPAudioHost.h
+++ b/dom/media/gmp/GMPAudioHost.h
@@ -24,48 +24,48 @@ class GMPAudioSamplesImpl : public GMPAu
 public:
   explicit GMPAudioSamplesImpl(GMPAudioFormat aFormat);
   explicit GMPAudioSamplesImpl(const GMPAudioEncodedSampleData& aData);
   GMPAudioSamplesImpl(MediaRawData* aSample,
                       uint32_t aChannels,
                       uint32_t aRate);
   virtual ~GMPAudioSamplesImpl();
 
-  virtual GMPAudioFormat GetFormat() override;
-  virtual void Destroy() override;
-  virtual GMPErr SetBufferSize(uint32_t aSize) override;
-  virtual uint32_t Size() override;
-  virtual void SetTimeStamp(uint64_t aTimeStamp) override;
-  virtual uint64_t TimeStamp() override;
-  virtual const uint8_t* Buffer() const override;
-  virtual uint8_t* Buffer() override;
-  virtual const GMPEncryptedBufferMetadata* GetDecryptionData() const override;
+  GMPAudioFormat GetFormat() override;
+  void Destroy() override;
+  GMPErr SetBufferSize(uint32_t aSize) override;
+  uint32_t Size() override;
+  void SetTimeStamp(uint64_t aTimeStamp) override;
+  uint64_t TimeStamp() override;
+  const uint8_t* Buffer() const override;
+  uint8_t* Buffer() override;
+  const GMPEncryptedBufferMetadata* GetDecryptionData() const override;
 
   void InitCrypto(const CryptoSample& aCrypto);
 
   void RelinquishData(GMPAudioEncodedSampleData& aData);
 
-  virtual uint32_t Channels() const override;
-  virtual void SetChannels(uint32_t aChannels) override;
-  virtual uint32_t Rate() const override;
-  virtual void SetRate(uint32_t aRate) override;
+  uint32_t Channels() const override;
+  void SetChannels(uint32_t aChannels) override;
+  uint32_t Rate() const override;
+  void SetRate(uint32_t aRate) override;
 
 private:
   GMPAudioFormat mFormat;
   nsTArray<uint8_t> mBuffer;
   int64_t mTimeStamp;
   nsAutoPtr<GMPEncryptedBufferDataImpl> mCrypto;
   uint32_t mChannels;
   uint32_t mRate;
 };
 
 class GMPAudioHostImpl : public GMPAudioHost
 {
 public:
-  virtual GMPErr CreateSamples(GMPAudioFormat aFormat,
-                               GMPAudioSamples** aSamples) override;
+  GMPErr CreateSamples(GMPAudioFormat aFormat,
+                       GMPAudioSamples** aSamples) override;
 private:
 };
 
 } // namespace gmp
 } // namespace mozilla
 
 #endif // GMPAudioHost_h_
--- a/dom/media/gmp/GMPChild.h
+++ b/dom/media/gmp/GMPChild.h
@@ -50,38 +50,38 @@ public:
 private:
   friend class GMPContentChild;
 
   bool PreLoadPluginVoucher();
   void PreLoadSandboxVoucher();
 
   bool GetUTF8LibPath(nsACString& aOutLibPath);
 
-  virtual bool RecvSetNodeId(const nsCString& aNodeId) override;
-  virtual bool AnswerStartPlugin() override;
+  bool RecvSetNodeId(const nsCString& aNodeId) override;
+  bool AnswerStartPlugin() override;
 
-  virtual PCrashReporterChild* AllocPCrashReporterChild(const NativeThreadId& aThread) override;
-  virtual bool DeallocPCrashReporterChild(PCrashReporterChild*) override;
+  PCrashReporterChild* AllocPCrashReporterChild(const NativeThreadId& aThread) override;
+  bool DeallocPCrashReporterChild(PCrashReporterChild*) override;
 
-  virtual PGMPTimerChild* AllocPGMPTimerChild() override;
-  virtual bool DeallocPGMPTimerChild(PGMPTimerChild* aActor) override;
+  PGMPTimerChild* AllocPGMPTimerChild() override;
+  bool DeallocPGMPTimerChild(PGMPTimerChild* aActor) override;
 
-  virtual PGMPStorageChild* AllocPGMPStorageChild() override;
-  virtual bool DeallocPGMPStorageChild(PGMPStorageChild* aActor) override;
+  PGMPStorageChild* AllocPGMPStorageChild() override;
+  bool DeallocPGMPStorageChild(PGMPStorageChild* aActor) override;
 
-  virtual PGMPContentChild* AllocPGMPContentChild(Transport* aTransport,
-                                                  ProcessId aOtherPid) override;
+  PGMPContentChild* AllocPGMPContentChild(Transport* aTransport,
+                                          ProcessId aOtherPid) override;
   void GMPContentChildActorDestroy(GMPContentChild* aGMPContentChild);
 
-  virtual bool RecvCrashPluginNow() override;
-  virtual bool RecvBeginAsyncShutdown() override;
-  virtual bool RecvCloseActive() override;
+  bool RecvCrashPluginNow() override;
+  bool RecvBeginAsyncShutdown() override;
+  bool RecvCloseActive() override;
 
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
-  virtual void ProcessingError(Result aCode, const char* aReason) override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+  void ProcessingError(Result aCode, const char* aReason) override;
 
   GMPErr GetAPI(const char* aAPIName, void* aHostAPI, void** aPluginAPI);
 
   nsTArray<UniquePtr<GMPContentChild>> mGMPContentChildren;
 
   GMPAsyncShutdown* mAsyncShutdown;
   RefPtr<GMPTimerChild> mTimerChild;
   RefPtr<GMPStorageChild> mStorage;
--- a/dom/media/gmp/GMPContentChild.h
+++ b/dom/media/gmp/GMPContentChild.h
@@ -18,38 +18,38 @@ class GMPContentChild : public PGMPConte
                       , public GMPSharedMem
 {
 public:
   explicit GMPContentChild(GMPChild* aChild);
   virtual ~GMPContentChild();
 
   MessageLoop* GMPMessageLoop();
 
-  virtual bool RecvPGMPAudioDecoderConstructor(PGMPAudioDecoderChild* aActor) override;
-  virtual bool RecvPGMPDecryptorConstructor(PGMPDecryptorChild* aActor) override;
-  virtual bool RecvPGMPVideoDecoderConstructor(PGMPVideoDecoderChild* aActor) override;
-  virtual bool RecvPGMPVideoEncoderConstructor(PGMPVideoEncoderChild* aActor) override;
+  bool RecvPGMPAudioDecoderConstructor(PGMPAudioDecoderChild* aActor) override;
+  bool RecvPGMPDecryptorConstructor(PGMPDecryptorChild* aActor) override;
+  bool RecvPGMPVideoDecoderConstructor(PGMPVideoDecoderChild* aActor) override;
+  bool RecvPGMPVideoEncoderConstructor(PGMPVideoEncoderChild* aActor) override;
 
-  virtual PGMPAudioDecoderChild* AllocPGMPAudioDecoderChild() override;
-  virtual bool DeallocPGMPAudioDecoderChild(PGMPAudioDecoderChild* aActor) override;
+  PGMPAudioDecoderChild* AllocPGMPAudioDecoderChild() override;
+  bool DeallocPGMPAudioDecoderChild(PGMPAudioDecoderChild* aActor) override;
 
-  virtual PGMPDecryptorChild* AllocPGMPDecryptorChild() override;
-  virtual bool DeallocPGMPDecryptorChild(PGMPDecryptorChild* aActor) override;
+  PGMPDecryptorChild* AllocPGMPDecryptorChild() override;
+  bool DeallocPGMPDecryptorChild(PGMPDecryptorChild* aActor) override;
 
-  virtual PGMPVideoDecoderChild* AllocPGMPVideoDecoderChild() override;
-  virtual bool DeallocPGMPVideoDecoderChild(PGMPVideoDecoderChild* aActor) override;
+  PGMPVideoDecoderChild* AllocPGMPVideoDecoderChild() override;
+  bool DeallocPGMPVideoDecoderChild(PGMPVideoDecoderChild* aActor) override;
 
-  virtual PGMPVideoEncoderChild* AllocPGMPVideoEncoderChild() override;
-  virtual bool DeallocPGMPVideoEncoderChild(PGMPVideoEncoderChild* aActor) override;
+  PGMPVideoEncoderChild* AllocPGMPVideoEncoderChild() override;
+  bool DeallocPGMPVideoEncoderChild(PGMPVideoEncoderChild* aActor) override;
 
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
-  virtual void ProcessingError(Result aCode, const char* aReason) override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+  void ProcessingError(Result aCode, const char* aReason) override;
 
   // GMPSharedMem
-  virtual void CheckThread() override;
+  void CheckThread() override;
 
   void CloseActive();
   bool IsUsed();
 
   GMPChild* mGMPChild;
 };
 
 } // namespace gmp
--- a/dom/media/gmp/GMPContentParent.h
+++ b/dom/media/gmp/GMPContentParent.h
@@ -37,17 +37,17 @@ public:
   void DecryptorDestroyed(GMPDecryptorParent* aSession);
 
   nsresult GetGMPAudioDecoder(GMPAudioDecoderParent** aGMPAD);
   void AudioDecoderDestroyed(GMPAudioDecoderParent* aDecoder);
 
   nsIThread* GMPThread();
 
   // GMPSharedMem
-  virtual void CheckThread() override;
+  void CheckThread() override;
 
   void SetDisplayName(const nsCString& aDisplayName)
   {
     mDisplayName = aDisplayName;
   }
   const nsCString& GetDisplayName()
   {
     return mDisplayName;
@@ -59,29 +59,29 @@ public:
   uint32_t GetPluginId() const
   {
     return mPluginId;
   }
 
 private:
   ~GMPContentParent();
 
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  virtual PGMPVideoDecoderParent* AllocPGMPVideoDecoderParent() override;
-  virtual bool DeallocPGMPVideoDecoderParent(PGMPVideoDecoderParent* aActor) override;
+  PGMPVideoDecoderParent* AllocPGMPVideoDecoderParent() override;
+  bool DeallocPGMPVideoDecoderParent(PGMPVideoDecoderParent* aActor) override;
 
-  virtual PGMPVideoEncoderParent* AllocPGMPVideoEncoderParent() override;
-  virtual bool DeallocPGMPVideoEncoderParent(PGMPVideoEncoderParent* aActor) override;
+  PGMPVideoEncoderParent* AllocPGMPVideoEncoderParent() override;
+  bool DeallocPGMPVideoEncoderParent(PGMPVideoEncoderParent* aActor) override;
 
-  virtual PGMPDecryptorParent* AllocPGMPDecryptorParent() override;
-  virtual bool DeallocPGMPDecryptorParent(PGMPDecryptorParent* aActor) override;
+  PGMPDecryptorParent* AllocPGMPDecryptorParent() override;
+  bool DeallocPGMPDecryptorParent(PGMPDecryptorParent* aActor) override;
 
-  virtual PGMPAudioDecoderParent* AllocPGMPAudioDecoderParent() override;
-  virtual bool DeallocPGMPAudioDecoderParent(PGMPAudioDecoderParent* aActor) override;
+  PGMPAudioDecoderParent* AllocPGMPAudioDecoderParent() override;
+  bool DeallocPGMPAudioDecoderParent(PGMPAudioDecoderParent* aActor) override;
 
   void CloseIfUnused();
   // Needed because NS_NewRunnableMethod tried to use the class that the method
   // lives on to store the receiver, but PGMPContentParent isn't refcounted.
   void Close()
   {
     PGMPContentParent::Close();
   }
--- a/dom/media/gmp/GMPDecryptorChild.h
+++ b/dom/media/gmp/GMPDecryptorChild.h
@@ -26,98 +26,98 @@ public:
 
   explicit GMPDecryptorChild(GMPContentChild* aPlugin,
                              const nsTArray<uint8_t>& aPluginVoucher,
                              const nsTArray<uint8_t>& aSandboxVoucher);
 
   void Init(GMPDecryptor* aSession);
 
   // GMPDecryptorCallback
-  virtual void SetSessionId(uint32_t aCreateSessionToken,
-                            const char* aSessionId,
-                            uint32_t aSessionIdLength) override;
-  virtual void ResolveLoadSessionPromise(uint32_t aPromiseId,
-                                         bool aSuccess) override;
-  virtual void ResolvePromise(uint32_t aPromiseId) override;
+  void SetSessionId(uint32_t aCreateSessionToken,
+                    const char* aSessionId,
+                    uint32_t aSessionIdLength) override;
+  void ResolveLoadSessionPromise(uint32_t aPromiseId,
+                                 bool aSuccess) override;
+  void ResolvePromise(uint32_t aPromiseId) override;
 
-  virtual void RejectPromise(uint32_t aPromiseId,
-                             GMPDOMException aException,
-                             const char* aMessage,
-                             uint32_t aMessageLength) override;
+  void RejectPromise(uint32_t aPromiseId,
+                     GMPDOMException aException,
+                     const char* aMessage,
+                     uint32_t aMessageLength) override;
 
-  virtual void SessionMessage(const char* aSessionId,
-                              uint32_t aSessionIdLength,
-                              GMPSessionMessageType aMessageType,
-                              const uint8_t* aMessage,
-                              uint32_t aMessageLength) override;
+  void SessionMessage(const char* aSessionId,
+                      uint32_t aSessionIdLength,
+                      GMPSessionMessageType aMessageType,
+                      const uint8_t* aMessage,
+                      uint32_t aMessageLength) override;
 
-  virtual void ExpirationChange(const char* aSessionId,
-                                 uint32_t aSessionIdLength,
-                                 GMPTimestamp aExpiryTime) override;
+  void ExpirationChange(const char* aSessionId,
+                        uint32_t aSessionIdLength,
+                        GMPTimestamp aExpiryTime) override;
 
-   virtual void SessionClosed(const char* aSessionId,
-                             uint32_t aSessionIdLength) override;
+  void SessionClosed(const char* aSessionId,
+                     uint32_t aSessionIdLength) override;
 
-  virtual void SessionError(const char* aSessionId,
-                            uint32_t aSessionIdLength,
-                            GMPDOMException aException,
-                            uint32_t aSystemCode,
-                            const char* aMessage,
-                            uint32_t aMessageLength) override;
+  void SessionError(const char* aSessionId,
+                    uint32_t aSessionIdLength,
+                    GMPDOMException aException,
+                    uint32_t aSystemCode,
+                    const char* aMessage,
+                    uint32_t aMessageLength) override;
 
-  virtual void KeyStatusChanged(const char* aSessionId,
-                                uint32_t aSessionIdLength,
-                                const uint8_t* aKeyId,
-                                uint32_t aKeyIdLength,
-                                GMPMediaKeyStatus aStatus) override;
+  void KeyStatusChanged(const char* aSessionId,
+                        uint32_t aSessionIdLength,
+                        const uint8_t* aKeyId,
+                        uint32_t aKeyIdLength,
+                        GMPMediaKeyStatus aStatus) override;
 
-  virtual void SetCapabilities(uint64_t aCaps) override;
+  void SetCapabilities(uint64_t aCaps) override;
 
-  virtual void Decrypted(GMPBuffer* aBuffer, GMPErr aResult) override;
+  void Decrypted(GMPBuffer* aBuffer, GMPErr aResult) override;
 
   // GMPDecryptorHost
-  virtual void GetSandboxVoucher(const uint8_t** aVoucher,
-                                 uint32_t* aVoucherLength) override;
+  void GetSandboxVoucher(const uint8_t** aVoucher,
+                         uint32_t* aVoucherLength) override;
 
-  virtual void GetPluginVoucher(const uint8_t** aVoucher,
-                                uint32_t* aVoucherLength) override;
+  void GetPluginVoucher(const uint8_t** aVoucher,
+                        uint32_t* aVoucherLength) override;
 private:
   ~GMPDecryptorChild();
 
   // GMPDecryptorChild
-  virtual bool RecvInit() override;
+  bool RecvInit() override;
 
-  virtual bool RecvCreateSession(const uint32_t& aCreateSessionToken,
-                                 const uint32_t& aPromiseId,
-                                 const nsCString& aInitDataType,
-                                 InfallibleTArray<uint8_t>&& aInitData,
-                                 const GMPSessionType& aSessionType) override;
+  bool RecvCreateSession(const uint32_t& aCreateSessionToken,
+                         const uint32_t& aPromiseId,
+                         const nsCString& aInitDataType,
+                         InfallibleTArray<uint8_t>&& aInitData,
+                         const GMPSessionType& aSessionType) override;
 
-  virtual bool RecvLoadSession(const uint32_t& aPromiseId,
-                               const nsCString& aSessionId) override;
+  bool RecvLoadSession(const uint32_t& aPromiseId,
+                       const nsCString& aSessionId) override;
 
-  virtual bool RecvUpdateSession(const uint32_t& aPromiseId,
-                                 const nsCString& aSessionId,
-                                 InfallibleTArray<uint8_t>&& aResponse) override;
+  bool RecvUpdateSession(const uint32_t& aPromiseId,
+                         const nsCString& aSessionId,
+                         InfallibleTArray<uint8_t>&& aResponse) override;
 
-  virtual bool RecvCloseSession(const uint32_t& aPromiseId,
-                                const nsCString& aSessionId) override;
+  bool RecvCloseSession(const uint32_t& aPromiseId,
+                        const nsCString& aSessionId) override;
 
-  virtual bool RecvRemoveSession(const uint32_t& aPromiseId,
-                                 const nsCString& aSessionId) override;
+  bool RecvRemoveSession(const uint32_t& aPromiseId,
+                         const nsCString& aSessionId) override;
 
-  virtual bool RecvDecrypt(const uint32_t& aId,
-                           InfallibleTArray<uint8_t>&& aBuffer,
-                           const GMPDecryptionData& aMetadata) override;
+  bool RecvDecrypt(const uint32_t& aId,
+                   InfallibleTArray<uint8_t>&& aBuffer,
+                   const GMPDecryptionData& aMetadata) override;
 
   // Resolve/reject promise on completion.
-  virtual bool RecvSetServerCertificate(const uint32_t& aPromiseId,
-                                        InfallibleTArray<uint8_t>&& aServerCert) override;
+  bool RecvSetServerCertificate(const uint32_t& aPromiseId,
+                                InfallibleTArray<uint8_t>&& aServerCert) override;
 
-  virtual bool RecvDecryptingComplete() override;
+  bool RecvDecryptingComplete() override;
 
   template <typename MethodType, typename... ParamType>
   void CallMethod(MethodType, ParamType&&...);
 
   template<typename MethodType, typename... ParamType>
   void CallOnGMPThread(MethodType, ParamType&&...);
 
   // GMP's GMPDecryptor implementation.
--- a/dom/media/gmp/GMPDecryptorParent.h
+++ b/dom/media/gmp/GMPDecryptorParent.h
@@ -24,95 +24,95 @@ class GMPDecryptorParent final : public 
 {
 public:
   NS_INLINE_DECL_REFCOUNTING(GMPDecryptorParent)
 
   explicit GMPDecryptorParent(GMPContentParent *aPlugin);
 
   // GMPDecryptorProxy
 
-  virtual uint32_t GetPluginId() const override { return mPluginId; }
+  uint32_t GetPluginId() const override { return mPluginId; }
 
-  virtual nsresult Init(GMPDecryptorProxyCallback* aCallback) override;
+  nsresult Init(GMPDecryptorProxyCallback* aCallback) override;
 
-  virtual void CreateSession(uint32_t aCreateSessionToken,
-                             uint32_t aPromiseId,
-                             const nsCString& aInitDataType,
-                             const nsTArray<uint8_t>& aInitData,
-                             GMPSessionType aSessionType) override;
+  void CreateSession(uint32_t aCreateSessionToken,
+                     uint32_t aPromiseId,
+                     const nsCString& aInitDataType,
+                     const nsTArray<uint8_t>& aInitData,
+                     GMPSessionType aSessionType) override;
 
-  virtual void LoadSession(uint32_t aPromiseId,
-                           const nsCString& aSessionId) override;
+  void LoadSession(uint32_t aPromiseId,
+                   const nsCString& aSessionId) override;
 
-  virtual void UpdateSession(uint32_t aPromiseId,
-                             const nsCString& aSessionId,
-                             const nsTArray<uint8_t>& aResponse) override;
+  void UpdateSession(uint32_t aPromiseId,
+                     const nsCString& aSessionId,
+                     const nsTArray<uint8_t>& aResponse) override;
 
-  virtual void CloseSession(uint32_t aPromiseId,
-                            const nsCString& aSessionId) override;
+  void CloseSession(uint32_t aPromiseId,
+                    const nsCString& aSessionId) override;
 
-  virtual void RemoveSession(uint32_t aPromiseId,
-                             const nsCString& aSessionId) override;
+  void RemoveSession(uint32_t aPromiseId,
+                     const nsCString& aSessionId) override;
 
-  virtual void SetServerCertificate(uint32_t aPromiseId,
-                                    const nsTArray<uint8_t>& aServerCert) override;
+  void SetServerCertificate(uint32_t aPromiseId,
+                            const nsTArray<uint8_t>& aServerCert) override;
 
-  virtual void Decrypt(uint32_t aId,
-                       const CryptoSample& aCrypto,
-                       const nsTArray<uint8_t>& aBuffer) override;
+  void Decrypt(uint32_t aId,
+               const CryptoSample& aCrypto,
+               const nsTArray<uint8_t>& aBuffer) override;
 
-  virtual void Close() override;
+  void Close() override;
 
   void Shutdown();
 
 private:
   ~GMPDecryptorParent();
 
   // PGMPDecryptorParent
 
-  virtual bool RecvSetSessionId(const uint32_t& aCreateSessionToken,
-                                const nsCString& aSessionId) override;
+  bool RecvSetSessionId(const uint32_t& aCreateSessionToken,
+                        const nsCString& aSessionId) override;
 
-  virtual bool RecvResolveLoadSessionPromise(const uint32_t& aPromiseId,
-                                             const bool& aSuccess) override;
+  bool RecvResolveLoadSessionPromise(const uint32_t& aPromiseId,
+                                     const bool& aSuccess) override;
 
-  virtual bool RecvResolvePromise(const uint32_t& aPromiseId) override;
+  bool RecvResolvePromise(const uint32_t& aPromiseId) override;
 
-  virtual bool RecvRejectPromise(const uint32_t& aPromiseId,
-                                 const GMPDOMException& aException,
-                                 const nsCString& aMessage) override;
+  bool RecvRejectPromise(const uint32_t& aPromiseId,
+                         const GMPDOMException& aException,
+                         const nsCString& aMessage) override;
 
-  virtual bool RecvSessionMessage(const nsCString& aSessionId,
-                                  const GMPSessionMessageType& aMessageType,
-                                  nsTArray<uint8_t>&& aMessage) override;
+  bool RecvSessionMessage(const nsCString& aSessionId,
+                          const GMPSessionMessageType& aMessageType,
+                          nsTArray<uint8_t>&& aMessage) override;
 
-  virtual bool RecvExpirationChange(const nsCString& aSessionId,
-                                    const double& aExpiryTime) override;
+  bool RecvExpirationChange(const nsCString& aSessionId,
+                            const double& aExpiryTime) override;
 
-  virtual bool RecvSessionClosed(const nsCString& aSessionId) override;
+  bool RecvSessionClosed(const nsCString& aSessionId) override;
 
-  virtual bool RecvSessionError(const nsCString& aSessionId,
-                                const GMPDOMException& aException,
-                                const uint32_t& aSystemCode,
-                                const nsCString& aMessage) override;
+  bool RecvSessionError(const nsCString& aSessionId,
+                        const GMPDOMException& aException,
+                        const uint32_t& aSystemCode,
+                        const nsCString& aMessage) override;
 
-  virtual bool RecvKeyStatusChanged(const nsCString& aSessionId,
-                                    InfallibleTArray<uint8_t>&& aKeyId,
-                                    const GMPMediaKeyStatus& aStatus) override;
+  bool RecvKeyStatusChanged(const nsCString& aSessionId,
+                            InfallibleTArray<uint8_t>&& aKeyId,
+                            const GMPMediaKeyStatus& aStatus) override;
 
-  virtual bool RecvDecrypted(const uint32_t& aId,
-                             const GMPErr& aErr,
-                             InfallibleTArray<uint8_t>&& aBuffer) override;
+  bool RecvDecrypted(const uint32_t& aId,
+                     const GMPErr& aErr,
+                     InfallibleTArray<uint8_t>&& aBuffer) override;
 
-  virtual bool RecvSetCaps(const uint64_t& aCaps) override;
+  bool RecvSetCaps(const uint64_t& aCaps) override;
 
-  virtual bool RecvShutdown() override;
+  bool RecvShutdown() override;
 
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
-  virtual bool Recv__delete__() override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+  bool Recv__delete__() override;
 
   bool mIsOpen;
   bool mShuttingDown;
   bool mActorDestroyed;
   RefPtr<GMPContentParent> mPlugin;
   uint32_t mPluginId;
   GMPDecryptorProxyCallback* mCallback;
 #ifdef DEBUG
--- a/dom/media/gmp/GMPEncryptedBufferDataImpl.h
+++ b/dom/media/gmp/GMPEncryptedBufferDataImpl.h
@@ -14,42 +14,42 @@ namespace mozilla {
 class CryptoSample;
 
 namespace gmp {
 
 class GMPStringListImpl : public GMPStringList
 {
 public:
   explicit GMPStringListImpl(const nsTArray<nsCString>& aStrings);
-  virtual uint32_t Size() const override;
-  virtual void StringAt(uint32_t aIndex,
-                        const char** aOutString, uint32_t *aOutLength) const override;
+  uint32_t Size() const override;
+  void StringAt(uint32_t aIndex,
+                const char** aOutString, uint32_t *aOutLength) const override;
   virtual ~GMPStringListImpl() override;
   void RelinquishData(nsTArray<nsCString>& aStrings);
 
 private:
   nsTArray<nsCString> mStrings;
 };
 
 class GMPEncryptedBufferDataImpl : public GMPEncryptedBufferMetadata {
 public:
   explicit GMPEncryptedBufferDataImpl(const CryptoSample& aCrypto);
   explicit GMPEncryptedBufferDataImpl(const GMPDecryptionData& aData);
   virtual ~GMPEncryptedBufferDataImpl();
 
   void RelinquishData(GMPDecryptionData& aData);
 
-  virtual const uint8_t* KeyId() const override;
-  virtual uint32_t KeyIdSize() const override;
-  virtual const uint8_t* IV() const override;
-  virtual uint32_t IVSize() const override;
-  virtual uint32_t NumSubsamples() const override;
-  virtual const uint16_t* ClearBytes() const override;
-  virtual const uint32_t* CipherBytes() const override;
-  virtual const GMPStringList* SessionIds() const override;
+  const uint8_t* KeyId() const override;
+  uint32_t KeyIdSize() const override;
+  const uint8_t* IV() const override;
+  uint32_t IVSize() const override;
+  uint32_t NumSubsamples() const override;
+  const uint16_t* ClearBytes() const override;
+  const uint32_t* CipherBytes() const override;
+  const GMPStringList* SessionIds() const override;
 
 private:
   nsTArray<uint8_t> mKeyId;
   nsTArray<uint8_t> mIV;
   nsTArray<uint16_t> mClearBytes;
   nsTArray<uint32_t> mCipherBytes;
 
   GMPStringListImpl mSessionIdList;
@@ -57,26 +57,26 @@ private:
 
 class GMPBufferImpl : public GMPBuffer {
 public:
   GMPBufferImpl(uint32_t aId, const nsTArray<uint8_t>& aData)
     : mId(aId)
     , mData(aData)
   {
   }
-  virtual uint32_t Id() const {
+  uint32_t Id() const override {
     return mId;
   }
-  virtual uint8_t* Data() {
+  uint8_t* Data() override {
     return mData.Elements();
   }
-  virtual uint32_t Size() const {
+  uint32_t Size() const override {
     return mData.Length();
   }
-  virtual void Resize(uint32_t aSize) {
+  void Resize(uint32_t aSize) override {
     mData.SetLength(aSize);
   }
 
   // Set metadata object to be freed when this buffer is destroyed.
   void SetMetadata(GMPEncryptedBufferDataImpl* aMetadata) {
     mMetadata = aMetadata;
   }
 
--- a/dom/media/gmp/GMPLoader.cpp
+++ b/dom/media/gmp/GMPLoader.cpp
@@ -51,30 +51,30 @@ namespace gmp {
 
 class GMPLoaderImpl : public GMPLoader {
 public:
   explicit GMPLoaderImpl(SandboxStarter* aStarter)
     : mSandboxStarter(aStarter)
   {}
   virtual ~GMPLoaderImpl() {}
 
-  virtual bool Load(const char* aUTF8LibPath,
-                    uint32_t aUTF8LibPathLen,
-                    char* aOriginSalt,
-                    uint32_t aOriginSaltLen,
-                    const GMPPlatformAPI* aPlatformAPI) override;
+  bool Load(const char* aUTF8LibPath,
+            uint32_t aUTF8LibPathLen,
+            char* aOriginSalt,
+            uint32_t aOriginSaltLen,
+            const GMPPlatformAPI* aPlatformAPI) override;
 
-  virtual GMPErr GetAPI(const char* aAPIName,
-                        void* aHostAPI,
-                        void** aPluginAPI) override;
+  GMPErr GetAPI(const char* aAPIName,
+                void* aHostAPI,
+                void** aPluginAPI) override;
 
-  virtual void Shutdown() override;
+  void Shutdown() override;
 
 #if defined(XP_MACOSX) && defined(MOZ_GMP_SANDBOX)
-  virtual void SetSandboxInfo(MacSandboxInfo* aSandboxInfo) override;
+  void SetSandboxInfo(MacSandboxInfo* aSandboxInfo) override;
 #endif
 
 private:
   PRLibrary* mLib;
   GMPGetAPIFunc mGetAPIFunc;
   SandboxStarter* mSandboxStarter;
 };
 
--- a/dom/media/gmp/GMPParent.h
+++ b/dom/media/gmp/GMPParent.h
@@ -153,36 +153,36 @@ private:
   ~GMPParent();
   RefPtr<GeckoMediaPluginServiceParent> mService;
   bool EnsureProcessLoaded();
   nsresult ReadGMPMetaData();
 #ifdef MOZ_CRASHREPORTER
   void WriteExtraDataForMinidump(CrashReporter::AnnotationTable& notes);
   void GetCrashID(nsString& aResult);
 #endif
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
 
-  virtual PCrashReporterParent* AllocPCrashReporterParent(const NativeThreadId& aThread) override;
-  virtual bool DeallocPCrashReporterParent(PCrashReporterParent* aCrashReporter) override;
+  PCrashReporterParent* AllocPCrashReporterParent(const NativeThreadId& aThread) override;
+  bool DeallocPCrashReporterParent(PCrashReporterParent* aCrashReporter) override;
 
-  virtual bool RecvPGMPStorageConstructor(PGMPStorageParent* actor) override;
-  virtual PGMPStorageParent* AllocPGMPStorageParent() override;
-  virtual bool DeallocPGMPStorageParent(PGMPStorageParent* aActor) override;
+  bool RecvPGMPStorageConstructor(PGMPStorageParent* actor) override;
+  PGMPStorageParent* AllocPGMPStorageParent() override;
+  bool DeallocPGMPStorageParent(PGMPStorageParent* aActor) override;
 
-  virtual PGMPContentParent* AllocPGMPContentParent(Transport* aTransport,
-                                                    ProcessId aOtherPid) override;
+  PGMPContentParent* AllocPGMPContentParent(Transport* aTransport,
+                                            ProcessId aOtherPid) override;
 
-  virtual bool RecvPGMPTimerConstructor(PGMPTimerParent* actor) override;
-  virtual PGMPTimerParent* AllocPGMPTimerParent() override;
-  virtual bool DeallocPGMPTimerParent(PGMPTimerParent* aActor) override;
+  bool RecvPGMPTimerConstructor(PGMPTimerParent* actor) override;
+  PGMPTimerParent* AllocPGMPTimerParent() override;
+  bool DeallocPGMPTimerParent(PGMPTimerParent* aActor) override;
 
-  virtual bool RecvAsyncShutdownComplete() override;
-  virtual bool RecvAsyncShutdownRequired() override;
+  bool RecvAsyncShutdownComplete() override;
+  bool RecvAsyncShutdownRequired() override;
 
-  virtual bool RecvPGMPContentChildDestroyed() override;
+  bool RecvPGMPContentChildDestroyed() override;
   bool IsUsed()
   {
     return mGMPContentChildCount > 0;
   }
 
 
   static void AbortWaitingForGMPAsyncShutdown(nsITimer* aTimer, void* aClosure);
   nsresult EnsureAsyncShutdownTimeoutSet();
--- a/dom/media/gmp/GMPPlatform.h
+++ b/dom/media/gmp/GMPPlatform.h
@@ -22,34 +22,34 @@ GMPErr RunOnMainThread(GMPTask* aTask);
 
 class GMPThreadImpl : public GMPThread
 {
 public:
   GMPThreadImpl();
   virtual ~GMPThreadImpl();
 
   // GMPThread
-  virtual void Post(GMPTask* aTask) override;
-  virtual void Join() override;
+  void Post(GMPTask* aTask) override;
+  void Join() override;
 
 private:
   Mutex mMutex;
   base::Thread mThread;
 };
 
 class GMPMutexImpl : public GMPMutex
 {
 public:
   GMPMutexImpl();
   virtual ~GMPMutexImpl();
 
   // GMPMutex
-  virtual void Acquire() override;
-  virtual void Release() override;
-  virtual void Destroy() override;
+  void Acquire() override;
+  void Release() override;
+  void Destroy() override;
 
 private:
   ReentrantMonitor mMonitor;
 };
 
 } // namespace gmp
 } // namespace mozilla
 
--- a/dom/media/gmp/GMPProcessChild.h
+++ b/dom/media/gmp/GMPProcessChild.h
@@ -17,18 +17,18 @@ class GMPLoader;
 class GMPProcessChild final : public mozilla::ipc::ProcessChild {
 protected:
   typedef mozilla::ipc::ProcessChild ProcessChild;
 
 public:
   explicit GMPProcessChild(ProcessId aParentPid);
   ~GMPProcessChild();
 
-  virtual bool Init() override;
-  virtual void CleanUp() override;
+  bool Init() override;
+  void CleanUp() override;
 
   // Set/get the GMPLoader singleton for this child process.
   // Note: The GMPLoader is not deleted by this object, the caller of
   // SetGMPLoader() must manage the GMPLoader's lifecycle.
   static void SetGMPLoader(GMPLoader* aHost);
   static GMPLoader* GetGMPLoader();
 
 private:
--- a/dom/media/gmp/GMPProcessParent.h
+++ b/dom/media/gmp/GMPProcessParent.h
@@ -27,17 +27,17 @@ public:
   ~GMPProcessParent();
 
   // Synchronously launch the plugin process. If the process fails to launch
   // after timeoutMs, this method will return false.
   bool Launch(int32_t aTimeoutMs);
 
   void Delete(nsCOMPtr<nsIRunnable> aCallback = nullptr);
 
-  virtual bool CanShutdown() override { return true; }
+  bool CanShutdown() override { return true; }
   const std::string& GetPluginFilePath() { return mGMPPath; }
 
   using mozilla::ipc::GeckoChildProcessHost::GetShutDownEvent;
   using mozilla::ipc::GeckoChildProcessHost::GetChannel;
   using mozilla::ipc::GeckoChildProcessHost::GetChildProcessHandle;
 
 private:
   void DoDelete();
--- a/dom/media/gmp/GMPService.cpp
+++ b/dom/media/gmp/GMPService.cpp
@@ -370,17 +370,17 @@ GeckoMediaPluginService::GetThread(nsITh
 class GetGMPContentParentForAudioDecoderDone : public GetGMPContentParentCallback
 {
 public:
   explicit GetGMPContentParentForAudioDecoderDone(UniquePtr<GetGMPAudioDecoderCallback>&& aCallback)
    : mCallback(Move(aCallback))
   {
   }
 
-  virtual void Done(GMPContentParent* aGMPParent) override
+  void Done(GMPContentParent* aGMPParent) override
   {
     GMPAudioDecoderParent* gmpADP = nullptr;
     if (aGMPParent) {
       aGMPParent->GetGMPAudioDecoder(&gmpADP);
     }
     mCallback->Done(gmpADP);
   }
 
@@ -414,17 +414,17 @@ GeckoMediaPluginService::GetGMPAudioDeco
 class GetGMPContentParentForVideoDecoderDone : public GetGMPContentParentCallback
 {
 public:
   explicit GetGMPContentParentForVideoDecoderDone(UniquePtr<GetGMPVideoDecoderCallback>&& aCallback)
    : mCallback(Move(aCallback))
   {
   }
 
-  virtual void Done(GMPContentParent* aGMPParent) override
+  void Done(GMPContentParent* aGMPParent) override
   {
     GMPVideoDecoderParent* gmpVDP = nullptr;
     GMPVideoHostImpl* videoHost = nullptr;
     if (aGMPParent && NS_SUCCEEDED(aGMPParent->GetGMPVideoDecoder(&gmpVDP))) {
       videoHost = &gmpVDP->Host();
     }
     mCallback->Done(gmpVDP, videoHost);
   }
@@ -459,17 +459,17 @@ GeckoMediaPluginService::GetGMPVideoDeco
 class GetGMPContentParentForVideoEncoderDone : public GetGMPContentParentCallback
 {
 public:
   explicit GetGMPContentParentForVideoEncoderDone(UniquePtr<GetGMPVideoEncoderCallback>&& aCallback)
    : mCallback(Move(aCallback))
   {
   }
 
-  virtual void Done(GMPContentParent* aGMPParent) override
+  void Done(GMPContentParent* aGMPParent) override
   {
     GMPVideoEncoderParent* gmpVEP = nullptr;
     GMPVideoHostImpl* videoHost = nullptr;
     if (aGMPParent && NS_SUCCEEDED(aGMPParent->GetGMPVideoEncoder(&gmpVEP))) {
       videoHost = &gmpVEP->Host();
     }
     mCallback->Done(gmpVEP, videoHost);
   }
@@ -504,17 +504,17 @@ GeckoMediaPluginService::GetGMPVideoEnco
 class GetGMPContentParentForDecryptorDone : public GetGMPContentParentCallback
 {
 public:
   explicit GetGMPContentParentForDecryptorDone(UniquePtr<GetGMPDecryptorCallback>&& aCallback)
    : mCallback(Move(aCallback))
   {
   }
 
-  virtual void Done(GMPContentParent* aGMPParent) override
+  void Done(GMPContentParent* aGMPParent) override
   {
     GMPDecryptorParent* ksp = nullptr;
     if (aGMPParent) {
       aGMPParent->GetGMPDecryptor(&ksp);
     }
     mCallback->Done(ksp);
   }
 
--- a/dom/media/gmp/GMPServiceChild.cpp
+++ b/dom/media/gmp/GMPServiceChild.cpp
@@ -54,17 +54,17 @@ public:
                            UniquePtr<GetGMPContentParentCallback>&& aCallback)
     : mNodeId(aNodeId),
       mAPI(aAPI),
       mTags(aTags),
       mCallback(Move(aCallback))
   {
   }
 
-  virtual void Done(GMPServiceChild* aGMPServiceChild)
+  void Done(GMPServiceChild* aGMPServiceChild) override
   {
     if (!aGMPServiceChild) {
       mCallback->Done(nullptr);
       return;
     }
 
     nsTArray<base::ProcessId> alreadyBridgedTo;
     aGMPServiceChild->GetAlreadyBridgedTo(alreadyBridgedTo);
@@ -142,17 +142,17 @@ public:
     : mOrigin(aOrigin),
       mTopLevelOrigin(aTopLevelOrigin),
       mGMPName(aGMPName),
       mInPrivateBrowsing(aInPrivateBrowsing),
       mCallback(Move(aCallback))
   {
   }
 
-  virtual void Done(GMPServiceChild* aGMPServiceChild)
+  void Done(GMPServiceChild* aGMPServiceChild) override
   {
     if (!aGMPServiceChild) {
       mCallback->Done(NS_ERROR_FAILURE, EmptyCString());
       return;
     }
 
     nsCString outId;
     if (!aGMPServiceChild->SendGetGMPNodeId(mOrigin, mTopLevelOrigin,
--- a/dom/media/gmp/GMPServiceChild.h
+++ b/dom/media/gmp/GMPServiceChild.h
@@ -53,24 +53,24 @@ public:
 
   NS_DECL_NSIOBSERVER
 
   void SetServiceChild(UniquePtr<GMPServiceChild>&& aServiceChild);
 
   void RemoveGMPContentParent(GMPContentParent* aGMPContentParent);
 
 protected:
-  virtual void InitializePlugins() override
+  void InitializePlugins() override
   {
     // Nothing to do here.
   }
-  virtual bool GetContentParentFrom(const nsACString& aNodeId,
-                                    const nsCString& aAPI,
-                                    const nsTArray<nsCString>& aTags,
-                                    UniquePtr<GetGMPContentParentCallback>&& aCallback)
+  bool GetContentParentFrom(const nsACString& aNodeId,
+                            const nsCString& aAPI,
+                            const nsTArray<nsCString>& aTags,
+                            UniquePtr<GetGMPContentParentCallback>&& aCallback)
     override;
 
 private:
   friend class OpenPGMPServiceChild;
 
   void GetServiceChild(UniquePtr<GetServiceChildCallback>&& aCallback);
 
   UniquePtr<GMPServiceChild> mServiceChild;
@@ -78,19 +78,18 @@ private:
 };
 
 class GMPServiceChild : public PGMPServiceChild
 {
 public:
   explicit GMPServiceChild();
   virtual ~GMPServiceChild();
 
-  virtual PGMPContentParent* AllocPGMPContentParent(Transport* aTransport,
-                                                    ProcessId aOtherPid)
-    override;
+  PGMPContentParent* AllocPGMPContentParent(Transport* aTransport,
+                                            ProcessId aOtherPid) override;
 
   void GetBridgedGMPContentParent(ProcessId aOtherPid,
                                   GMPContentParent** aGMPContentParent);
   void RemoveGMPContentParent(GMPContentParent* aGMPContentParent);
 
   void GetAlreadyBridgedTo(nsTArray<ProcessId>& aAlreadyBridgedTo);
 
   static PGMPServiceChild* Create(Transport* aTransport, ProcessId aOtherPid);
--- a/dom/media/gmp/GMPServiceParent.cpp
+++ b/dom/media/gmp/GMPServiceParent.cpp
@@ -1573,17 +1573,17 @@ GeckoMediaPluginServiceParent::ClearNode
 void
 GeckoMediaPluginServiceParent::ForgetThisSiteOnGMPThread(const nsACString& aSite)
 {
   MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
   LOGD(("%s::%s: origin=%s", __CLASS__, __FUNCTION__, aSite.Data()));
 
   struct OriginFilter : public DirectoryFilter {
     explicit OriginFilter(const nsACString& aSite) : mSite(aSite) {}
-    virtual bool operator()(nsIFile* aPath) {
+    bool operator()(nsIFile* aPath) override {
       return MatchOrigin(aPath, mSite);
     }
   private:
     const nsACString& mSite;
   } filter(aSite);
 
   ClearNodeIdAndPlugin(filter);
 }
@@ -1610,17 +1610,17 @@ GeckoMediaPluginServiceParent::ClearRece
         if (IsModifiedAfter(dirEntry)) {
           return true;
         }
       }
       return false;
     }
 
     // |aPath| is $profileDir/gmp/$platform/$gmpName/id/$originHash/
-    virtual bool operator()(nsIFile* aPath) {
+    bool operator()(nsIFile* aPath) override {
       if (IsModifiedAfter(aPath)) {
         return true;
       }
 
       nsAutoCString salt;
       if (NS_FAILED(ReadSalt(aPath, salt))) {
         return false;
       }
--- a/dom/media/gmp/GMPServiceParent.h
+++ b/dom/media/gmp/GMPServiceParent.h
@@ -25,17 +25,17 @@ class GMPParent;
 
 class GeckoMediaPluginServiceParent final : public GeckoMediaPluginService
                                           , public mozIGeckoMediaPluginChromeService
 {
 public:
   static already_AddRefed<GeckoMediaPluginServiceParent> GetSingleton();
 
   GeckoMediaPluginServiceParent();
-  virtual nsresult Init() override;
+  nsresult Init() override;
 
   NS_DECL_ISUPPORTS_INHERITED
 
   // mozIGeckoMediaPluginService
   NS_IMETHOD GetPluginVersionForAPI(const nsACString& aAPI,
                                     nsTArray<nsCString>* aTags,
                                     bool* aHasPlugin,
                                     nsACString& aOutVersion) override;
@@ -99,21 +99,21 @@ private:
                             DirectoryFilter& aFilter);
   void ForgetThisSiteOnGMPThread(const nsACString& aOrigin);
   void ClearRecentHistoryOnGMPThread(PRTime aSince);
 
 protected:
   friend class GMPParent;
   void ReAddOnGMPThread(const RefPtr<GMPParent>& aOld);
   void PluginTerminated(const RefPtr<GMPParent>& aOld);
-  virtual void InitializePlugins() override;
-  virtual bool GetContentParentFrom(const nsACString& aNodeId,
-                                    const nsCString& aAPI,
-                                    const nsTArray<nsCString>& aTags,
-                                    UniquePtr<GetGMPContentParentCallback>&& aCallback)
+  void InitializePlugins() override;
+  bool GetContentParentFrom(const nsACString& aNodeId,
+                            const nsCString& aAPI,
+                            const nsTArray<nsCString>& aTags,
+                            UniquePtr<GetGMPContentParentCallback>&& aCallback)
     override;
 private:
   GMPParent* ClonePlugin(const GMPParent* aOriginal);
   nsresult EnsurePluginsOnDiskScanned();
   nsresult InitStorage();
 
   class PathRunnable : public nsRunnable
   {
@@ -202,33 +202,33 @@ class GMPServiceParent final : public PG
 {
 public:
   explicit GMPServiceParent(GeckoMediaPluginServiceParent* aService)
     : mService(aService)
   {
   }
   virtual ~GMPServiceParent();
 
-  virtual bool RecvLoadGMP(const nsCString& aNodeId,
-                           const nsCString& aApi,
-                           nsTArray<nsCString>&& aTags,
-                           nsTArray<ProcessId>&& aAlreadyBridgedTo,
-                           base::ProcessId* aID,
-                           nsCString* aDisplayName,
-                           uint32_t* aPluginId) override;
-  virtual bool RecvGetGMPNodeId(const nsString& aOrigin,
-                                const nsString& aTopLevelOrigin,
-                                const nsString& aGMPName,
-                                const bool& aInPrivateBrowsing,
-                                nsCString* aID) override;
+  bool RecvLoadGMP(const nsCString& aNodeId,
+                   const nsCString& aApi,
+                   nsTArray<nsCString>&& aTags,
+                   nsTArray<ProcessId>&& aAlreadyBridgedTo,
+                   base::ProcessId* aID,
+                   nsCString* aDisplayName,
+                   uint32_t* aPluginId) override;
+  bool RecvGetGMPNodeId(const nsString& aOrigin,
+                        const nsString& aTopLevelOrigin,
+                        const nsString& aGMPName,
+                        const bool& aInPrivateBrowsing,
+                        nsCString* aID) override;
   static bool RecvGetGMPPluginVersionForAPI(const nsCString& aAPI,
                                             nsTArray<nsCString>&& aTags,
                                             bool* aHasPlugin,
                                             nsCString* aVersion);
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
 
   static PGMPServiceParent* Create(Transport* aTransport, ProcessId aOtherPid);
 
 private:
   RefPtr<GeckoMediaPluginServiceParent> mService;
 };
 
 } // namespace gmp
--- a/dom/media/gmp/GMPStorageChild.cpp
+++ b/dom/media/gmp/GMPStorageChild.cpp
@@ -300,37 +300,37 @@ class GMPRecordIteratorImpl : public GMP
 public:
   explicit GMPRecordIteratorImpl(const InfallibleTArray<nsCString>& aRecordNames)
     : mRecordNames(aRecordNames)
     , mIndex(0)
   {
     mRecordNames.Sort();
   }
 
-  virtual GMPErr GetName(const char** aOutName, uint32_t* aOutNameLength) override {
+  GMPErr GetName(const char** aOutName, uint32_t* aOutNameLength) override {
     if (!aOutName || !aOutNameLength) {
       return GMPInvalidArgErr;
     }
     if (mIndex == mRecordNames.Length()) {
       return GMPEndOfEnumeration;
     }
     *aOutName = mRecordNames[mIndex].get();
     *aOutNameLength = mRecordNames[mIndex].Length();
     return GMPNoErr;
   }
 
-  virtual GMPErr NextRecord() override {
+  GMPErr NextRecord() override {
     if (mIndex < mRecordNames.Length()) {
       mIndex++;
     }
     return (mIndex < mRecordNames.Length()) ? GMPNoErr
                                             : GMPEndOfEnumeration;
   }
 
-  virtual void Close() override {
+  void Close() override {
     delete this;
   }
 
 private:
   nsTArray<nsCString> mRecordNames;
   size_t mIndex;
 };
 
--- a/dom/media/gmp/GMPStorageChild.h
+++ b/dom/media/gmp/GMPStorageChild.h
@@ -25,21 +25,21 @@ class GMPRecordImpl : public GMPRecord
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GMPRecordImpl)
 
   GMPRecordImpl(GMPStorageChild* aOwner,
                 const nsCString& aName,
                 GMPRecordClient* aClient);
 
   // GMPRecord.
-  virtual GMPErr Open() override;
-  virtual GMPErr Read() override;
-  virtual GMPErr Write(const uint8_t* aData,
-                       uint32_t aDataSize) override;
-  virtual GMPErr Close() override;
+  GMPErr Open() override;
+  GMPErr Read() override;
+  GMPErr Write(const uint8_t* aData,
+               uint32_t aDataSize) override;
+  GMPErr Close() override;
 
   const nsCString& Name() const { return mName; }
 
   void OpenComplete(GMPErr aStatus);
   void ReadComplete(GMPErr aStatus, const uint8_t* aBytes, uint32_t aLength);
   void WriteComplete(GMPErr aStatus);
 
 private:
@@ -76,26 +76,26 @@ public:
 private:
   bool HasRecord(const nsCString& aRecordName);
   already_AddRefed<GMPRecordImpl> GetRecord(const nsCString& aRecordName);
 
 protected:
   ~GMPStorageChild() {}
 
   // PGMPStorageChild
-  virtual bool RecvOpenComplete(const nsCString& aRecordName,
-                                const GMPErr& aStatus) override;
-  virtual bool RecvReadComplete(const nsCString& aRecordName,
-                                const GMPErr& aStatus,
-                                InfallibleTArray<uint8_t>&& aBytes) override;
-  virtual bool RecvWriteComplete(const nsCString& aRecordName,
-                                 const GMPErr& aStatus) override;
-  virtual bool RecvRecordNames(InfallibleTArray<nsCString>&& aRecordNames,
-                               const GMPErr& aStatus) override;
-  virtual bool RecvShutdown() override;
+  bool RecvOpenComplete(const nsCString& aRecordName,
+                        const GMPErr& aStatus) override;
+  bool RecvReadComplete(const nsCString& aRecordName,
+                        const GMPErr& aStatus,
+                        InfallibleTArray<uint8_t>&& aBytes) override;
+  bool RecvWriteComplete(const nsCString& aRecordName,
+                         const GMPErr& aStatus) override;
+  bool RecvRecordNames(InfallibleTArray<nsCString>&& aRecordNames,
+                       const GMPErr& aStatus) override;
+  bool RecvShutdown() override;
 
 private:
   Monitor mMonitor;
   nsRefPtrHashtable<nsCStringHashKey, GMPRecordImpl> mRecords;
   GMPChild* mPlugin;
 
   struct RecordIteratorContext {
     explicit RecordIteratorContext(RecvGMPRecordIteratorPtr aFunc,
--- a/dom/media/gmp/GMPStorageParent.h
+++ b/dom/media/gmp/GMPStorageParent.h
@@ -34,23 +34,23 @@ public:
   NS_INLINE_DECL_REFCOUNTING(GMPStorageParent)
   GMPStorageParent(const nsCString& aNodeId,
                    GMPParent* aPlugin);
 
   nsresult Init();
   void Shutdown();
 
 protected:
-  virtual bool RecvOpen(const nsCString& aRecordName) override;
-  virtual bool RecvRead(const nsCString& aRecordName) override;
-  virtual bool RecvWrite(const nsCString& aRecordName,
-                         InfallibleTArray<uint8_t>&& aBytes) override;
-  virtual bool RecvGetRecordNames() override;
-  virtual bool RecvClose(const nsCString& aRecordName) override;
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+  bool RecvOpen(const nsCString& aRecordName) override;
+  bool RecvRead(const nsCString& aRecordName) override;
+  bool RecvWrite(const nsCString& aRecordName,
+                 InfallibleTArray<uint8_t>&& aBytes) override;
+  bool RecvGetRecordNames() override;
+  bool RecvClose(const nsCString& aRecordName) override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
 
 private:
   ~GMPStorageParent() {}
 
   UniquePtr<GMPStorage> mStorage;
 
   const nsCString mNodeId;
   RefPtr<GMPParent> mPlugin;
--- a/dom/media/gmp/GMPTimerChild.h
+++ b/dom/media/gmp/GMPTimerChild.h
@@ -24,17 +24,17 @@ public:
   NS_INLINE_DECL_REFCOUNTING(GMPTimerChild)
 
   explicit GMPTimerChild(GMPChild* aPlugin);
 
   GMPErr SetTimer(GMPTask* aTask, int64_t aTimeoutMS);
 
 protected:
   // GMPTimerChild
-  virtual bool RecvTimerExpired(const uint32_t& aTimerId) override;
+  bool RecvTimerExpired(const uint32_t& aTimerId) override;
 
 private:
   ~GMPTimerChild();
 
   nsDataHashtable<nsUint32HashKey, GMPTask*> mTimers;
   uint32_t mTimerCount;
 
   GMPChild* mPlugin;
--- a/dom/media/gmp/GMPTimerParent.h
+++ b/dom/media/gmp/GMPTimerParent.h
@@ -21,19 +21,19 @@ namespace gmp {
 class GMPTimerParent : public PGMPTimerParent {
 public:
   NS_INLINE_DECL_REFCOUNTING(GMPTimerParent)
   explicit GMPTimerParent(nsIThread* aGMPThread);
 
   void Shutdown();
 
 protected:
-  virtual bool RecvSetTimer(const uint32_t& aTimerId,
-                            const uint32_t& aTimeoutMs) override;
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+  bool RecvSetTimer(const uint32_t& aTimerId,
+                    const uint32_t& aTimeoutMs) override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
 
 private:
   ~GMPTimerParent() {}
 
   static void GMPTimerExpired(nsITimer *aTimer, void *aClosure);
 
   struct Context {
     Context() {
--- a/dom/media/gmp/GMPVideoDecoderChild.h
+++ b/dom/media/gmp/GMPVideoDecoderChild.h
@@ -26,43 +26,43 @@ public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GMPVideoDecoderChild);
 
   explicit GMPVideoDecoderChild(GMPContentChild* aPlugin);
 
   void Init(GMPVideoDecoder* aDecoder);
   GMPVideoHostImpl& Host();
 
   // GMPVideoDecoderCallback
-  virtual void Decoded(GMPVideoi420Frame* decodedFrame) override;
-  virtual void ReceivedDecodedReferenceFrame(const uint64_t pictureId) override;
-  virtual void ReceivedDecodedFrame(const uint64_t pictureId) override;
-  virtual void InputDataExhausted() override;
-  virtual void DrainComplete() override;
-  virtual void ResetComplete() override;
-  virtual void Error(GMPErr aError) override;
+  void Decoded(GMPVideoi420Frame* decodedFrame) override;
+  void ReceivedDecodedReferenceFrame(const uint64_t pictureId) override;
+  void ReceivedDecodedFrame(const uint64_t pictureId) override;
+  void InputDataExhausted() override;
+  void DrainComplete() override;
+  void ResetComplete() override;
+  void Error(GMPErr aError) override;
 
   // GMPSharedMemManager
-  virtual bool Alloc(size_t aSize, Shmem::SharedMemory::SharedMemoryType aType, Shmem* aMem) override;
-  virtual void Dealloc(Shmem& aMem) override;
+  bool Alloc(size_t aSize, Shmem::SharedMemory::SharedMemoryType aType, Shmem* aMem) override;
+  void Dealloc(Shmem& aMem) override;
 
 private:
   virtual ~GMPVideoDecoderChild();
 
   // PGMPVideoDecoderChild
-  virtual bool RecvInitDecode(const GMPVideoCodec& aCodecSettings,
-                              InfallibleTArray<uint8_t>&& aCodecSpecific,
-                              const int32_t& aCoreCount) override;
-  virtual bool RecvDecode(const GMPVideoEncodedFrameData& aInputFrame,
-                          const bool& aMissingFrames,
-                          InfallibleTArray<uint8_t>&& aCodecSpecificInfo,
-                          const int64_t& aRenderTimeMs) override;
-  virtual bool RecvChildShmemForPool(Shmem&& aFrameBuffer) override;
-  virtual bool RecvReset() override;
-  virtual bool RecvDrain() override;
-  virtual bool RecvDecodingComplete() override;
+  bool RecvInitDecode(const GMPVideoCodec& aCodecSettings,
+                      InfallibleTArray<uint8_t>&& aCodecSpecific,
+                      const int32_t& aCoreCount) override;
+  bool RecvDecode(const GMPVideoEncodedFrameData& aInputFrame,
+                  const bool& aMissingFrames,
+                  InfallibleTArray<uint8_t>&& aCodecSpecificInfo,
+                  const int64_t& aRenderTimeMs) override;
+  bool RecvChildShmemForPool(Shmem&& aFrameBuffer) override;
+  bool RecvReset() override;
+  bool RecvDrain() override;
+  bool RecvDecodingComplete() override;
 
   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/GMPVideoDecoderParent.h
+++ b/dom/media/gmp/GMPVideoDecoderParent.h
@@ -29,61 +29,61 @@ public:
   NS_INLINE_DECL_REFCOUNTING(GMPVideoDecoderParent)
 
   explicit GMPVideoDecoderParent(GMPContentParent *aPlugin);
 
   GMPVideoHostImpl& Host();
   nsresult Shutdown();
 
   // GMPVideoDecoder
-  virtual void Close() override;
-  virtual nsresult InitDecode(const GMPVideoCodec& aCodecSettings,
-                              const nsTArray<uint8_t>& aCodecSpecific,
-                              GMPVideoDecoderCallbackProxy* aCallback,
-                              int32_t aCoreCount) override;
-  virtual nsresult Decode(GMPUniquePtr<GMPVideoEncodedFrame> aInputFrame,
-                          bool aMissingFrames,
-                          const nsTArray<uint8_t>& aCodecSpecificInfo,
-                          int64_t aRenderTimeMs = -1) override;
-  virtual nsresult Reset() override;
-  virtual nsresult Drain() override;
-  virtual uint32_t GetPluginId() const override { return mPluginId; }
-  virtual const nsCString& GetDisplayName() const override;
+  void Close() override;
+  nsresult InitDecode(const GMPVideoCodec& aCodecSettings,
+                      const nsTArray<uint8_t>& aCodecSpecific,
+                      GMPVideoDecoderCallbackProxy* aCallback,
+                      int32_t aCoreCount) override;
+  nsresult Decode(GMPUniquePtr<GMPVideoEncodedFrame> aInputFrame,
+                  bool aMissingFrames,
+                  const nsTArray<uint8_t>& aCodecSpecificInfo,
+                  int64_t aRenderTimeMs = -1) override;
+  nsresult Reset() override;
+  nsresult Drain() override;
+  uint32_t GetPluginId() const override { return mPluginId; }
+  const nsCString& GetDisplayName() const override;
 
   // GMPSharedMemManager
-  virtual bool Alloc(size_t aSize, Shmem::SharedMemory::SharedMemoryType aType, Shmem* aMem) override
+  bool Alloc(size_t aSize, Shmem::SharedMemory::SharedMemoryType aType, Shmem* aMem) override
   {
 #ifdef GMP_SAFE_SHMEM
     return AllocShmem(aSize, aType, aMem);
 #else
     return AllocUnsafeShmem(aSize, aType, aMem);
 #endif
   }
-  virtual void Dealloc(Shmem& aMem) override
+  void Dealloc(Shmem& aMem) override
   {
     DeallocShmem(aMem);
   }
 
 private:
   ~GMPVideoDecoderParent();
 
   // PGMPVideoDecoderParent
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
-  virtual bool RecvDecoded(const GMPVideoi420FrameData& aDecodedFrame) override;
-  virtual bool RecvReceivedDecodedReferenceFrame(const uint64_t& aPictureId) override;
-  virtual bool RecvReceivedDecodedFrame(const uint64_t& aPictureId) override;
-  virtual bool RecvInputDataExhausted() override;
-  virtual bool RecvDrainComplete() override;
-  virtual bool RecvResetComplete() override;
-  virtual bool RecvError(const GMPErr& aError) override;
-  virtual bool RecvShutdown() override;
-  virtual bool RecvParentShmemForPool(Shmem&& aEncodedBuffer) override;
-  virtual bool AnswerNeedShmem(const uint32_t& aFrameBufferSize,
-                               Shmem* aMem) override;
-  virtual bool Recv__delete__() override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+  bool RecvDecoded(const GMPVideoi420FrameData& aDecodedFrame) override;
+  bool RecvReceivedDecodedReferenceFrame(const uint64_t& aPictureId) override;
+  bool RecvReceivedDecodedFrame(const uint64_t& aPictureId) override;
+  bool RecvInputDataExhausted() override;
+  bool RecvDrainComplete() override;
+  bool RecvResetComplete() override;
+  bool RecvError(const GMPErr& aError) override;
+  bool RecvShutdown() override;
+  bool RecvParentShmemForPool(Shmem&& aEncodedBuffer) override;
+  bool AnswerNeedShmem(const uint32_t& aFrameBufferSize,
+                       Shmem* aMem) override;
+  bool Recv__delete__() override;
 
   void UnblockResetAndDrain();
   void CancelResetCompleteTimeout();
 
   bool mIsOpen;
   bool mShuttingDown;
   bool mActorDestroyed;
   bool mIsAwaitingResetComplete;
--- a/dom/media/gmp/GMPVideoEncodedFrameImpl.h
+++ b/dom/media/gmp/GMPVideoEncodedFrameImpl.h
@@ -60,48 +60,48 @@ public:
   // when a consumer is finished or during XPCOM shutdown.
   void DoneWithAPI();
   // Does not attempt to release Shmem, as the Shmem has already been released.
   void ActorDestroyed();
 
   bool RelinquishFrameData(GMPVideoEncodedFrameData& aFrameData);
 
   // GMPVideoFrame
-  virtual GMPVideoFrameFormat GetFrameFormat() override;
-  virtual void Destroy() override;
+  GMPVideoFrameFormat GetFrameFormat() override;
+  void Destroy() override;
 
   // GMPVideoEncodedFrame
-  virtual GMPErr   CreateEmptyFrame(uint32_t aSize) override;
-  virtual GMPErr   CopyFrame(const GMPVideoEncodedFrame& aFrame) override;
-  virtual void     SetEncodedWidth(uint32_t aEncodedWidth) override;
-  virtual uint32_t EncodedWidth() override;
-  virtual void     SetEncodedHeight(uint32_t aEncodedHeight) override;
-  virtual uint32_t EncodedHeight() override;
+  GMPErr   CreateEmptyFrame(uint32_t aSize) override;
+  GMPErr   CopyFrame(const GMPVideoEncodedFrame& aFrame) override;
+  void     SetEncodedWidth(uint32_t aEncodedWidth) override;
+  uint32_t EncodedWidth() override;
+  void     SetEncodedHeight(uint32_t aEncodedHeight) override;
+  uint32_t EncodedHeight() override;
   // Microseconds
-  virtual void     SetTimeStamp(uint64_t aTimeStamp) override;
-  virtual uint64_t TimeStamp() override;
+  void     SetTimeStamp(uint64_t aTimeStamp) override;
+  uint64_t TimeStamp() override;
   // Set frame duration (microseconds)
   // NOTE: next-frame's Timestamp() != this-frame's TimeStamp()+Duration()
   // depending on rounding to avoid having to track roundoff errors
   // and dropped/missing frames(!) (which may leave a large gap)
-  virtual void     SetDuration(uint64_t aDuration) override;
-  virtual uint64_t Duration() const override;
-  virtual void     SetFrameType(GMPVideoFrameType aFrameType) override;
-  virtual GMPVideoFrameType FrameType() override;
-  virtual void     SetAllocatedSize(uint32_t aNewSize) override;
-  virtual uint32_t AllocatedSize() override;
-  virtual void     SetSize(uint32_t aSize) override;
-  virtual uint32_t Size() override;
-  virtual void     SetCompleteFrame(bool aCompleteFrame) override;
-  virtual bool     CompleteFrame() override;
-  virtual const uint8_t* Buffer() const override;
-  virtual uint8_t* Buffer() override;
-  virtual GMPBufferType BufferType() const override;
-  virtual void     SetBufferType(GMPBufferType aBufferType) override;
-  virtual const    GMPEncryptedBufferMetadata* GetDecryptionData() const override;
+  void     SetDuration(uint64_t aDuration) override;
+  uint64_t Duration() const override;
+  void     SetFrameType(GMPVideoFrameType aFrameType) override;
+  GMPVideoFrameType FrameType() override;
+  void     SetAllocatedSize(uint32_t aNewSize) override;
+  uint32_t AllocatedSize() override;
+  void     SetSize(uint32_t aSize) override;
+  uint32_t Size() override;
+  void     SetCompleteFrame(bool aCompleteFrame) override;
+  bool     CompleteFrame() override;
+  const uint8_t* Buffer() const override;
+  uint8_t* Buffer() override;
+  GMPBufferType BufferType() const override;
+  void     SetBufferType(GMPBufferType aBufferType) override;
+  const    GMPEncryptedBufferMetadata* GetDecryptionData() const override;
 
 private:
   void DestroyBuffer();
 
   uint32_t mEncodedWidth;
   uint32_t mEncodedHeight;
   uint64_t mTimeStamp;
   uint64_t mDuration;
--- a/dom/media/gmp/GMPVideoEncoderChild.h
+++ b/dom/media/gmp/GMPVideoEncoderChild.h
@@ -25,44 +25,44 @@ public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GMPVideoEncoderChild);
 
   explicit GMPVideoEncoderChild(GMPContentChild* aPlugin);
 
   void Init(GMPVideoEncoder* aEncoder);
   GMPVideoHostImpl& Host();
 
   // GMPVideoEncoderCallback
-  virtual void Encoded(GMPVideoEncodedFrame* aEncodedFrame,
-                       const uint8_t* aCodecSpecificInfo,
-                       uint32_t aCodecSpecificInfoLength) override;
-  virtual void Error(GMPErr aError) override;
+  void Encoded(GMPVideoEncodedFrame* aEncodedFrame,
+               const uint8_t* aCodecSpecificInfo,
+               uint32_t aCodecSpecificInfoLength) override;
+  void Error(GMPErr aError) override;
 
   // GMPSharedMemManager
-  virtual bool Alloc(size_t aSize, Shmem::SharedMemory::SharedMemoryType aType,
+  bool Alloc(size_t aSize, Shmem::SharedMemory::SharedMemoryType aType,
     Shmem* aMem) override;
-  virtual void Dealloc(Shmem& aMem) override;
+  void Dealloc(Shmem& aMem) override;
 
 private:
   virtual ~GMPVideoEncoderChild();
 
   // PGMPVideoEncoderChild
-  virtual bool RecvInitEncode(const GMPVideoCodec& aCodecSettings,
-                              InfallibleTArray<uint8_t>&& aCodecSpecific,
-                              const int32_t& aNumberOfCores,
-                              const uint32_t& aMaxPayloadSize) override;
-  virtual bool RecvEncode(const GMPVideoi420FrameData& aInputFrame,
-                          InfallibleTArray<uint8_t>&& aCodecSpecificInfo,
-                          InfallibleTArray<GMPVideoFrameType>&& aFrameTypes) override;
-  virtual bool RecvChildShmemForPool(Shmem&& aEncodedBuffer) override;
-  virtual bool RecvSetChannelParameters(const uint32_t& aPacketLoss,
-                                        const uint32_t& aRTT) override;
-  virtual bool RecvSetRates(const uint32_t& aNewBitRate,
-                            const uint32_t& aFrameRate) override;
-  virtual bool RecvSetPeriodicKeyFrames(const bool& aEnable) override;
-  virtual bool RecvEncodingComplete() override;
+  bool RecvInitEncode(const GMPVideoCodec& aCodecSettings,
+                      InfallibleTArray<uint8_t>&& aCodecSpecific,
+                      const int32_t& aNumberOfCores,
+                      const uint32_t& aMaxPayloadSize) override;
+  bool RecvEncode(const GMPVideoi420FrameData& aInputFrame,
+                  InfallibleTArray<uint8_t>&& aCodecSpecificInfo,
+                  InfallibleTArray<GMPVideoFrameType>&& aFrameTypes) override;
+  bool RecvChildShmemForPool(Shmem&& aEncodedBuffer) override;
+  bool RecvSetChannelParameters(const uint32_t& aPacketLoss,
+                                const uint32_t& aRTT) override;
+  bool RecvSetRates(const uint32_t& aNewBitRate,
+                    const uint32_t& aFrameRate) override;
+  bool RecvSetPeriodicKeyFrames(const bool& aEnable) override;
+  bool RecvEncodingComplete() override;
 
   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/gmp/GMPVideoEncoderParent.h
+++ b/dom/media/gmp/GMPVideoEncoderParent.h
@@ -28,57 +28,57 @@ public:
   NS_INLINE_DECL_REFCOUNTING(GMPVideoEncoderParent)
 
   explicit GMPVideoEncoderParent(GMPContentParent *aPlugin);
 
   GMPVideoHostImpl& Host();
   void Shutdown();
 
   // GMPVideoEncoderProxy
-  virtual void Close() override;
-  virtual GMPErr InitEncode(const GMPVideoCodec& aCodecSettings,
-                            const nsTArray<uint8_t>& aCodecSpecific,
-                            GMPVideoEncoderCallbackProxy* aCallback,
-                            int32_t aNumberOfCores,
-                            uint32_t aMaxPayloadSize) override;
-  virtual GMPErr Encode(GMPUniquePtr<GMPVideoi420Frame> aInputFrame,
-                        const nsTArray<uint8_t>& aCodecSpecificInfo,
-                        const nsTArray<GMPVideoFrameType>& aFrameTypes) override;
-  virtual GMPErr SetChannelParameters(uint32_t aPacketLoss, uint32_t aRTT) override;
-  virtual GMPErr SetRates(uint32_t aNewBitRate, uint32_t aFrameRate) override;
-  virtual GMPErr SetPeriodicKeyFrames(bool aEnable) override;
-  virtual uint32_t GetPluginId() const override { return mPluginId; }
+  void Close() override;
+  GMPErr InitEncode(const GMPVideoCodec& aCodecSettings,
+                    const nsTArray<uint8_t>& aCodecSpecific,
+                    GMPVideoEncoderCallbackProxy* aCallback,
+                    int32_t aNumberOfCores,
+                    uint32_t aMaxPayloadSize) override;
+  GMPErr Encode(GMPUniquePtr<GMPVideoi420Frame> aInputFrame,
+                const nsTArray<uint8_t>& aCodecSpecificInfo,
+                const nsTArray<GMPVideoFrameType>& aFrameTypes) override;
+  GMPErr SetChannelParameters(uint32_t aPacketLoss, uint32_t aRTT) override;
+  GMPErr SetRates(uint32_t aNewBitRate, uint32_t aFrameRate) override;
+  GMPErr SetPeriodicKeyFrames(bool aEnable) override;
+  uint32_t GetPluginId() const override { return mPluginId; }
 
   // GMPSharedMemManager
-  virtual bool Alloc(size_t aSize, Shmem::SharedMemory::SharedMemoryType aType, Shmem* aMem) override
+  bool Alloc(size_t aSize, Shmem::SharedMemory::SharedMemoryType aType, Shmem* aMem) override
   {
 #ifdef GMP_SAFE_SHMEM
     return AllocShmem(aSize, aType, aMem);
 #else
     return AllocUnsafeShmem(aSize, aType, aMem);
 #endif
   }
-  virtual void Dealloc(Shmem& aMem) override
+  void Dealloc(Shmem& aMem) override
   {
     DeallocShmem(aMem);
   }
 
 private:
   virtual ~GMPVideoEncoderParent();
 
   // PGMPVideoEncoderParent
-  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
-  virtual bool RecvEncoded(const GMPVideoEncodedFrameData& aEncodedFrame,
-                           InfallibleTArray<uint8_t>&& aCodecSpecificInfo) override;
-  virtual bool RecvError(const GMPErr& aError) override;
-  virtual bool RecvShutdown() override;
-  virtual bool RecvParentShmemForPool(Shmem&& aFrameBuffer) override;
-  virtual bool AnswerNeedShmem(const uint32_t& aEncodedBufferSize,
-                               Shmem* aMem) override;
-  virtual bool Recv__delete__() override;
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+  bool RecvEncoded(const GMPVideoEncodedFrameData& aEncodedFrame,
+                   InfallibleTArray<uint8_t>&& aCodecSpecificInfo) override;
+  bool RecvError(const GMPErr& aError) override;
+  bool RecvShutdown() override;
+  bool RecvParentShmemForPool(Shmem&& aFrameBuffer) override;
+  bool AnswerNeedShmem(const uint32_t& aEncodedBufferSize,
+                       Shmem* aMem) override;
+  bool Recv__delete__() override;
 
   bool mIsOpen;
   bool mShuttingDown;
   bool mActorDestroyed;
   RefPtr<GMPContentParent> mPlugin;
   GMPVideoEncoderCallbackProxy* mCallback;
   GMPVideoHostImpl mVideoHost;
   nsCOMPtr<nsIThread> mEncodedThread;
--- a/dom/media/gmp/GMPVideoHost.h
+++ b/dom/media/gmp/GMPVideoHost.h
@@ -30,18 +30,18 @@ public:
   void DoneWithAPI();
   void ActorDestroyed();
   void PlaneCreated(GMPPlaneImpl* aPlane);
   void PlaneDestroyed(GMPPlaneImpl* aPlane);
   void EncodedFrameCreated(GMPVideoEncodedFrameImpl* aEncodedFrame);
   void EncodedFrameDestroyed(GMPVideoEncodedFrameImpl* aFrame);
 
   // GMPVideoHost
-  virtual GMPErr CreateFrame(GMPVideoFrameFormat aFormat, GMPVideoFrame** aFrame) override;
-  virtual GMPErr CreatePlane(GMPPlane** aPlane) override;
+  GMPErr CreateFrame(GMPVideoFrameFormat aFormat, GMPVideoFrame** aFrame) override;
+  GMPErr CreatePlane(GMPPlane** aPlane) override;
 
 private:
   // All shared memory allocations have to be made by an IPDL actor.
   // This is a reference to the owning actor. If this reference is
   // null then the actor has died and all allocations must fail.
   GMPSharedMemManager* mSharedMemMgr;
 
   // We track all of these things because they need to handle further
--- a/dom/media/gmp/GMPVideoPlaneImpl.h
+++ b/dom/media/gmp/GMPVideoPlaneImpl.h
@@ -29,31 +29,31 @@ public:
   // This is called when something has gone wrong - specicifically,
   // a child process has crashed. Does not attempt to release Shmem,
   // as the Shmem has already been released.
   void ActorDestroyed();
 
   bool InitPlaneData(GMPPlaneData& aPlaneData);
 
   // GMPPlane
-  virtual GMPErr CreateEmptyPlane(int32_t aAllocatedSize,
-                                  int32_t aStride,
-                                  int32_t aPlaneSize) override;
-  virtual GMPErr Copy(const GMPPlane& aPlane) override;
-  virtual GMPErr Copy(int32_t aSize,
-                      int32_t aStride,
-                      const uint8_t* aBuffer) override;
-  virtual void Swap(GMPPlane& aPlane) override;
-  virtual int32_t AllocatedSize() const override;
-  virtual void ResetSize() override;
-  virtual bool IsZeroSize() const override;
-  virtual int32_t Stride() const override;
-  virtual const uint8_t* Buffer() const override;
-  virtual uint8_t* Buffer() override;
-  virtual void Destroy() override;
+  GMPErr CreateEmptyPlane(int32_t aAllocatedSize,
+                          int32_t aStride,
+                          int32_t aPlaneSize) override;
+  GMPErr Copy(const GMPPlane& aPlane) override;
+  GMPErr Copy(int32_t aSize,
+              int32_t aStride,
+              const uint8_t* aBuffer) override;
+  void Swap(GMPPlane& aPlane) override;
+  int32_t AllocatedSize() const override;
+  void ResetSize() override;
+  bool IsZeroSize() const override;
+  int32_t Stride() const override;
+  const uint8_t* Buffer() const override;
+  uint8_t* Buffer() override;
+  void Destroy() override;
 
 private:
   GMPErr MaybeResize(int32_t aNewSize);
   void DestroyBuffer();
 
   ipc::Shmem mBuffer;
   int32_t mSize;
   int32_t mStride;
--- a/dom/media/gmp/GMPVideoi420FrameImpl.h
+++ b/dom/media/gmp/GMPVideoi420FrameImpl.h
@@ -25,49 +25,49 @@ public:
 
   static bool CheckFrameData(const GMPVideoi420FrameData& aFrameData);
 
   bool InitFrameData(GMPVideoi420FrameData& aFrameData);
   const GMPPlaneImpl* GetPlane(GMPPlaneType aType) const;
   GMPPlaneImpl* GetPlane(GMPPlaneType aType);
 
   // GMPVideoFrame
-  virtual GMPVideoFrameFormat GetFrameFormat() override;
-  virtual void Destroy() override;
+  GMPVideoFrameFormat GetFrameFormat() override;
+  void Destroy() override;
 
   // GMPVideoi420Frame
-  virtual GMPErr CreateEmptyFrame(int32_t aWidth,
-                                  int32_t aHeight,
-                                  int32_t aStride_y,
-                                  int32_t aStride_u,
-                                  int32_t aStride_v) override;
-  virtual GMPErr CreateFrame(int32_t aSize_y, const uint8_t* aBuffer_y,
-                             int32_t aSize_u, const uint8_t* aBuffer_u,
-                             int32_t aSize_v, const uint8_t* aBuffer_v,
-                             int32_t aWidth,
-                             int32_t aHeight,
-                             int32_t aStride_y,
-                             int32_t aStride_u,
-                             int32_t aStride_v) override;
-  virtual GMPErr CopyFrame(const GMPVideoi420Frame& aFrame) override;
-  virtual void SwapFrame(GMPVideoi420Frame* aFrame) override;
-  virtual uint8_t* Buffer(GMPPlaneType aType) override;
-  virtual const uint8_t* Buffer(GMPPlaneType aType) const override;
-  virtual int32_t AllocatedSize(GMPPlaneType aType) const override;
-  virtual int32_t Stride(GMPPlaneType aType) const override;
-  virtual GMPErr SetWidth(int32_t aWidth) override;
-  virtual GMPErr SetHeight(int32_t aHeight) override;
-  virtual int32_t Width() const override;
-  virtual int32_t Height() const override;
-  virtual void SetTimestamp(uint64_t aTimestamp) override;
-  virtual uint64_t Timestamp() const override;
-  virtual void SetDuration(uint64_t aDuration) override;
-  virtual uint64_t Duration() const override;
-  virtual bool IsZeroSize() const override;
-  virtual void ResetSize() override;
+  GMPErr CreateEmptyFrame(int32_t aWidth,
+                          int32_t aHeight,
+                          int32_t aStride_y,
+                          int32_t aStride_u,
+                          int32_t aStride_v) override;
+  GMPErr CreateFrame(int32_t aSize_y, const uint8_t* aBuffer_y,
+                     int32_t aSize_u, const uint8_t* aBuffer_u,
+                     int32_t aSize_v, const uint8_t* aBuffer_v,
+                     int32_t aWidth,
+                     int32_t aHeight,
+                     int32_t aStride_y,
+                     int32_t aStride_u,
+                     int32_t aStride_v) override;
+  GMPErr CopyFrame(const GMPVideoi420Frame& aFrame) override;
+  void SwapFrame(GMPVideoi420Frame* aFrame) override;
+  uint8_t* Buffer(GMPPlaneType aType) override;
+  const uint8_t* Buffer(GMPPlaneType aType) const override;
+  int32_t AllocatedSize(GMPPlaneType aType) const override;
+  int32_t Stride(GMPPlaneType aType) const override;
+  GMPErr SetWidth(int32_t aWidth) override;
+  GMPErr SetHeight(int32_t aHeight) override;
+  int32_t Width() const override;
+  int32_t Height() const override;
+  void SetTimestamp(uint64_t aTimestamp) override;
+  uint64_t Timestamp() const override;
+  void SetDuration(uint64_t aDuration) override;
+  uint64_t Duration() const override;
+  bool IsZeroSize() const override;
+  void ResetSize() override;
 
 private:
   bool CheckDimensions(int32_t aWidth, int32_t aHeight,
                        int32_t aStride_y, int32_t aStride_u, int32_t aStride_v);
 
   GMPPlaneImpl mYPlane;
   GMPPlaneImpl mUPlane;
   GMPPlaneImpl mVPlane;