Bug 1240411: P5. Clean up GMP headers. r=cpearce
authorJean-Yves Avenard <jyavenard@mozilla.com>
Mon, 18 Jan 2016 14:40:49 +1100
changeset 302995 48d96340d424ee60efd502228c0ef2b80720ef19
parent 302994 8a7c295f149a248ff9459079058a8a97d1f1da9f
child 302996 e1f4f479595d37d14235d5c6b211b2ade132e245
push id5703
push userraliiev@mozilla.com
push dateMon, 07 Mar 2016 14:18:41 +0000
treeherdermozilla-esr52@31e373ad5b5f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerscpearce
bugs1240411
milestone46.0a1
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;