--- a/accessible/aom/AccessibleNode.h
+++ b/accessible/aom/AccessibleNode.h
@@ -28,17 +28,17 @@ class AccessibleNode : public nsISupport
                        public nsWrapperCache
 {
 public:
   explicit AccessibleNode(nsINode* aNode);
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS;
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(AccessibleNode);
 
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override final;
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
   virtual dom::ParentObject GetParentObject() const final;
 
   void GetRole(nsAString& aRole);
   void GetStates(nsTArray<nsString>& aStates);
   void GetAttributes(nsTArray<nsString>& aAttributes);
   nsINode* GetDOMNode();
 
   bool Is(const Sequence<nsString>& aFlavors);

--- a/accessible/generic/BaseAccessibles.h
+++ b/accessible/generic/BaseAccessibles.h
@@ -30,18 +30,18 @@ public:
   LeafAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // nsISupports
   NS_INLINE_DECL_REFCOUNTING_INHERITED(LeafAccessible, AccessibleWrap)
 
   // Accessible
   virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY,
                                    EWhichChildAtPoint aWhichChild) override;
-  virtual bool InsertChildAt(uint32_t aIndex, Accessible* aChild) override final;
-  virtual bool RemoveChild(Accessible* aChild) override final;
+  virtual bool InsertChildAt(uint32_t aIndex, Accessible* aChild) final;
+  virtual bool RemoveChild(Accessible* aChild) final;
 
   virtual bool IsAcceptableChild(nsIContent* aEl) const override;
 
 protected:
   virtual ~LeafAccessible() {}
 };
 
 /**
@@ -111,21 +111,21 @@ protected:
  * crossplatform accessible tree.
  */
 class DummyAccessible : public AccessibleWrap
 {
 public:
   explicit DummyAccessible(DocAccessible* aDocument = nullptr) :
     AccessibleWrap(nullptr, aDocument) { }
 
-  virtual uint64_t NativeState() override final;
-  virtual uint64_t NativeInteractiveState() const override final;
-  virtual uint64_t NativeLinkState() const override final;
-  virtual bool NativelyUnavailable() const override final;
-  virtual void ApplyARIAState(uint64_t* aState) const override final;
+  virtual uint64_t NativeState() final;
+  virtual uint64_t NativeInteractiveState() const final;
+  virtual uint64_t NativeLinkState() const final;
+  virtual bool NativelyUnavailable() const final;
+  virtual void ApplyARIAState(uint64_t* aState) const final;
 
 protected:
   virtual ~DummyAccessible() { }
 };
 
 } // namespace a11y
 } // namespace mozilla
 

--- a/accessible/ipc/DocAccessibleParent.h
+++ b/accessible/ipc/DocAccessibleParent.h
@@ -74,23 +74,23 @@ public:
     override;
 
   virtual mozilla::ipc::IPCResult RecvShowEvent(const ShowEventData& aData, const bool& aFromUser)
     override;
   virtual mozilla::ipc::IPCResult RecvHideEvent(const uint64_t& aRootID, const bool& aFromUser)
     override;
   virtual mozilla::ipc::IPCResult RecvStateChangeEvent(const uint64_t& aID,
                                                        const uint64_t& aState,
-                                                       const bool& aEnabled) override final;
+                                                       const bool& aEnabled) final;
 
   virtual mozilla::ipc::IPCResult RecvCaretMoveEvent(const uint64_t& aID,
 #if defined(XP_WIN)
                                                      const LayoutDeviceIntRect& aCaretRect,
 #endif
-                                                     const int32_t& aOffset) override final;
+                                                     const int32_t& aOffset) final;
 
   virtual mozilla::ipc::IPCResult RecvTextChangeEvent(const uint64_t& aID, const nsString& aStr,
                                                       const int32_t& aStart, const uint32_t& aLen,
                                                       const bool& aIsInsert,
                                                       const bool& aFromUser) override;
 
 #if defined(XP_WIN)
   virtual mozilla::ipc::IPCResult RecvSyncTextChangeEvent(const uint64_t& aID, const nsString& aStr,
@@ -101,17 +101,17 @@ public:
   virtual mozilla::ipc::IPCResult RecvFocusEvent(const uint64_t& aID,
                                                  const LayoutDeviceIntRect& aCaretRect) override;
 #endif // defined(XP_WIN)
 
   virtual mozilla::ipc::IPCResult RecvSelectionEvent(const uint64_t& aID,
                                                      const uint64_t& aWidgetID,
                                                      const uint32_t& aType) override;
 
-  virtual mozilla::ipc::IPCResult RecvRoleChangedEvent(const uint32_t& aRole) override final;
+  virtual mozilla::ipc::IPCResult RecvRoleChangedEvent(const uint32_t& aRole) final;
 
   virtual mozilla::ipc::IPCResult RecvBindChildDoc(PDocAccessibleParent* aChildDoc, const uint64_t& aID) override;
 
   void Unbind()
   {
     if (DocAccessibleParent* parent = ParentDoc()) {
       parent->RemoveChildDoc(this);
     }

--- a/accessible/xul/XULTreeGridAccessible.h
+++ b/accessible/xul/XULTreeGridAccessible.h
@@ -86,17 +86,17 @@ public:
   virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY,
                                    EWhichChildAtPoint aWhichChild) override;
 
   virtual Accessible* GetChildAt(uint32_t aIndex) const override;
   virtual uint32_t ChildCount() const override;
 
   // XULTreeItemAccessibleBase
   virtual XULTreeGridCellAccessible* GetCellAccessible(nsITreeColumn* aColumn)
-    const override final;
+    const final;
   virtual void RowInvalidated(int32_t aStartColIdx, int32_t aEndColIdx) override;
 
 protected:
   virtual ~XULTreeGridRowAccessible();
 
   // XULTreeItemAccessibleBase
   mutable nsRefPtrHashtable<nsPtrHashKey<const void>, XULTreeGridCellAccessible>
     mAccessibleCache;

--- a/devtools/shared/heapsnapshot/HeapSnapshot.cpp
+++ b/devtools/shared/heapsnapshot/HeapSnapshot.cpp
@@ -1257,17 +1257,17 @@ public:
 
   virtual bool writeMetadata(uint64_t timestamp) final {
     protobuf::Metadata metadata;
     metadata.set_timestamp(timestamp);
     return writeMessage(metadata);
   }
 
   virtual bool writeNode(const JS::ubi::Node& ubiNode,
-                         EdgePolicy includeEdges) override final {
+                         EdgePolicy includeEdges) final {
     // NB: de-duplicated string properties must be written in the same order
     // here as they are read in `HeapSnapshot::saveNode` or else indices in
     // references to already serialized strings will be off.
 
     protobuf::Node protobufNode;
     protobufNode.set_id(ubiNode.identifier());
 
     protobufNode.set_coarsetype(JS::ubi::CoarseTypeToUint32(ubiNode.coarseType()));

--- a/dom/base/StyleSheetList.h
+++ b/dom/base/StyleSheetList.h
@@ -24,17 +24,17 @@ class StyleSheetList final : public nsSt
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(StyleSheetList)
 
   NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
 
   explicit StyleSheetList(DocumentOrShadowRoot& aScope);
 
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override final;
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
 
   nsINode* GetParentObject() const
   {
     return mDocumentOrShadowRoot ? &mDocumentOrShadowRoot->AsNode() : nullptr;
   }
 
   uint32_t Length() const
   {

--- a/dom/base/TextInputProcessor.cpp
+++ b/dom/base/TextInputProcessor.cpp
@@ -55,194 +55,194 @@ public:
     // SelectionChangeDataBase::mString still refers nsString instance owned
     // by aSelectionChangeData.  So, this needs to copy the instance.
     nsString* string = new nsString(aSelectionChangeData.String());
     mSelectionChangeData.mString = string;
   }
 
   NS_DECL_ISUPPORTS
 
-  NS_IMETHOD GetType(nsACString& aType) override final
+  NS_IMETHOD GetType(nsACString& aType) final
   {
     aType = mType;
     return NS_OK;
   }
 
   // "notify-text-change" and "notify-selection-change"
-  NS_IMETHOD GetOffset(uint32_t* aOffset) override final
+  NS_IMETHOD GetOffset(uint32_t* aOffset) final
   {
     if (NS_WARN_IF(!aOffset)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsSelectionChange()) {
       *aOffset = mSelectionChangeData.mOffset;
       return NS_OK;
     }
     if (IsTextChange()) {
       *aOffset = mTextChangeData.mStartOffset;
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   // "notify-selection-change"
-  NS_IMETHOD GetText(nsAString& aText) override final
+  NS_IMETHOD GetText(nsAString& aText) final
   {
     if (IsSelectionChange()) {
       aText = mSelectionChangeData.String();
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
-  NS_IMETHOD GetCollapsed(bool* aCollapsed) override final
+  NS_IMETHOD GetCollapsed(bool* aCollapsed) final
   {
     if (NS_WARN_IF(!aCollapsed)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsSelectionChange()) {
       *aCollapsed = mSelectionChangeData.IsCollapsed();
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
-  NS_IMETHOD GetLength(uint32_t* aLength) override final
+  NS_IMETHOD GetLength(uint32_t* aLength) final
   {
     if (NS_WARN_IF(!aLength)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsSelectionChange()) {
       *aLength = mSelectionChangeData.Length();
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
-  NS_IMETHOD GetReversed(bool* aReversed) override final
+  NS_IMETHOD GetReversed(bool* aReversed) final
   {
     if (NS_WARN_IF(!aReversed)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsSelectionChange()) {
       *aReversed = mSelectionChangeData.mReversed;
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
-  NS_IMETHOD GetWritingMode(nsACString& aWritingMode) override final
+  NS_IMETHOD GetWritingMode(nsACString& aWritingMode) final
   {
     if (IsSelectionChange()) {
       WritingMode writingMode = mSelectionChangeData.GetWritingMode();
       if (!writingMode.IsVertical()) {
         aWritingMode.AssignLiteral("horizontal-tb");
       } else if (writingMode.IsVerticalLR()) {
         aWritingMode.AssignLiteral("vertical-lr");
       } else {
         aWritingMode.AssignLiteral("vertical-rl");
       }
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
-  NS_IMETHOD GetCausedByComposition(bool* aCausedByComposition) override final
+  NS_IMETHOD GetCausedByComposition(bool* aCausedByComposition) final
   {
     if (NS_WARN_IF(!aCausedByComposition)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsSelectionChange()) {
       *aCausedByComposition = mSelectionChangeData.mCausedByComposition;
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   NS_IMETHOD GetCausedBySelectionEvent(
-               bool* aCausedBySelectionEvent) override final
+               bool* aCausedBySelectionEvent) final
   {
     if (NS_WARN_IF(!aCausedBySelectionEvent)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsSelectionChange()) {
       *aCausedBySelectionEvent = mSelectionChangeData.mCausedBySelectionEvent;
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   NS_IMETHOD GetOccurredDuringComposition(
-               bool* aOccurredDuringComposition) override final
+               bool* aOccurredDuringComposition) final
   {
     if (NS_WARN_IF(!aOccurredDuringComposition)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsSelectionChange()) {
       *aOccurredDuringComposition =
         mSelectionChangeData.mOccurredDuringComposition;
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   // "notify-text-change"
-  NS_IMETHOD GetRemovedLength(uint32_t* aLength) override final
+  NS_IMETHOD GetRemovedLength(uint32_t* aLength) final
   {
     if (NS_WARN_IF(!aLength)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsTextChange()) {
       *aLength = mTextChangeData.OldLength();
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
-  NS_IMETHOD GetAddedLength(uint32_t* aLength) override final
+  NS_IMETHOD GetAddedLength(uint32_t* aLength) final
   {
     if (NS_WARN_IF(!aLength)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsTextChange()) {
       *aLength = mTextChangeData.NewLength();
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   NS_IMETHOD GetCausedOnlyByComposition(
-               bool* aCausedOnlyByComposition) override final
+               bool* aCausedOnlyByComposition) final
   {
     if (NS_WARN_IF(!aCausedOnlyByComposition)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsTextChange()) {
       *aCausedOnlyByComposition = mTextChangeData.mCausedOnlyByComposition;
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   NS_IMETHOD GetIncludingChangesDuringComposition(
-               bool* aIncludingChangesDuringComposition) override final
+               bool* aIncludingChangesDuringComposition) final
   {
     if (NS_WARN_IF(!aIncludingChangesDuringComposition)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsTextChange()) {
       *aIncludingChangesDuringComposition =
         mTextChangeData.mIncludingChangesDuringComposition;
       return NS_OK;
     }
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   NS_IMETHOD GetIncludingChangesWithoutComposition(
-               bool* aIncludingChangesWithoutComposition) override final
+               bool* aIncludingChangesWithoutComposition) final
   {
     if (NS_WARN_IF(!aIncludingChangesWithoutComposition)) {
       return NS_ERROR_INVALID_ARG;
     }
     if (IsTextChange()) {
       *aIncludingChangesWithoutComposition =
         mTextChangeData.mIncludingChangesWithoutComposition;
       return NS_OK;

--- a/dom/base/nsContentList.h
+++ b/dom/base/nsContentList.h
@@ -167,17 +167,17 @@ public:
   {
     return nsWrapperCache::GetWrapperPreserveColor();
   }
   virtual void PreserveWrapperInternal(nsISupports* aScriptObjectHolder) override
   {
     nsWrapperCache::PreserveWrapper(aScriptObjectHolder);
   }
 
-  virtual uint32_t Length() override final
+  virtual uint32_t Length() final
   {
     return 0;
   }
   virtual nsIContent* Item(uint32_t aIndex) override;
   virtual mozilla::dom::Element* GetElementAt(uint32_t index) override;
   virtual mozilla::dom::Element*
   GetFirstNamedElement(const nsAString& aName, bool& aFound) override;
   virtual void GetSupportedNames(nsTArray<nsString>& aNames) override;
@@ -341,17 +341,17 @@ public:
   // nsBaseContentList overrides
   virtual int32_t IndexOf(nsIContent *aContent, bool aDoFlush) override;
   virtual int32_t IndexOf(nsIContent* aContent) override;
   virtual nsINode* GetParentObject() override
   {
     return mRootNode;
   }
 
-  virtual uint32_t Length() override final
+  virtual uint32_t Length() final
   {
     return Length(true);
   }
   virtual nsIContent* Item(uint32_t aIndex) override;
   virtual mozilla::dom::Element* GetElementAt(uint32_t index) override;
   virtual mozilla::dom::Element*
   GetFirstNamedElement(const nsAString& aName, bool& aFound) override
   {

--- a/dom/base/nsDOMCaretPosition.h
+++ b/dom/base/nsDOMCaretPosition.h
@@ -83,17 +83,17 @@ public:
   }
 
   nsISupports* GetParentObject() const
   {
     return GetOffsetNode();
   }
 
   virtual JSObject* WrapObject(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
-    override final;
+    final;
 
 protected:
   virtual ~nsDOMCaretPosition();
 
   uint32_t mOffset;
   nsCOMPtr<nsINode> mOffsetNode;
   nsCOMPtr<nsINode> mAnonymousContentNode;
 };

--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -10585,17 +10585,17 @@ class nsCallExitFullscreen : public Runn
 {
 public:
   explicit nsCallExitFullscreen(nsIDocument* aDoc)
     : mozilla::Runnable("nsCallExitFullscreen")
     , mDoc(aDoc)
   {
   }
 
-  NS_IMETHOD Run() override final
+  NS_IMETHOD Run() final
   {
     if (!mDoc) {
       FullscreenRoots::ForEach(&AskWindowToExitFullscreen);
     } else {
       AskWindowToExitFullscreen(mDoc);
     }
     return NS_OK;
   }

--- a/dom/base/nsGlobalWindowOuter.h
+++ b/dom/base/nsGlobalWindowOuter.h
@@ -344,19 +344,19 @@ public:
   virtual bool DispatchCustomEvent(const nsAString& aEventName) override;
   bool DispatchResizeEvent(const mozilla::CSSIntSize& aSize);
 
   // For accessing protected field mFullScreen
   friend class FullscreenTransitionTask;
 
   // Outer windows only.
   virtual nsresult SetFullscreenInternal(
-    FullscreenReason aReason, bool aIsFullscreen) override final;
-  virtual void FullscreenWillChange(bool aIsFullscreen) override final;
-  virtual void FinishFullscreenChange(bool aIsFullscreen) override final;
+    FullscreenReason aReason, bool aIsFullscreen) final;
+  virtual void FullscreenWillChange(bool aIsFullscreen) final;
+  virtual void FinishFullscreenChange(bool aIsFullscreen) final;
   bool SetWidgetFullscreen(FullscreenReason aReason, bool aIsFullscreen,
                            nsIWidget* aWidget, nsIScreen* aScreen);
   bool FullScreen() const;
 
   using EventTarget::EventListenerAdded;
   virtual void EventListenerAdded(nsAtom* aType) override;
   using EventTarget::EventListenerRemoved;
   virtual void EventListenerRemoved(nsAtom* aType) override;

--- a/dom/base/nsRange.h
+++ b/dom/base/nsRange.h
@@ -363,17 +363,17 @@ public:
   void SetStartAfter(nsINode& aNode, ErrorResult& aErr);
   void SetStartBefore(nsINode& aNode, ErrorResult& aErr);
 
   static void GetInnerTextNoFlush(mozilla::dom::DOMString& aValue,
                                   mozilla::ErrorResult& aError,
                                   nsIContent* aContainer);
 
   nsINode* GetParentObject() const { return mOwner; }
-  virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto) override final;
+  virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto) final;
   DocGroup* GetDocGroup() const;
 
 private:
   // no copy's or assigns
   nsRange(const nsRange&);
   nsRange& operator=(const nsRange&);
 
   /**

--- a/dom/crypto/WebCryptoTask.h
+++ b/dom/crypto/WebCryptoTask.h
@@ -179,18 +179,18 @@ protected:
 
   void FailWithError(nsresult aRv);
 
   virtual nsresult CalculateResult() final;
 
   virtual void CallCallback(nsresult rv) final;
 
 private:
-  NS_IMETHOD Run() override final;
-  nsresult Cancel() override final;
+  NS_IMETHOD Run() final;
+  nsresult Cancel() final;
 
   class InternalWorkerHolder;
 
   nsCOMPtr<nsISerialEventTarget> mOriginalEventTarget;
   RefPtr<InternalWorkerHolder> mWorkerHolder;
   nsresult mRv;
 };
 

--- a/dom/events/Event.h
+++ b/dom/events/Event.h
@@ -88,17 +88,17 @@ public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Event)
 
   nsIGlobalObject* GetParentObject()
   {
     return mOwner;
   }
 
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override final;
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
 
   virtual JSObject* WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto);
 
 #define GENERATED_EVENT(EventClass_) \
   virtual EventClass_* As##EventClass_()  \
   {                                       \
     return nullptr;                       \
   }

--- a/dom/html/HTMLTitleElement.h
+++ b/dom/html/HTMLTitleElement.h
@@ -49,17 +49,17 @@ public:
                               bool aNullParent = true) override;
 
   virtual void DoneAddingChildren(bool aHaveNotified) override;
 
 protected:
   virtual ~HTMLTitleElement();
 
   virtual JSObject* WrapNode(JSContext* cx, JS::Handle<JSObject*> aGivenProto)
-    override final;
+    final;
 
 private:
   void SendTitleChangeEvent(bool aBound);
 };
 
 } // namespace dom
 } // namespace mozilla
 

--- a/dom/media/ChannelMediaDecoder.h
+++ b/dom/media/ChannelMediaDecoder.h
@@ -113,17 +113,17 @@ private:
   // Called on the main thread only. aStatus is the result from OnStopRequest.
   void NotifyDownloadEnded(nsresult aStatus);
 
   // Called by the MediaResource to keep track of the number of bytes read
   // from the resource. Called on the main by an event runner dispatched
   // by the MediaResource read functions.
   void NotifyBytesConsumed(int64_t aBytes, int64_t aOffset);
 
-  bool CanPlayThroughImpl() override final;
+  bool CanPlayThroughImpl() final;
 
   struct PlaybackRateInfo
   {
     uint32_t mRate; // Estimate of the current playback rate (bytes/second).
     bool mReliable; // True if mRate is a reliable estimate.
   };
   // The actual playback rate computation.
   static PlaybackRateInfo ComputePlaybackRate(

--- a/dom/media/GraphDriver.h
+++ b/dom/media/GraphDriver.h
@@ -582,17 +582,17 @@ public:
     }
     return threadPool->Dispatch(this, aFlags);
   }
 
 protected:
   virtual ~AsyncCubebTask();
 
 private:
-  NS_IMETHOD Run() override final;
+  NS_IMETHOD Run() final;
 
   RefPtr<AudioCallbackDriver> mDriver;
   AsyncCubebOperation mOperation;
   RefPtr<MediaStreamGraphImpl> mShutdownGrip;
 };
 
 } // namespace mozilla
 

--- a/dom/media/hls/HLSDecoder.h
+++ b/dom/media/hls/HLSDecoder.h
@@ -44,17 +44,17 @@ public:
   // Called as data arrives on the underlying HLS player. Main thread only.
   void NotifyDataArrived();
 
 private:
   friend class HLSResourceCallbacksSupport;
 
   MediaDecoderStateMachine* CreateStateMachine();
 
-  bool CanPlayThroughImpl() override final
+  bool CanPlayThroughImpl() final
   {
     // TODO: We don't know how to estimate 'canplaythrough' for this decoder.
     // For now we just return true for 'autoplay' can work.
     return true;
   }
 
   nsCOMPtr<nsIChannel> mChannel;
   nsCOMPtr<nsIURI> mURI;

--- a/dom/svg/SVGAnimatedEnumeration.h
+++ b/dom/svg/SVGAnimatedEnumeration.h
@@ -22,17 +22,17 @@ public:
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(SVGAnimatedEnumeration)
 
   nsSVGElement* GetParentObject() const
   {
     return mSVGElement;
   }
 
   virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
-    override final;
+    final;
 
   virtual uint16_t BaseVal() = 0;
   virtual void SetBaseVal(uint16_t aBaseVal, ErrorResult& aRv) = 0;
   virtual uint16_t AnimVal() = 0;
 
 protected:
   explicit SVGAnimatedEnumeration(nsSVGElement* aSVGElement)
     : mSVGElement(aSVGElement)

--- a/dom/svg/SVGAnimatedInteger.h
+++ b/dom/svg/SVGAnimatedInteger.h
@@ -22,17 +22,17 @@ public:
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(SVGAnimatedInteger)
 
   nsSVGElement* GetParentObject() const
   {
     return mSVGElement;
   }
 
   virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
-    override final;
+    final;
 
   virtual int32_t BaseVal() = 0;
   virtual void SetBaseVal(int32_t aBaseVal) = 0;
   virtual int32_t AnimVal() = 0;
 
 protected:
   explicit SVGAnimatedInteger(nsSVGElement* aSVGElement)
     : mSVGElement(aSVGElement)

--- a/dom/svg/SVGAnimatedNumber.h
+++ b/dom/svg/SVGAnimatedNumber.h
@@ -23,17 +23,17 @@ public:
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(SVGAnimatedNumber)
 
   nsSVGElement* GetParentObject() const
   {
     return mSVGElement;
   }
 
   virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
-    override final;
+    final;
 
   virtual float BaseVal() = 0;
   virtual void SetBaseVal(float aBaseVal) = 0;
   virtual float AnimVal() = 0;
 
 protected:
   explicit SVGAnimatedNumber(nsSVGElement* aSVGElement)
     : mSVGElement(aSVGElement)

--- a/dom/svg/SVGGeometryElement.h
+++ b/dom/svg/SVGGeometryElement.h
@@ -56,17 +56,17 @@ public:
                                 const nsAttrValue* aOldValue,
                                 nsIPrincipal* aSubjectPrincipal,
                                 bool aNotify) override;
 
   /**
    * Causes this element to discard any Path object that GetOrBuildPath may
    * have cached.
    */
-  virtual void ClearAnyCachedPath() override final {
+  virtual void ClearAnyCachedPath() final {
     mCachedPath = nullptr;
   }
 
   virtual bool AttributeDefinesGeometry(const nsAtom *aName);
 
   /**
    * Returns true if this element's geometry depends on the width or height of its
    * coordinate context (typically the viewport established by its nearest <svg>

--- a/dom/svg/SVGRect.h
+++ b/dom/svg/SVGRect.h
@@ -22,47 +22,47 @@ class SVGRect final : public SVGIRect
 public:
   explicit SVGRect(nsIContent* aParent, float x=0.0f, float y=0.0f, float w=0.0f,
                    float h=0.0f);
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(SVGRect)
 
   // WebIDL
-  virtual float X() const override final
+  virtual float X() const final
   {
     return mX;
   }
 
   virtual void SetX(float aX, ErrorResult& aRv) final
   {
     mX = aX;
   }
 
-  virtual float Y() const override final
+  virtual float Y() const final
   {
     return mY;
   }
 
   virtual void SetY(float aY, ErrorResult& aRv) final
   {
     mY = aY;
   }
 
-  virtual float Width() const override final
+  virtual float Width() const final
   {
     return mWidth;
   }
 
   virtual void SetWidth(float aWidth, ErrorResult& aRv) final
   {
     mWidth = aWidth;
   }
 
-  virtual float Height() const override final
+  virtual float Height() const final
   {
     return mHeight;
   }
 
   virtual void SetHeight(float aHeight, ErrorResult& aRv) final
   {
     mHeight = aHeight;
   }

--- a/dom/svg/nsSVGElement.h
+++ b/dom/svg/nsSVGElement.h
@@ -335,17 +335,17 @@ protected:
 
   // We define BeforeSetAttr here and mark it final to ensure it is NOT used
   // by SVG elements.
   // This is because we're not currently passing the correct value for aValue to
   // BeforeSetAttr since it would involve allocating extra SVG value types.
   // See the comment in nsSVGElement::WillChangeValue.
   virtual nsresult BeforeSetAttr(int32_t aNamespaceID, nsAtom* aName,
                                  const nsAttrValueOrString* aValue,
-                                 bool aNotify) override final;
+                                 bool aNotify) final;
   virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
                                 const nsAttrValue* aValue,
                                 const nsAttrValue* aOldValue,
                                 nsIPrincipal* aSubjectPrincipal,
                                 bool aNotify) override;
   virtual bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
                                 const nsAString& aValue,
                                 nsIPrincipal* aMaybeScriptedPrincipal,

--- a/dom/svg/nsSVGViewBox.h
+++ b/dom/svg/nsSVGViewBox.h
@@ -110,32 +110,32 @@ public:
       : mozilla::dom::SVGIRect()
       , mVal(aVal)
       , mSVGElement(aSVGElement)
     {}
 
     nsSVGViewBox* mVal; // kept alive because it belongs to content
     RefPtr<nsSVGElement> mSVGElement;
 
-    float X() const override final
+    float X() const final
     {
       return mVal->GetBaseValue().x;
     }
 
-    float Y() const override final
+    float Y() const final
     {
       return mVal->GetBaseValue().y;
     }
 
-    float Width() const override final
+    float Width() const final
     {
       return mVal->GetBaseValue().width;
     }
 
-    float Height() const override final
+    float Height() const final
     {
       return mVal->GetBaseValue().height;
     }
 
     void SetX(float aX, mozilla::ErrorResult& aRv) final;
     void SetY(float aY, mozilla::ErrorResult& aRv) final;
     void SetWidth(float aWidth, mozilla::ErrorResult& aRv) final;
     void SetHeight(float aHeight, mozilla::ErrorResult& aRv) final;
@@ -160,35 +160,35 @@ public:
       , mSVGElement(aSVGElement)
     {}
 
     nsSVGViewBox* mVal; // kept alive because it belongs to content
     RefPtr<nsSVGElement> mSVGElement;
 
     // Script may have modified animation parameters or timeline -- DOM getters
     // need to flush any resample requests to reflect these modifications.
-    float X() const override final
+    float X() const final
     {
       mSVGElement->FlushAnimations();
       return mVal->GetAnimValue().x;
     }
 
-    float Y() const override final
+    float Y() const final
     {
       mSVGElement->FlushAnimations();
       return mVal->GetAnimValue().y;
     }
 
-    float Width() const override final
+    float Width() const final
     {
       mSVGElement->FlushAnimations();
       return mVal->GetAnimValue().width;
     }
 
-    float Height() const override final
+    float Height() const final
     {
       mSVGElement->FlushAnimations();
       return mVal->GetAnimValue().height;
     }
 
     void SetX(float aX, mozilla::ErrorResult& aRv) final
     {
       aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);

--- a/dom/workers/WorkerRunnable.h
+++ b/dom/workers/WorkerRunnable.h
@@ -195,17 +195,17 @@ protected:
 private:
   virtual bool
   IsDebuggerRunnable() const override
   {
     return true;
   }
 
   virtual bool
-  PreDispatch(WorkerPrivate* aWorkerPrivate) override final
+  PreDispatch(WorkerPrivate* aWorkerPrivate) final
   {
     AssertIsOnMainThread();
 
     return true;
   }
 
   virtual void
   PostDispatch(WorkerPrivate* aWorkerPrivate,
@@ -478,29 +478,29 @@ public:
   Cancel() override;
 
 protected:
   virtual ~MainThreadStopSyncLoopRunnable()
   { }
 
 private:
   virtual bool
-  PreDispatch(WorkerPrivate* aWorkerPrivate) override final
+  PreDispatch(WorkerPrivate* aWorkerPrivate) final
   {
     AssertIsOnMainThread();
     return true;
   }
 
   virtual void
   PostDispatch(WorkerPrivate* aWorkerPrivate,
                bool aDispatchResult) override;
 
   virtual bool
   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override;
 
   virtual bool
-  DispatchInternal() override final;
+  DispatchInternal() final;
 };
 
 } // dom namespace
 } // mozilla namespace
 
 #endif // mozilla_dom_workers_workerrunnable_h__

--- a/dom/xhr/XMLHttpRequestWorker.cpp
+++ b/dom/xhr/XMLHttpRequestWorker.cpp
@@ -531,17 +531,17 @@ public:
     mScopeObj(RootingCx(), aScopeObj)
   { }
 
 private:
   ~EventRunnable()
   { }
 
   virtual bool
-  PreDispatch(WorkerPrivate* /* unused */) override final;
+  PreDispatch(WorkerPrivate* /* unused */) final;
 
   virtual bool
   WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override;
 };
 
 class SyncTeardownRunnable final : public WorkerThreadProxySyncRunnable
 {
 public:

--- a/editor/composer/nsComposerCommands.h
+++ b/editor/composer/nsComposerCommands.h
@@ -86,20 +86,20 @@ class nsStyleUpdatingCommand final : pub
 {
 public:
   explicit nsStyleUpdatingCommand(nsAtom* aTagName);
 
 protected:
 
   // get the current state (on or off) for this style or block format
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
 
   // add/remove the style
-  virtual nsresult ToggleState(mozilla::HTMLEditor* aHTMLEditor) override final;
+  virtual nsresult ToggleState(mozilla::HTMLEditor* aHTMLEditor) final;
 };
 
 
 class nsInsertTagCommand : public nsBaseComposerCommand
 {
 public:
   explicit nsInsertTagCommand(nsAtom* aTagName);
 
@@ -118,35 +118,35 @@ class nsListCommand final : public nsBas
 {
 public:
   explicit nsListCommand(nsAtom* aTagName);
 
 protected:
 
   // get the current state (on or off) for this style or block format
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
 
   // add/remove the style
-  virtual nsresult ToggleState(mozilla::HTMLEditor* aHTMLEditor) override final;
+  virtual nsresult ToggleState(mozilla::HTMLEditor* aHTMLEditor) final;
 };
 
 class nsListItemCommand final : public nsBaseStateUpdatingCommand
 {
 public:
   explicit nsListItemCommand(nsAtom* aTagName);
 
 protected:
 
   // get the current state (on or off) for this style or block format
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
 
   // add/remove the style
-  virtual nsresult ToggleState(mozilla::HTMLEditor* aHTMLEditor) override final;
+  virtual nsresult ToggleState(mozilla::HTMLEditor* aHTMLEditor) final;
 };
 
 // Base class for commands whose state consists of a string (e.g. para format)
 class nsMultiStateCommand : public nsBaseComposerCommand
 {
 public:
 
   nsMultiStateCommand();
@@ -168,116 +168,116 @@ protected:
 class nsParagraphStateCommand final : public nsMultiStateCommand
 {
 public:
                    nsParagraphStateCommand();
 
 protected:
 
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
   virtual nsresult SetState(mozilla::HTMLEditor* aHTMLEditor,
-                            nsString& newState) override final;
+                            nsString& newState) final;
 };
 
 class nsFontFaceStateCommand final : public nsMultiStateCommand
 {
 public:
                    nsFontFaceStateCommand();
 
 protected:
 
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
   virtual nsresult SetState(mozilla::HTMLEditor* aHTMLEditor,
-                            nsString& newState) override final;
+                            nsString& newState) final;
 };
 
 class nsFontSizeStateCommand final : public nsMultiStateCommand
 {
 public:
                    nsFontSizeStateCommand();
 
 protected:
 
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
   virtual nsresult SetState(mozilla::HTMLEditor* aHTMLEditor,
-                            nsString& newState) override final;
+                            nsString& newState) final;
 };
 
 class nsHighlightColorStateCommand final : public nsMultiStateCommand
 {
 public:
                    nsHighlightColorStateCommand();
 
 protected:
 
   NS_IMETHOD IsCommandEnabled(const char* aCommandName,
                               nsISupports* aCommandRefCon,
-                              bool* _retval) override final;
+                              bool* _retval) final;
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
   virtual nsresult SetState(mozilla::HTMLEditor* aHTMLEditor,
-                            nsString& newState) override final;
+                            nsString& newState) final;
 
 };
 
 class nsFontColorStateCommand final : public nsMultiStateCommand
 {
 public:
                    nsFontColorStateCommand();
 
 protected:
 
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
   virtual nsresult SetState(mozilla::HTMLEditor* aHTMLEditor,
-                            nsString& newState) override final;
+                            nsString& newState) final;
 };
 
 class nsAlignCommand final : public nsMultiStateCommand
 {
 public:
                    nsAlignCommand();
 
 protected:
 
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
   virtual nsresult SetState(mozilla::HTMLEditor* aHTMLEditor,
-                            nsString& newState) override final;
+                            nsString& newState) final;
 };
 
 class nsBackgroundColorStateCommand final : public nsMultiStateCommand
 {
 public:
                    nsBackgroundColorStateCommand();
 
 protected:
 
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
+                                   nsICommandParams* aParams) final;
   virtual nsresult SetState(mozilla::HTMLEditor* aHTMLEditor,
-                            nsString& newState) override final;
+                            nsString& newState) final;
 };
 
 class nsAbsolutePositioningCommand final : public nsBaseStateUpdatingCommand
 {
 public:
   nsAbsolutePositioningCommand();
 
 protected:
 
   NS_IMETHOD IsCommandEnabled(const char* aCommandName,
                               nsISupports* aCommandRefCon,
-                              bool* _retval) override final;
+                              bool* _retval) final;
   virtual nsresult GetCurrentState(mozilla::HTMLEditor* aHTMLEditor,
-                                   nsICommandParams* aParams) override final;
-  virtual nsresult ToggleState(mozilla::HTMLEditor* aHTMLEditor) override final;
+                                   nsICommandParams* aParams) final;
+  virtual nsresult ToggleState(mozilla::HTMLEditor* aHTMLEditor) final;
 };
 
 // composer commands
 
 NS_DECL_COMPOSER_COMMAND(nsCloseCommand)
 NS_DECL_COMPOSER_COMMAND(nsDocumentStateCommand)
 NS_DECL_COMPOSER_COMMAND(nsSetDocumentStateCommand)
 NS_DECL_COMPOSER_COMMAND(nsSetDocumentOptionsCommand)

--- a/gfx/2d/InlineTranslator.h
+++ b/gfx/2d/InlineTranslator.h
@@ -71,24 +71,24 @@ public:
 
   ScaledFont* LookupScaledFont(ReferencePtr aRefPtr) final
   {
     ScaledFont* result = mScaledFonts.GetWeak(aRefPtr);
     MOZ_ASSERT(result);
     return result;
   }
 
-  UnscaledFont* LookupUnscaledFont(ReferencePtr aRefPtr) override final
+  UnscaledFont* LookupUnscaledFont(ReferencePtr aRefPtr) final
   {
     UnscaledFont* result = mUnscaledFonts.GetWeak(aRefPtr);
     MOZ_ASSERT(result);
     return result;
   }
 
-  virtual UnscaledFont* LookupUnscaledFontByIndex(size_t index) override final
+  virtual UnscaledFont* LookupUnscaledFontByIndex(size_t index) final
   {
     UnscaledFont* result = mUnscaledFontTable[index];
     return result;
   }
 
   NativeFontResource* LookupNativeFontResource(uint64_t aKey) final
   {
     NativeFontResource* result = mNativeFontResources.GetWeak(aKey);

--- a/gfx/thebes/PrintTargetSkPDF.h
+++ b/gfx/thebes/PrintTargetSkPDF.h
@@ -39,17 +39,17 @@ public:
   virtual nsresult BeginPage() override;
   virtual nsresult EndPage() override;
 
   virtual already_AddRefed<DrawTarget>
   MakeDrawTarget(const IntSize& aSize,
                  DrawEventRecorder* aRecorder = nullptr) final;
 
   virtual already_AddRefed<DrawTarget>
-  GetReferenceDrawTarget() override final;
+  GetReferenceDrawTarget() final;
 
 private:
   PrintTargetSkPDF(const IntSize& aSize,
                    UniquePtr<SkWStream> aStream);
   virtual ~PrintTargetSkPDF();
 
   // Do not hand out references to this object.  It holds a non-owning
   // reference to mOStreame, so must not outlive mOStream.

--- a/image/Image.h
+++ b/image/Image.h
@@ -244,17 +244,17 @@ public:
   already_AddRefed<ProgressTracker> GetProgressTracker() override
   {
     RefPtr<ProgressTracker> progressTracker = mProgressTracker;
     MOZ_ASSERT(progressTracker);
     return progressTracker.forget();
   }
 
   void SetProgressTracker(
-                       ProgressTracker* aProgressTracker) override final
+                       ProgressTracker* aProgressTracker) final
   {
     MOZ_ASSERT(aProgressTracker);
     MOZ_ASSERT(!mProgressTracker);
     mProgressTracker = aProgressTracker;
   }
 
   virtual void IncrementAnimationConsumers() override;
   virtual void DecrementAnimationConsumers() override;

--- a/image/SurfacePipe.h
+++ b/image/SurfacePipe.h
@@ -652,21 +652,21 @@ class AbstractSurfaceSink : public Surfa
 public:
   AbstractSurfaceSink()
     : mImageData(nullptr)
     , mImageDataLength(0)
     , mRow(0)
     , mFlipVertically(false)
   { }
 
-  Maybe<SurfaceInvalidRect> TakeInvalidRect() override final;
+  Maybe<SurfaceInvalidRect> TakeInvalidRect() final;
 
 protected:
-  uint8_t* DoResetToFirstRow() override final;
-  uint8_t* DoAdvanceRow() override final;
+  uint8_t* DoResetToFirstRow() final;
+  uint8_t* DoAdvanceRow() final;
   virtual uint8_t* GetRowPointer() const = 0;
 
   gfx::IntRect mInvalidRect;  /// The region of the surface that has been written
                               /// to since the last call to TakeInvalidRect().
   uint8_t*  mImageData;       /// A pointer to the beginning of the surface data.
   uint32_t  mImageDataLength; /// The length of the surface data.
   uint32_t  mRow;             /// The row to which we're writing. (0-indexed)
   bool      mFlipVertically;  /// If true, write the rows from top to bottom.

--- a/js/src/builtin/Promise.h
+++ b/js/src/builtin/Promise.h
@@ -190,17 +190,17 @@ class OffThreadPromiseTask : public JS::
 
   protected:
     OffThreadPromiseTask(JSContext* cx, Handle<PromiseObject*> promise);
 
     // To be called by OffThreadPromiseTask and implemented by the derived class.
     virtual bool resolve(JSContext* cx, Handle<PromiseObject*> promise) = 0;
 
     // JS::Dispatchable implementation. Ends with 'delete this'.
-    void run(JSContext* cx, MaybeShuttingDown maybeShuttingDown) override final;
+    void run(JSContext* cx, MaybeShuttingDown maybeShuttingDown) final;
 
   public:
     ~OffThreadPromiseTask() override;
 
     // Initializing an OffThreadPromiseTask informs the runtime that it must
     // wait on shutdown for this task to rejoin the active JSContext by calling
     // dispatchResolveAndDestroy().
     bool init(JSContext* cx);

--- a/js/src/frontend/TokenStream.h
+++ b/js/src/frontend/TokenStream.h
@@ -769,29 +769,29 @@ class TokenStreamAnyChars
                                      unsigned flags, unsigned errorNumber, va_list args);
 
     // Compute error metadata for an error at no offset.
     void computeErrorMetadataNoOffset(ErrorMetadata* err);
 
   public:
     // ErrorReporter API.
 
-    virtual const JS::ReadOnlyCompileOptions& options() const override final {
+    virtual const JS::ReadOnlyCompileOptions& options() const final {
         return options_;
     }
 
     virtual void
-    lineAndColumnAt(size_t offset, uint32_t* line, uint32_t* column) const override final;
+    lineAndColumnAt(size_t offset, uint32_t* line, uint32_t* column) const final;
 
-    virtual void currentLineAndColumn(uint32_t* line, uint32_t* column) const override final;
+    virtual void currentLineAndColumn(uint32_t* line, uint32_t* column) const final;
 
-    virtual bool hasTokenizationStarted() const override final;
-    virtual void reportErrorNoOffsetVA(unsigned errorNumber, va_list args) override final;
+    virtual bool hasTokenizationStarted() const final;
+    virtual void reportErrorNoOffsetVA(unsigned errorNumber, va_list args) final;
 
-    virtual const char* getFilename() const override final {
+    virtual const char* getFilename() const final {
         return filename_;
     }
 
   protected:
     // Options used for parsing/tokenizing.
     const ReadOnlyCompileOptions& options_;
 
     Token               tokens[ntokens];    // circular token buffer

--- a/layout/style/CSSRuleList.h
+++ b/layout/style/CSSRuleList.h
@@ -17,17 +17,17 @@ namespace dom {
 class CSSRuleList : public nsISupports
                   , public nsWrapperCache
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(CSSRuleList)
 
   virtual StyleSheet* GetParentObject() = 0;
-  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override final;
+  virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
 
   // WebIDL API
   css::Rule* Item(uint32_t aIndex)
   {
     bool unused;
     return IndexedGetter(aIndex, unused);
   }
 

--- a/layout/style/nsDOMCSSRGBColor.h
+++ b/layout/style/nsDOMCSSRGBColor.h
@@ -48,17 +48,17 @@ public:
   }
 
   nsISupports* GetParentObject() const
   {
     return nullptr;
   }
 
   virtual JSObject *WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto)
-    override final;
+    final;
 
 private:
   virtual ~nsDOMCSSRGBColor(void);
 
   RefPtr<nsROCSSPrimitiveValue> mRed;
   RefPtr<nsROCSSPrimitiveValue> mGreen;
   RefPtr<nsROCSSPrimitiveValue> mBlue;
   RefPtr<nsROCSSPrimitiveValue> mAlpha;

--- a/layout/style/nsDOMCSSRect.h
+++ b/layout/style/nsDOMCSSRect.h
@@ -30,17 +30,17 @@ public:
   nsROCSSPrimitiveValue* Top() const { return mTop; }
   nsROCSSPrimitiveValue* Right() const { return mRight; }
   nsROCSSPrimitiveValue* Bottom() const { return mBottom; }
   nsROCSSPrimitiveValue* Left() const { return mLeft; }
 
   nsISupports* GetParentObject() const { return nullptr; }
 
   virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto)
-    override final;
+    final;
 
 protected:
   virtual ~nsDOMCSSRect(void);
 
 private:
   RefPtr<nsROCSSPrimitiveValue> mTop;
   RefPtr<nsROCSSPrimitiveValue> mRight;
   RefPtr<nsROCSSPrimitiveValue> mBottom;

--- a/layout/style/nsDOMCSSValueList.h
+++ b/layout/style/nsDOMCSSValueList.h
@@ -22,20 +22,20 @@ public:
   nsDOMCSSValueList(bool aCommaDelimited, bool aReadonly);
 
   /**
    * Adds a value to this list.
    */
   void AppendCSSValue(already_AddRefed<CSSValue> aValue);
 
   virtual void GetCssText(nsString& aText, mozilla::ErrorResult& aRv)
-    override final;
+    final;
   virtual void SetCssText(const nsAString& aText,
-                          mozilla::ErrorResult& aRv) override final;
-  virtual uint16_t CssValueType() const override final;
+                          mozilla::ErrorResult& aRv) final;
+  virtual uint16_t CssValueType() const final;
 
   void GetCssText(nsAString& aText);
 
   CSSValue* IndexedGetter(uint32_t aIdx, bool& aFound) const
   {
     aFound = aIdx <= Length();
     return Item(aIdx);
   }

--- a/layout/style/nsROCSSPrimitiveValue.h
+++ b/layout/style/nsROCSSPrimitiveValue.h
@@ -27,19 +27,19 @@ class nsDOMCSSRGBColor;
  */
 class nsROCSSPrimitiveValue final : public mozilla::dom::CSSValue
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsROCSSPrimitiveValue)
 
   // CSSValue
-  virtual void GetCssText(nsString& aText, mozilla::ErrorResult& aRv) override final;
-  virtual void SetCssText(const nsAString& aText, mozilla::ErrorResult& aRv) override final;
-  virtual uint16_t CssValueType() const override final;
+  virtual void GetCssText(nsString& aText, mozilla::ErrorResult& aRv) final;
+  virtual void SetCssText(const nsAString& aText, mozilla::ErrorResult& aRv) final;
+  virtual uint16_t CssValueType() const final;
 
   // CSSPrimitiveValue
   uint16_t PrimitiveType();
   void SetFloatValue(uint16_t aUnitType, float aValue,
                      mozilla::ErrorResult& aRv);
   float GetFloatValue(uint16_t aUnitType, mozilla::ErrorResult& aRv);
   void GetStringValue(nsString& aString, mozilla::ErrorResult& aRv);
   void SetStringValue(uint16_t aUnitType, const nsAString& aString,

--- a/mozglue/build/WindowsDllServices.h
+++ b/mozglue/build/WindowsDllServices.h
@@ -37,17 +37,17 @@ public:
    */
   virtual void DispatchDllLoadNotification(PCUNICODE_STRING aDllName) = 0;
 
   void SetAuthenticodeImpl(Authenticode* aAuthenticode)
   {
     mAuthenticode = aAuthenticode;
   }
 
-  virtual UniquePtr<wchar_t[]> GetBinaryOrgName(const wchar_t* aFilePath) override final
+  virtual UniquePtr<wchar_t[]> GetBinaryOrgName(const wchar_t* aFilePath) final
   {
     if (!mAuthenticode) {
       return nullptr;
     }
 
     return mAuthenticode->GetBinaryOrgName(aFilePath);
   }
 
@@ -80,17 +80,17 @@ private:
 
 } // namespace detail
 
 #if defined(MOZILLA_INTERNAL_API)
 
 class DllServices : public detail::DllServicesBase
 {
 public:
-  virtual void DispatchDllLoadNotification(PCUNICODE_STRING aDllName) override final
+  virtual void DispatchDllLoadNotification(PCUNICODE_STRING aDllName) final
   {
     nsDependentSubstring strDllName(aDllName->Buffer,
                                     aDllName->Length / sizeof(wchar_t));
 
     nsCOMPtr<nsIRunnable> runnable(
       NewRunnableMethod<bool, nsString>("DllServices::NotifyDllLoad",
                                         this, &DllServices::NotifyDllLoad,
                                         NS_IsMainThread(), strDllName));

--- a/netwerk/base/nsSocketTransport2.h
+++ b/netwerk/base/nsSocketTransport2.h
@@ -151,17 +151,17 @@ public:
     // unlayered, simple, stream sockets.
     nsresult InitWithFilename(const char *filename);
 #endif
 
     // nsASocketHandler methods:
     void OnSocketReady(PRFileDesc *, int16_t outFlags) override;
     void OnSocketDetached(PRFileDesc *) override;
     void IsLocal(bool *aIsLocal) override;
-    void OnKeepaliveEnabledPrefChange(bool aEnabled) override final;
+    void OnKeepaliveEnabledPrefChange(bool aEnabled) final;
 
     // called when a socket event is handled
     void OnSocketEvent(uint32_t type, nsresult status, nsISupports *param);
 
     uint64_t ByteCountReceived() override { return mInput.ByteCount(); }
     uint64_t ByteCountSent() override { return mOutput.ByteCount(); }
     static void CloseSocket(PRFileDesc *aFd, bool aTelemetryEnabled);
     static void SendPRBlockingTelemetry(PRIntervalTime aStart,

--- a/netwerk/protocol/http/ASpdySession.h
+++ b/netwerk/protocol/http/ASpdySession.h
@@ -41,17 +41,17 @@ public:
   // or it might just need to wait longer for one of them to become free.
   //
   // return true if the session takes back ownership of the transaction from
   // the connection manager.
   virtual bool MaybeReTunnel(nsAHttpTransaction *) = 0;
 
   virtual void PrintDiagnostics (nsCString &log) = 0;
 
-  bool ResponseTimeoutEnabled() const override final {
+  bool ResponseTimeoutEnabled() const final {
     return true;
   }
 
   virtual void SendPing() = 0;
 
   const static uint32_t kSendingChunkSize = 4095;
   const static uint32_t kTCPSendBufferSize = 131072;
 

--- a/netwerk/protocol/http/Http2Session.h
+++ b/netwerk/protocol/http/Http2Session.h
@@ -245,21 +245,21 @@ public:
   void DecrementServerSessionWindow (uint32_t bytes) { mServerSessionWindow -= bytes; }
   uint32_t InitialRwin() { return mInitialRwin; }
 
   void SendPing() override;
   MOZ_MUST_USE bool MaybeReTunnel(nsAHttpTransaction *) override;
   bool UseH2Deps() { return mUseH2Deps; }
 
   // overload of nsAHttpTransaction
-  MOZ_MUST_USE nsresult ReadSegmentsAgain(nsAHttpSegmentReader *, uint32_t, uint32_t *, bool *) override final;
-  MOZ_MUST_USE nsresult WriteSegmentsAgain(nsAHttpSegmentWriter *, uint32_t , uint32_t *, bool *) override final;
-  MOZ_MUST_USE bool Do0RTT() override final { return true; }
-  MOZ_MUST_USE nsresult Finish0RTT(bool aRestart, bool aAlpnChanged) override final;
-  void SetFastOpenStatus(uint8_t aStatus) override final;
+  MOZ_MUST_USE nsresult ReadSegmentsAgain(nsAHttpSegmentReader *, uint32_t, uint32_t *, bool *) final;
+  MOZ_MUST_USE nsresult WriteSegmentsAgain(nsAHttpSegmentWriter *, uint32_t , uint32_t *, bool *) final;
+  MOZ_MUST_USE bool Do0RTT() final { return true; }
+  MOZ_MUST_USE nsresult Finish0RTT(bool aRestart, bool aAlpnChanged) final;
+  void SetFastOpenStatus(uint8_t aStatus) final;
 
   // For use by an HTTP2Stream
   void Received421(nsHttpConnectionInfo *ci);
 
   void SendPriorityFrame(uint32_t streamID, uint32_t dependsOn, uint8_t weight);
 
 private:
 

--- a/netwerk/protocol/http/NullHttpTransaction.h
+++ b/netwerk/protocol/http/NullHttpTransaction.h
@@ -38,20 +38,20 @@ public:
   NullHttpTransaction(nsHttpConnectionInfo *ci,
                       nsIInterfaceRequestor *callbacks,
                       uint32_t caps);
 
   MOZ_MUST_USE bool Claim();
   void Unclaim();
 
   // Overload of nsAHttpTransaction methods
-  bool IsNullTransaction() override final { return true; }
-  NullHttpTransaction *QueryNullTransaction() override final { return this; }
-  bool ResponseTimeoutEnabled() const override final {return true; }
-  PRIntervalTime ResponseTimeout() override final
+  bool IsNullTransaction() final { return true; }
+  NullHttpTransaction *QueryNullTransaction() final { return this; }
+  bool ResponseTimeoutEnabled() const final {return true; }
+  PRIntervalTime ResponseTimeout() final
   {
     return PR_SecondsToInterval(15);
   }
 
   // We have to override this function because |mTransaction| in nsHalfOpenSocket
   // could be either nsHttpTransaction or NullHttpTransaction.
   // NullHttpTransaction will be activated on the connection immediately after
   // creation and be never put in a pending queue, so it's OK to just return 0.

--- a/netwerk/protocol/http/TunnelUtils.h
+++ b/netwerk/protocol/http/TunnelUtils.h
@@ -195,22 +195,22 @@ public:
   // A transaction is forced into plaintext when it is intended to be used as a CONNECT
   // tunnel but the setup fails. The plaintext only carries the CONNECT error.
   void ForcePlainText();
   void MapStreamToHttpConnection(nsISocketTransport *aTransport,
                                  nsHttpConnectionInfo *aConnInfo);
 
   MOZ_MUST_USE nsresult ReadSegments(nsAHttpSegmentReader *reader,
                                      uint32_t count,
-                                     uint32_t *countRead) override final;
+                                     uint32_t *countRead) final;
   MOZ_MUST_USE nsresult WriteSegments(nsAHttpSegmentWriter *writer,
                                       uint32_t count,
-                                      uint32_t *countWritten) override final;
-  nsHttpRequestHead *RequestHead() override final;
-  void Close(nsresult reason) override final;
+                                      uint32_t *countWritten) final;
+  nsHttpRequestHead *RequestHead() final;
+  void Close(nsresult reason) final;
 
   // ConnectedReadyForInput() tests whether the spdy connect transaction is attached to
   // an nsHttpConnection that can properly deal with flow control, etc..
   bool ConnectedReadyForInput();
 
 private:
   friend class InputStreamShim;
   friend class OutputStreamShim;

--- a/security/manager/ssl/CryptoTask.h
+++ b/security/manager/ssl/CryptoTask.h
@@ -50,17 +50,17 @@ protected:
   virtual nsresult CalculateResult() = 0;
 
   /**
    * Called on the main thread with the result from CalculateResult().
    */
   virtual void CallCallback(nsresult rv) = 0;
 
 private:
-  NS_IMETHOD Run() override final;
+  NS_IMETHOD Run() final;
 
   nsresult mRv;
   nsCOMPtr<nsIThread> mThread;
 };
 
 } // namespace mozilla
 
 #endif // mozilla__CryptoTask_h

--- a/widget/cocoa/nsCocoaWindow.h
+++ b/widget/cocoa/nsCocoaWindow.h
@@ -253,19 +253,19 @@ public:
     void WillEnterFullScreen(bool aFullScreen);
     void EnteredFullScreen(bool aFullScreen, bool aNativeMode = true);
     virtual bool PrepareForFullscreenTransition(nsISupports** aData) override;
     virtual void PerformFullscreenTransition(FullscreenTransitionStage aStage,
                                              uint16_t aDuration,
                                              nsISupports* aData,
                                              nsIRunnable* aCallback) override;
     virtual nsresult MakeFullScreen(
-      bool aFullScreen, nsIScreen* aTargetScreen = nullptr) override final;
+      bool aFullScreen, nsIScreen* aTargetScreen = nullptr) final;
     virtual nsresult MakeFullScreenWithNativeTransition(
-      bool aFullScreen, nsIScreen* aTargetScreen = nullptr) override final;
+      bool aFullScreen, nsIScreen* aTargetScreen = nullptr) final;
     NSAnimation* FullscreenTransitionAnimation() const { return mFullscreenTransitionAnimation; }
     void ReleaseFullscreenTransitionAnimation()
     {
       MOZ_ASSERT(mFullscreenTransitionAnimation,
                  "Should only be called when there is animation");
       [mFullscreenTransitionAnimation release];
       mFullscreenTransitionAnimation = nil;
     }

--- a/widget/nsBaseWidget.h
+++ b/widget/nsBaseWidget.h
@@ -266,17 +266,17 @@ public:
                                           int32_t aVertical) override
                           { return NS_ERROR_NOT_IMPLEMENTED; }
   virtual MOZ_MUST_USE nsresult
                           BeginMoveDrag(mozilla::WidgetMouseEvent* aEvent) override
                           { return NS_ERROR_NOT_IMPLEMENTED; }
   virtual nsresult        ActivateNativeMenuItemAt(const nsAString& indexString) override { return NS_ERROR_NOT_IMPLEMENTED; }
   virtual nsresult        ForceUpdateNativeMenuAt(const nsAString& indexString) override { return NS_ERROR_NOT_IMPLEMENTED; }
   virtual nsresult        NotifyIME(const IMENotification& aIMENotification)
-                            override final;
+                            final;
   virtual MOZ_MUST_USE nsresult
                           StartPluginIME(const mozilla::WidgetKeyboardEvent& aKeyboardEvent,
                                          int32_t aPanelX, int32_t aPanelY,
                                          nsString& aCommitted) override
                           { return NS_ERROR_NOT_IMPLEMENTED; }
   virtual void            SetPluginFocused(bool& aFocused) override {}
   virtual void            SetCandidateWindowForPlugin(
                             const mozilla::widget::CandidateWindowPosition&
@@ -293,17 +293,17 @@ public:
   CreateChild(const LayoutDeviceIntRect& aRect,
               nsWidgetInitData* aInitData = nullptr,
               bool aForceUseIWidgetParent = false) override;
   virtual void            AttachViewToTopLevel(bool aUseAttachedEvents) override;
   virtual nsIWidgetListener* GetAttachedWidgetListener() override;
   virtual void               SetAttachedWidgetListener(nsIWidgetListener* aListener) override;
   virtual nsIWidgetListener* GetPreviouslyAttachedWidgetListener() override;
   virtual void               SetPreviouslyAttachedWidgetListener(nsIWidgetListener* aListener) override;
-  virtual TextEventDispatcher* GetTextEventDispatcher() override final;
+  virtual TextEventDispatcher* GetTextEventDispatcher() final;
   virtual TextEventDispatcherListener*
     GetNativeTextEventDispatcherListener() override;
   virtual void ZoomToRect(const uint32_t& aPresShellId,
                           const FrameMetrics::ViewID& aViewId,
                           const CSSRect& aRect,
                           const uint32_t& aFlags) override;
   // Dispatch an event that must be first be routed through APZ.
   nsEventStatus DispatchInputEvent(mozilla::WidgetInputEvent* aEvent) override;