Bug 1118486 - Part 1: Use `= delete` instead of MOZ_DELETE directly; r=Waldo
authorEhsan Akhgari <ehsan@mozilla.com>
Tue, 06 Jan 2015 18:35:02 -0500
changeset 222888 86924ac6a94a9147bcae518239d7a33b5981062b
parent 222887 9838f371e0984bbac1fdc7da9077ff17ae84807a
child 222889 02de139764d987a467ed1fecd02f320091f31c02
push id10731
push usercbook@mozilla.com
push dateFri, 09 Jan 2015 14:51:37 +0000
treeherderfx-team@e6756043d930 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersWaldo
bugs1118486
milestone37.0a1
Bug 1118486 - Part 1: Use `= delete` instead of MOZ_DELETE directly; r=Waldo Most of this patch (with the exception of dom/bindings/Codegen.py) was generated by the following bash script: #!/bin/bash function convert() { echo "Converting $1 to $2..." find . ! -wholename "*nsprpub*" \ ! -wholename "*security/nss*" \ ! -wholename "*/.hg*" \ ! -wholename "*/.git*" \ ! -wholename "obj-*" \ -type f \ \( -iname "*.cpp" \ -o -iname "*.h" \ -o -iname "*.cc" \ -o -iname "*.idl" \ -o -iname "*.ipdl" \ -o -iname "*.ipdlh" \ -o -iname "*.mm" \) | \ xargs -n 1 sed -i -e "s/\b$1\b/$2/g" } convert MOZ_DELETE '= delete'
accessible/base/ARIAMap.h
accessible/base/AccGroupInfo.h
accessible/base/AccIterator.h
accessible/base/EventQueue.h
accessible/base/Relation.h
accessible/base/StyleInfo.h
accessible/base/TextRange.h
accessible/base/nsAccessiblePivot.h
accessible/generic/Accessible.h
accessible/windows/msaa/EnumVariant.h
accessible/windows/uia/uiaRawElmProvider.h
accessible/xpcom/xpcAccessible.h
accessible/xpcom/xpcAccessibleApplication.h
accessible/xpcom/xpcAccessibleDocument.h
accessible/xpcom/xpcAccessibleGeneric.h
accessible/xpcom/xpcAccessibleHyperLink.h
accessible/xpcom/xpcAccessibleHyperText.h
accessible/xpcom/xpcAccessibleImage.h
accessible/xpcom/xpcAccessibleSelectable.h
accessible/xpcom/xpcAccessibleTable.h
accessible/xpcom/xpcAccessibleTableCell.h
accessible/xpcom/xpcAccessibleTextRange.h
accessible/xpcom/xpcAccessibleValue.h
dom/base/DOMCursor.h
dom/base/DOMMatrix.h
dom/base/NodeInfo.h
dom/base/ScriptSettings.h
dom/base/WebSocket.h
dom/base/nsAttrAndChildArray.h
dom/base/nsDOMNavigationTiming.h
dom/bindings/BindingDeclarations.h
dom/bindings/BindingUtils.h
dom/bindings/CallbackObject.h
dom/bindings/Codegen.py
dom/bindings/ErrorResult.h
dom/bindings/TypedArray.h
dom/bindings/test/TestBindingHeader.h
dom/camera/CameraControlImpl.h
dom/camera/DOMCameraControl.h
dom/camera/DOMCameraControlListener.h
dom/camera/DOMCameraManager.h
dom/camera/FallbackCameraControl.cpp
dom/camera/GonkCameraControl.h
dom/camera/GonkCameraHwMgr.h
dom/camera/TestGonkCameraControl.h
dom/camera/TestGonkCameraHardware.h
dom/canvas/ImageData.h
dom/cellbroadcast/CellBroadcast.h
dom/encoding/EncodingUtils.h
dom/events/JSEventHandler.h
dom/fetch/FetchDriver.h
dom/fetch/Headers.h
dom/fetch/Response.h
dom/indexedDB/ActorsChild.h
dom/indexedDB/ActorsParent.cpp
dom/ipc/TabContext.h
dom/media/MediaRecorder.h
dom/media/SelfRef.h
dom/media/eme/CDMCaps.h
dom/media/encoder/fmp4_muxer/ISOMediaBoxes.h
dom/media/fmp4/gonk/GonkVideoDecoderManager.h
dom/media/omx/I420ColorConverterHelper.h
dom/media/omx/MediaCodecProxy.h
dom/media/omx/MediaCodecReader.h
dom/media/omx/OMXCodecWrapper.h
dom/media/omx/mediaresourcemanager/MediaResourceHandler.h
dom/media/webaudio/FFTBlock.h
dom/media/webaudio/blink/HRTFDatabase.h
dom/media/webaudio/blink/HRTFElevation.h
dom/media/webaudio/blink/HRTFKernel.h
dom/mobileconnection/ipc/MobileConnectionChild.h
dom/mobilemessage/MobileMessageThread.h
dom/nfc/MozNDEFRecord.h
dom/quota/OriginOrPatternString.h
dom/svg/SVGFragmentIdentifier.h
dom/workers/WorkerPrivate.h
dom/xul/templates/nsTemplateMatch.h
extensions/cookie/nsPermissionManager.h
gfx/gl/HeapCopyOfStackArray.h
gfx/layers/basic/AutoMaskData.h
gfx/layers/basic/BasicLayersImpl.h
gfx/layers/composite/AsyncCompositionManager.h
gfx/thebes/gfxDWriteFontList.cpp
gfx/thebes/gfxFontEntry.h
gfx/thebes/gfxFontMissingGlyphs.h
gfx/thebes/gfxGlyphExtents.h
gfx/thebes/gfxPrefs.h
gfx/thebes/gfxQuartzNativeDrawing.h
image/src/ProgressTracker.h
ipc/glue/MessageChannel.cpp
js/public/Debug.h
js/public/HashTable.h
js/public/MemoryMetrics.h
js/public/RootingAPI.h
js/public/StructuredClone.h
js/public/UbiNode.h
js/public/WeakMapPtr.h
js/src/builtin/MapObject.cpp
js/src/builtin/TestingFunctions.cpp
js/src/ds/LifoAlloc.h
js/src/ds/PriorityQueue.h
js/src/ds/SplayTree.h
js/src/frontend/BytecodeEmitter.cpp
js/src/frontend/ParseMaps.h
js/src/frontend/ParseNode.h
js/src/frontend/TokenStream.h
js/src/gc/Barrier.h
js/src/gc/GCInternals.h
js/src/gc/Nursery.h
js/src/gc/StoreBuffer.h
js/src/irregexp/RegExpEngine.h
js/src/jit/InlineList.h
js/src/jit/JitFrameIterator.h
js/src/jit/LiveRangeAllocator.h
js/src/jit/MIR.h
js/src/jit/RegisterAllocator.h
js/src/jit/TypePolicy.cpp
js/src/jit/arm/Simulator-arm.cpp
js/src/jit/mips/Simulator-mips.cpp
js/src/jsapi.h
js/src/jscompartment.h
js/src/jsdate.cpp
js/src/jsfriendapi.h
js/src/jsgc.h
js/src/jshashutil.h
js/src/jsobj.h
js/src/jspubtd.h
js/src/jsscript.h
js/src/jsstr.cpp
js/src/jsstr.h
js/src/shell/js.cpp
js/src/shell/jsheaptools.cpp
js/src/vm/Debugger.h
js/src/vm/GlobalObject.h
js/src/vm/Interpreter-inl.h
js/src/vm/Interpreter.h
js/src/vm/JSONParser.h
js/src/vm/PIC.h
js/src/vm/RegExpObject.h
js/src/vm/Runtime.h
js/src/vm/ScopeObject.h
js/src/vm/Shape.h
js/src/vm/Stack.h
js/src/vm/String.h
js/src/vm/StringBuffer.h
js/src/vm/Symbol.h
js/xpconnect/loader/mozJSComponentLoader.cpp
js/xpconnect/src/xpcObjectHelper.h
js/xpconnect/src/xpcprivate.h
js/xpconnect/src/xpcpublic.h
js/xpconnect/wrappers/XrayWrapper.h
layout/base/MaskLayerImageCache.h
layout/base/SelectionCarets.h
layout/base/TouchCaret.h
layout/base/nsCSSFrameConstructor.h
layout/base/nsStyleChangeList.h
layout/generic/WritingModes.h
layout/generic/nsFlexContainerFrame.cpp
layout/generic/nsFloatManager.h
layout/generic/nsFontInflationData.h
layout/generic/nsFrame.cpp
layout/generic/nsFrameList.h
layout/generic/nsLineBox.h
layout/mathml/nsMathMLSelectedFrame.h
layout/printing/nsPrintData.h
layout/printing/nsPrintEngine.h
layout/printing/nsPrintObject.h
layout/style/CSS.h
layout/style/CSSStyleSheet.h
layout/style/CounterStyleManager.h
layout/style/Declaration.h
layout/style/SVGAttrAnimationRuleProcessor.h
layout/style/StyleRule.h
layout/style/nsCSSParser.h
layout/style/nsCSSValue.h
layout/style/nsHTMLCSSStyleSheet.h
layout/style/nsHTMLStyleSheet.h
layout/style/nsStyleCoord.h
layout/style/nsStyleSet.h
layout/style/nsStyleStruct.h
media/mtransport/m_cpp_utils.h
media/webrtc/signaling/src/common/NullTransport.h
media/webrtc/signaling/src/media-conduit/AudioConduit.h
media/webrtc/signaling/src/media-conduit/VideoConduit.h
media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.h
media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.h
media/webrtc/signaling/src/sdp/SipccSdpAttributeList.h
memory/mozalloc/VolatileBuffer.h
mfbt/AlreadyAddRefed.h
mfbt/Atomics.h
mfbt/CheckedInt.h
mfbt/Endian.h
mfbt/LinkedList.h
mfbt/MathAlgorithms.h
mfbt/MaybeOneOf.h
mfbt/NullPtr.h
mfbt/Pair.h
mfbt/PodOperations.h
mfbt/RangedPtr.h
mfbt/ReentrancyGuard.h
mfbt/RefPtr.h
mfbt/Scoped.h
mfbt/SplayTree.h
mfbt/TypedEnum.h
mfbt/UniquePtr.h
mfbt/Vector.h
mfbt/tests/TestMaybe.cpp
mfbt/tests/TestTypeTraits.cpp
modules/libjar/nsZipArchive.h
netwerk/base/src/AutoClose.h
netwerk/cache2/CacheStorage.h
netwerk/cache2/CacheStorageService.h
netwerk/cache2/OldWrappers.h
netwerk/cookie/nsCookieService.cpp
security/manager/ssl/src/nsNSSCertificate.h
toolkit/components/filewatcher/NativeFileWatcherNotSupported.h
toolkit/components/filewatcher/NativeFileWatcherWin.h
toolkit/components/finalizationwitness/FinalizationWitnessService.h
toolkit/components/osfile/NativeOSFileInternals.cpp
toolkit/components/osfile/NativeOSFileInternals.h
toolkit/components/telemetry/Telemetry.cpp
toolkit/identity/IdentityCryptoService.cpp
tools/profiler/EHABIStackWalk.cpp
tools/profiler/PseudoStack.h
tools/profiler/TracedTaskCommon.h
xpcom/base/nsAutoRef.h
xpcom/ds/TimeStamp.h
xpcom/glue/DeadlockDetector.h
xpcom/glue/nsCOMArray.h
xpcom/glue/nsISupportsImpl.h
xpcom/glue/nsStringAPI.h
xpcom/glue/nsTHashtable.h
xpcom/glue/nsThreadUtils.h
xpcom/string/nsString.h
xpcom/string/nsTDependentString.h
xpcom/string/nsTLiteralString.h
xpcom/string/nsTPromiseFlatString.h
xpcom/string/nsTString.h
--- a/accessible/base/ARIAMap.h
+++ b/accessible/base/ARIAMap.h
@@ -238,19 +238,19 @@ public:
     mContent(aContent), mAttrIdx(0)
   {
     mAttrCount = mContent->GetAttrCount();
   }
 
   bool Next(nsAString& aAttrName, nsAString& aAttrValue);
 
 private:
-  AttrIterator() MOZ_DELETE;
-  AttrIterator(const AttrIterator&) MOZ_DELETE;
-  AttrIterator& operator= (const AttrIterator&) MOZ_DELETE;
+  AttrIterator() = delete;
+  AttrIterator(const AttrIterator&) = delete;
+  AttrIterator& operator= (const AttrIterator&) = delete;
 
   nsIContent* mContent;
   uint32_t mAttrIdx;
   uint32_t mAttrCount;
 };
 
 } // namespace aria
 } // namespace a11y
--- a/accessible/base/AccGroupInfo.h
+++ b/accessible/base/AccGroupInfo.h
@@ -73,19 +73,19 @@ public:
    * Return next item of the same group to the given item.
    */
   static Accessible* NextItemTo(Accessible* aItem);
 
 protected:
   AccGroupInfo(Accessible* aItem, a11y::role aRole);
 
 private:
-  AccGroupInfo() MOZ_DELETE;
-  AccGroupInfo(const AccGroupInfo&) MOZ_DELETE;
-  AccGroupInfo& operator =(const AccGroupInfo&) MOZ_DELETE;
+  AccGroupInfo() = delete;
+  AccGroupInfo(const AccGroupInfo&) = delete;
+  AccGroupInfo& operator =(const AccGroupInfo&) = delete;
 
   static mozilla::a11y::role BaseRole(mozilla::a11y::role aRole)
   {
     if (aRole == mozilla::a11y::roles::CHECK_MENU_ITEM ||
         aRole == mozilla::a11y::roles::PARENT_MENUITEM ||
         aRole == mozilla::a11y::roles::RADIO_MENU_ITEM)
       return mozilla::a11y::roles::MENUITEM;
 
--- a/accessible/base/AccIterator.h
+++ b/accessible/base/AccIterator.h
@@ -276,19 +276,19 @@ class ItemIterator : public AccIterable
 public:
   explicit ItemIterator(Accessible* aItemContainer) :
     mContainer(aItemContainer), mAnchor(nullptr) { }
   virtual ~ItemIterator() { }
 
   virtual Accessible* Next();
 
 private:
-  ItemIterator() MOZ_DELETE;
-  ItemIterator(const ItemIterator&) MOZ_DELETE;
-  ItemIterator& operator = (const ItemIterator&) MOZ_DELETE;
+  ItemIterator() = delete;
+  ItemIterator(const ItemIterator&) = delete;
+  ItemIterator& operator = (const ItemIterator&) = delete;
 
   Accessible* mContainer;
   Accessible* mAnchor;
 };
 
 
 /**
  * Used to iterate through XUL tree items of the same level.
@@ -298,19 +298,19 @@ class XULTreeItemIterator : public AccIt
 public:
   XULTreeItemIterator(XULTreeAccessible* aXULTree, nsITreeView* aTreeView,
                       int32_t aRowIdx);
   virtual ~XULTreeItemIterator() { }
 
   virtual Accessible* Next();
 
 private:
-  XULTreeItemIterator() MOZ_DELETE;
-  XULTreeItemIterator(const XULTreeItemIterator&) MOZ_DELETE;
-  XULTreeItemIterator& operator = (const XULTreeItemIterator&) MOZ_DELETE;
+  XULTreeItemIterator() = delete;
+  XULTreeItemIterator(const XULTreeItemIterator&) = delete;
+  XULTreeItemIterator& operator = (const XULTreeItemIterator&) = delete;
 
   XULTreeAccessible* mXULTree;
   nsITreeView* mTreeView;
   int32_t mRowCount;
   int32_t mContainerLevel;
   int32_t mCurrRowIdx;
 };
 
--- a/accessible/base/EventQueue.h
+++ b/accessible/base/EventQueue.h
@@ -27,18 +27,18 @@ protected:
   bool PushEvent(AccEvent* aEvent);
 
   /**
    * Process events from the queue and fires events.
    */
   void ProcessEventQueue();
 
 private:
-  EventQueue(const EventQueue&) MOZ_DELETE;
-  EventQueue& operator = (const EventQueue&) MOZ_DELETE;
+  EventQueue(const EventQueue&) = delete;
+  EventQueue& operator = (const EventQueue&) = delete;
 
   // Event queue processing
   /**
    * Coalesce redundant events from the queue.
    */
   void CoalesceEvents();
 
   /**
--- a/accessible/base/Relation.h
+++ b/accessible/base/Relation.h
@@ -90,18 +90,18 @@ public:
 
     if (!mFirstIter)
       mLastIter = nullptr;
 
     return target;
   }
 
 private:
-  Relation& operator = (const Relation&) MOZ_DELETE;
-  Relation(const Relation&) MOZ_DELETE;
+  Relation& operator = (const Relation&) = delete;
+  Relation(const Relation&) = delete;
 
   nsAutoPtr<AccIterable> mFirstIter;
   AccIterable* mLastIter;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/base/StyleInfo.h
+++ b/accessible/base/StyleInfo.h
@@ -27,19 +27,19 @@ public:
   void MarginTop(nsAString& aValue) { Margin(eSideTop, aValue); }
   void MarginBottom(nsAString& aValue) { Margin(eSideBottom, aValue); }
 
   static void FormatColor(const nscolor& aValue, nsString& aFormattedValue);
   static void FormatFontStyle(const nscoord& aValue, nsAString& aFormattedValue);
   static void FormatTextDecorationStyle(uint8_t aValue, nsAString& aFormattedValue);
 
 private:
-  StyleInfo() MOZ_DELETE;
-  StyleInfo(const StyleInfo&) MOZ_DELETE;
-  StyleInfo& operator = (const StyleInfo&) MOZ_DELETE;
+  StyleInfo() = delete;
+  StyleInfo(const StyleInfo&) = delete;
+  StyleInfo& operator = (const StyleInfo&) = delete;
 
   void Margin(Side aSide, nsAString& aValue);
 
   dom::Element* mElement;
   nsRefPtr<nsStyleContext> mStyleContext;
 };
 
 } // namespace a11y
--- a/accessible/base/TextRange.h
+++ b/accessible/base/TextRange.h
@@ -213,18 +213,18 @@ public:
   bool IsValid() const { return mRoot; }
 
   void SetStartPoint(HyperTextAccessible* aContainer, int32_t aOffset)
     { mStartContainer = aContainer; mStartOffset = aOffset; }
   void SetEndPoint(HyperTextAccessible* aContainer, int32_t aOffset)
     { mStartContainer = aContainer; mStartOffset = aOffset; }
 
 private:
-  TextRange(const TextRange& aRange) MOZ_DELETE;
-  TextRange& operator=(const TextRange& aRange) MOZ_DELETE;
+  TextRange(const TextRange& aRange) = delete;
+  TextRange& operator=(const TextRange& aRange) = delete;
 
   friend class HyperTextAccessible;
   friend class xpcAccessibleTextRange;
 
   void Set(HyperTextAccessible* aRoot,
            HyperTextAccessible* aStartContainer, int32_t aStartOffset,
            HyperTextAccessible* aEndContainer, int32_t aEndOffset);
 
--- a/accessible/base/nsAccessiblePivot.h
+++ b/accessible/base/nsAccessiblePivot.h
@@ -34,19 +34,19 @@ public:
 
   /*
    * A simple getter for the pivot's position.
    */
   Accessible* Position() { return mPosition; }
 
 private:
   ~nsAccessiblePivot();
-  nsAccessiblePivot() MOZ_DELETE;
-  nsAccessiblePivot(const nsAccessiblePivot&) MOZ_DELETE;
-  void operator = (const nsAccessiblePivot&) MOZ_DELETE;
+  nsAccessiblePivot() = delete;
+  nsAccessiblePivot(const nsAccessiblePivot&) = delete;
+  void operator = (const nsAccessiblePivot&) = delete;
 
   /*
    * Notify all observers on a pivot change. Return true if it has changed and
    * observers have been notified.
    */
   bool NotifyOfPivotChange(Accessible* aOldAccessible,
                            int32_t aOldStart, int32_t aOldEnd,
                            PivotMoveReason aReason,
--- a/accessible/generic/Accessible.h
+++ b/accessible/generic/Accessible.h
@@ -1107,19 +1107,19 @@ protected:
   friend class AccGroupInfo;
 
   /**
    * Non-null indicates author-supplied role; possibly state & value as well
    */
   nsRoleMapEntry* mRoleMapEntry;
 
 private:
-  Accessible() MOZ_DELETE;
-  Accessible(const Accessible&) MOZ_DELETE;
-  Accessible& operator =(const Accessible&) MOZ_DELETE;
+  Accessible() = delete;
+  Accessible(const Accessible&) = delete;
+  Accessible& operator =(const Accessible&) = delete;
 
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(Accessible,
                               NS_ACCESSIBLE_IMPL_IID)
 
 
 /**
--- a/accessible/windows/msaa/EnumVariant.h
+++ b/accessible/windows/msaa/EnumVariant.h
@@ -35,18 +35,18 @@ public:
     /* [in] */ ULONG aCount);
 
   virtual HRESULT STDMETHODCALLTYPE Reset();
 
   virtual HRESULT STDMETHODCALLTYPE Clone(
     /* [out] */ IEnumVARIANT** aEnumVaraint);
 
 private:
-  ChildrenEnumVariant() MOZ_DELETE;
-  ChildrenEnumVariant& operator =(const ChildrenEnumVariant&) MOZ_DELETE;
+  ChildrenEnumVariant() = delete;
+  ChildrenEnumVariant& operator =(const ChildrenEnumVariant&) = delete;
 
   ChildrenEnumVariant(const ChildrenEnumVariant& aEnumVariant) :
     mAnchorAcc(aEnumVariant.mAnchorAcc), mCurAcc(aEnumVariant.mCurAcc),
     mCurIndex(aEnumVariant.mCurIndex) { }
   virtual ~ChildrenEnumVariant() { }
 
 protected:
   nsRefPtr<AccessibleWrap> mAnchorAcc;
--- a/accessible/windows/uia/uiaRawElmProvider.h
+++ b/accessible/windows/uia/uiaRawElmProvider.h
@@ -56,19 +56,19 @@ public:
   virtual HRESULT STDMETHODCALLTYPE GetPropertyValue(
     /* [in] */ PROPERTYID aPropertyId,
     /* [retval][out] */ __RPC__out VARIANT* aPropertyValue);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_HostRawElementProvider(
     /* [retval][out] */ __RPC__deref_out_opt IRawElementProviderSimple** aRawElmProvider);
 
 private:
-  uiaRawElmProvider() MOZ_DELETE;
-  uiaRawElmProvider& operator =(const uiaRawElmProvider&) MOZ_DELETE;
-  uiaRawElmProvider(const uiaRawElmProvider&) MOZ_DELETE;
+  uiaRawElmProvider() = delete;
+  uiaRawElmProvider& operator =(const uiaRawElmProvider&) = delete;
+  uiaRawElmProvider(const uiaRawElmProvider&) = delete;
 
 protected:
   nsRefPtr<AccessibleWrap> mAcc;
 };
 
 } // a11y namespace
 } // mozilla namespace
 
--- a/accessible/xpcom/xpcAccessible.h
+++ b/accessible/xpcom/xpcAccessible.h
@@ -81,16 +81,16 @@ public:
 
 protected:
   xpcAccessible() { }
   virtual ~xpcAccessible() {}
 
 private:
   Accessible* Intl();
 
-  xpcAccessible(const xpcAccessible&) MOZ_DELETE;
-  xpcAccessible& operator =(const xpcAccessible&) MOZ_DELETE;
+  xpcAccessible(const xpcAccessible&) = delete;
+  xpcAccessible& operator =(const xpcAccessible&) = delete;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/xpcom/xpcAccessibleApplication.h
+++ b/accessible/xpcom/xpcAccessibleApplication.h
@@ -33,16 +33,16 @@ public:
   NS_IMETHOD GetPlatformVersion(nsAString& aVersion) MOZ_FINAL;
 
 protected:
   virtual ~xpcAccessibleApplication() {}
 
 private:
   ApplicationAccessible* Intl() { return mIntl->AsApplication(); }
 
-  xpcAccessibleApplication(const xpcAccessibleApplication&) MOZ_DELETE;
-  xpcAccessibleApplication& operator =(const xpcAccessibleApplication&) MOZ_DELETE;
+  xpcAccessibleApplication(const xpcAccessibleApplication&) = delete;
+  xpcAccessibleApplication& operator =(const xpcAccessibleApplication&) = delete;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/xpcom/xpcAccessibleDocument.h
+++ b/accessible/xpcom/xpcAccessibleDocument.h
@@ -64,18 +64,18 @@ private:
       xpcAcc->Shutdown();
 
     mCache.Remove(aAccessible);
   }
 
   friend class DocManager;
   friend class DocAccessible;
 
-  xpcAccessibleDocument(const xpcAccessibleDocument&) MOZ_DELETE;
-  xpcAccessibleDocument& operator =(const xpcAccessibleDocument&) MOZ_DELETE;
+  xpcAccessibleDocument(const xpcAccessibleDocument&) = delete;
+  xpcAccessibleDocument& operator =(const xpcAccessibleDocument&) = delete;
 
   nsRefPtrHashtable<nsPtrHashKey<const Accessible>, xpcAccessibleGeneric> mCache;
 };
 
 inline xpcAccessibleGeneric*
 ToXPC(Accessible* aAccessible)
 {
   if (!aAccessible)
--- a/accessible/xpcom/xpcAccessibleGeneric.h
+++ b/accessible/xpcom/xpcAccessibleGeneric.h
@@ -61,18 +61,18 @@ protected:
 
 private:
   friend class Accessible;
   friend class xpcAccessible;
   friend class xpcAccessibleHyperLink;
   friend class xpcAccessibleSelectable;
   friend class xpcAccessibleValue;
 
-  xpcAccessibleGeneric(const xpcAccessibleGeneric&) MOZ_DELETE;
-  xpcAccessibleGeneric& operator =(const xpcAccessibleGeneric&) MOZ_DELETE;
+  xpcAccessibleGeneric(const xpcAccessibleGeneric&) = delete;
+  xpcAccessibleGeneric& operator =(const xpcAccessibleGeneric&) = delete;
 };
 
 inline Accessible*
 xpcAccessible::Intl()
 {
   return static_cast<xpcAccessibleGeneric*>(this)->mIntl;
 }
 
--- a/accessible/xpcom/xpcAccessibleHyperLink.h
+++ b/accessible/xpcom/xpcAccessibleHyperLink.h
@@ -30,18 +30,18 @@ public:
   NS_IMETHOD GetAnchor(int32_t aIndex, nsIAccessible** aAccessible) MOZ_FINAL;
   NS_IMETHOD GetValid(bool* aValid) MOZ_FINAL;
 
 protected:
   xpcAccessibleHyperLink() { }
   virtual ~xpcAccessibleHyperLink() {}
 
 private:
-  xpcAccessibleHyperLink(const xpcAccessibleHyperLink&) MOZ_DELETE;
-  xpcAccessibleHyperLink& operator =(const xpcAccessibleHyperLink&) MOZ_DELETE;
+  xpcAccessibleHyperLink(const xpcAccessibleHyperLink&) = delete;
+  xpcAccessibleHyperLink& operator =(const xpcAccessibleHyperLink&) = delete;
 
   Accessible* Intl();
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/xpcom/xpcAccessibleHyperText.h
+++ b/accessible/xpcom/xpcAccessibleHyperText.h
@@ -37,16 +37,16 @@ public:
   NS_DECL_NSIACCESSIBLEEDITABLETEXT
 
 protected:
   virtual ~xpcAccessibleHyperText() {}
 
 private:
   HyperTextAccessible* Intl() { return mIntl->AsHyperText(); }
 
-  xpcAccessibleHyperText(const xpcAccessibleHyperText&) MOZ_DELETE;
-  xpcAccessibleHyperText& operator =(const xpcAccessibleHyperText&) MOZ_DELETE;
+  xpcAccessibleHyperText(const xpcAccessibleHyperText&) = delete;
+  xpcAccessibleHyperText& operator =(const xpcAccessibleHyperText&) = delete;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif // mozilla_a11y_xpcAccessibleHyperText_h_
--- a/accessible/xpcom/xpcAccessibleImage.h
+++ b/accessible/xpcom/xpcAccessibleImage.h
@@ -28,16 +28,16 @@ public:
   NS_IMETHOD GetImageSize(int32_t* aWidth, int32_t* aHeight) MOZ_FINAL;
 
 protected:
   virtual ~xpcAccessibleImage() {}
 
 private:
   ImageAccessible* Intl() { return mIntl->AsImage(); }
 
-  xpcAccessibleImage(const xpcAccessibleImage&) MOZ_DELETE;
-  xpcAccessibleImage& operator =(const xpcAccessibleImage&) MOZ_DELETE;
+  xpcAccessibleImage(const xpcAccessibleImage&) = delete;
+  xpcAccessibleImage& operator =(const xpcAccessibleImage&) = delete;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/xpcom/xpcAccessibleSelectable.h
+++ b/accessible/xpcom/xpcAccessibleSelectable.h
@@ -34,18 +34,18 @@ public:
   NS_IMETHOD SelectAll(bool* aIsMultiSelect) MOZ_FINAL;
   NS_IMETHOD UnselectAll() MOZ_FINAL;
 
 protected:
   xpcAccessibleSelectable() { }
   virtual ~xpcAccessibleSelectable() {}
 
 private:
-  xpcAccessibleSelectable(const xpcAccessibleSelectable&) MOZ_DELETE;
-  xpcAccessibleSelectable& operator =(const xpcAccessibleSelectable&) MOZ_DELETE;
+  xpcAccessibleSelectable(const xpcAccessibleSelectable&) = delete;
+  xpcAccessibleSelectable& operator =(const xpcAccessibleSelectable&) = delete;
 
   Accessible* Intl();
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/xpcom/xpcAccessibleTable.h
+++ b/accessible/xpcom/xpcAccessibleTable.h
@@ -64,16 +64,16 @@ public:
   NS_IMETHOD IsProbablyForLayout(bool* aIsForLayout) MOZ_FINAL;
 
 protected:
   virtual ~xpcAccessibleTable() {}
 
 private:
   TableAccessible* Intl() { return mIntl->AsTable(); }
 
-  xpcAccessibleTable(const xpcAccessibleTable&) MOZ_DELETE;
-  xpcAccessibleTable& operator =(const xpcAccessibleTable&) MOZ_DELETE;
+  xpcAccessibleTable(const xpcAccessibleTable&) = delete;
+  xpcAccessibleTable& operator =(const xpcAccessibleTable&) = delete;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif // mozilla_a11y_xpcAccessibleTable_h_
--- a/accessible/xpcom/xpcAccessibleTableCell.h
+++ b/accessible/xpcom/xpcAccessibleTableCell.h
@@ -37,16 +37,16 @@ public:
   NS_IMETHOD IsSelected(bool* aSelected) MOZ_FINAL;
 
 protected:
   virtual ~xpcAccessibleTableCell() {}
 
 private:
   TableCellAccessible* Intl() { return mIntl->AsTableCell(); }
 
-  xpcAccessibleTableCell(const xpcAccessibleTableCell&) MOZ_DELETE;
-  xpcAccessibleTableCell& operator =(const xpcAccessibleTableCell&) MOZ_DELETE;
+  xpcAccessibleTableCell(const xpcAccessibleTableCell&) = delete;
+  xpcAccessibleTableCell& operator =(const xpcAccessibleTableCell&) = delete;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif // mozilla_a11y_xpcom_xpcAccessibletableCell_h_
--- a/accessible/xpcom/xpcAccessibleTextRange.h
+++ b/accessible/xpcom/xpcAccessibleTextRange.h
@@ -64,18 +64,18 @@ private:
   explicit xpcAccessibleTextRange(TextRange&& aRange) :
     mRange(Forward<TextRange>(aRange)) {}
   xpcAccessibleTextRange() {}
 
   ~xpcAccessibleTextRange() {}
 
   friend class xpcAccessibleHyperText;
 
-  xpcAccessibleTextRange(const xpcAccessibleTextRange&) MOZ_DELETE;
-  xpcAccessibleTextRange& operator =(const xpcAccessibleTextRange&) MOZ_DELETE;
+  xpcAccessibleTextRange(const xpcAccessibleTextRange&) = delete;
+  xpcAccessibleTextRange& operator =(const xpcAccessibleTextRange&) = delete;
 
   TextRange mRange;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(xpcAccessibleTextRange,
                               NS_ACCESSIBLETEXTRANGE_IMPL_IID)
 
 } // namespace a11y
--- a/accessible/xpcom/xpcAccessibleValue.h
+++ b/accessible/xpcom/xpcAccessibleValue.h
@@ -29,16 +29,16 @@ public:
 
 protected:
   xpcAccessibleValue() { }
   virtual ~xpcAccessibleValue() {}
 
 private:
   Accessible* Intl();
 
-  xpcAccessibleValue(const xpcAccessibleValue&) MOZ_DELETE;
-  xpcAccessibleValue& operator =(const xpcAccessibleValue&) MOZ_DELETE;
+  xpcAccessibleValue(const xpcAccessibleValue&) = delete;
+  xpcAccessibleValue& operator =(const xpcAccessibleValue&) = delete;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/dom/base/DOMCursor.h
+++ b/dom/base/DOMCursor.h
@@ -37,22 +37,22 @@ public:
 
   void Reset();
   void FireDone();
 
 protected:
   ~DOMCursor() {}
 
 private:
-  DOMCursor() MOZ_DELETE;
+  DOMCursor() = delete;
   // Calling Then() on DOMCursor is a mistake, since the DOMCursor object
   // should not have a .then() method from JS' point of view.
   already_AddRefed<mozilla::dom::Promise>
   Then(JSContext* aCx, AnyCallback* aResolveCallback,
-       AnyCallback* aRejectCallback, ErrorResult& aRv) MOZ_DELETE;
+       AnyCallback* aRejectCallback, ErrorResult& aRv) = delete;
 
   nsCOMPtr<nsICursorContinueCallback> mCallback;
   bool mFinished;
 };
 
 } // namespace dom
 } // namespace mozilla
 
--- a/dom/base/DOMMatrix.h
+++ b/dom/base/DOMMatrix.h
@@ -129,19 +129,19 @@ protected:
   nsCOMPtr<nsISupports>     mParent;
   nsAutoPtr<gfx::Matrix>    mMatrix2D;
   nsAutoPtr<gfx::Matrix4x4> mMatrix3D;
 
   ~DOMMatrixReadOnly()
   {
   }
 private:
-  DOMMatrixReadOnly() MOZ_DELETE;
-  DOMMatrixReadOnly(const DOMMatrixReadOnly&) MOZ_DELETE;
-  DOMMatrixReadOnly& operator=(const DOMMatrixReadOnly&) MOZ_DELETE;
+  DOMMatrixReadOnly() = delete;
+  DOMMatrixReadOnly(const DOMMatrixReadOnly&) = delete;
+  DOMMatrixReadOnly& operator=(const DOMMatrixReadOnly&) = delete;
 };
 
 class DOMMatrix MOZ_FINAL : public DOMMatrixReadOnly
 {
 public:
   explicit DOMMatrix(nsISupports* aParent)
     : DOMMatrixReadOnly(aParent)
   {}
--- a/dom/base/NodeInfo.h
+++ b/dom/base/NodeInfo.h
@@ -201,18 +201,18 @@ public:
    * Retrieve a pointer to the document that owns this node info.
    */
   nsIDocument* GetDocument() const
   {
     return mDocument;
   }
 
 private:
-  NodeInfo() MOZ_DELETE; 
-  NodeInfo(const NodeInfo& aOther) MOZ_DELETE;
+  NodeInfo() = delete; 
+  NodeInfo(const NodeInfo& aOther) = delete;
 
   // NodeInfo is only constructed by nsNodeInfoManager which is a friend class.
   // aName and aOwnerManager may not be null.
   NodeInfo(nsIAtom* aName, nsIAtom* aPrefix, int32_t aNamespaceID,
            uint16_t aNodeType, nsIAtom* aExtraName,
            nsNodeInfoManager* aOwnerManager);
 
   ~NodeInfo();
--- a/dom/base/ScriptSettings.h
+++ b/dom/base/ScriptSettings.h
@@ -307,18 +307,18 @@ private:
 
   // Track state between the old and new error reporting modes.
   bool mOwnErrorReporting;
   bool mOldAutoJSAPIOwnsErrorReporting;
   Maybe<JSErrorReporter> mOldErrorReporter;
 
   void InitInternal(JSObject* aGlobal, JSContext* aCx, bool aIsMainThread);
 
-  AutoJSAPI(const AutoJSAPI&) MOZ_DELETE;
-  AutoJSAPI& operator= (const AutoJSAPI&) MOZ_DELETE;
+  AutoJSAPI(const AutoJSAPI&) = delete;
+  AutoJSAPI& operator= (const AutoJSAPI&) = delete;
 };
 
 /*
  * A class that represents a new script entry point.
  */
 class AutoEntryScript : public AutoJSAPI,
                         protected ScriptSettingsStackEntry {
 public:
--- a/dom/base/WebSocket.h
+++ b/dom/base/WebSocket.h
@@ -153,18 +153,18 @@ private: // constructor && distructor
   // outgoing not sent messages then this method keeps the object alive
   // when js doesn't have strong references to it.
   void UpdateMustKeepAlive();
   // ATTENTION, when calling this method the object can be released
   // (and possibly collected).
   void DontKeepAliveAnyMore();
 
 private:
-  WebSocket(const WebSocket& x) MOZ_DELETE;   // prevent bad usage
-  WebSocket& operator=(const WebSocket& x) MOZ_DELETE;
+  WebSocket(const WebSocket& x) = delete;   // prevent bad usage
+  WebSocket& operator=(const WebSocket& x) = delete;
 
   void Send(nsIInputStream* aMsgStream,
             const nsACString& aMsgString,
             uint32_t aMsgLength,
             bool aIsBinary,
             ErrorResult& aRv);
 
   void AssertIsOnTargetThread() const;
--- a/dom/base/nsAttrAndChildArray.h
+++ b/dom/base/nsAttrAndChildArray.h
@@ -124,18 +124,18 @@ public:
 
   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
   bool HasMappedAttrs() const
   {
     return MappedAttrCount();
   }
 
 private:
-  nsAttrAndChildArray(const nsAttrAndChildArray& aOther) MOZ_DELETE;
-  nsAttrAndChildArray& operator=(const nsAttrAndChildArray& aOther) MOZ_DELETE;
+  nsAttrAndChildArray(const nsAttrAndChildArray& aOther) = delete;
+  nsAttrAndChildArray& operator=(const nsAttrAndChildArray& aOther) = delete;
 
   void Clear();
 
   uint32_t NonMappedAttrCount() const;
   uint32_t MappedAttrCount() const;
 
   // Returns a non-null zero-refcount object.
   nsMappedAttributes*
--- a/dom/base/nsDOMNavigationTiming.h
+++ b/dom/base/nsDOMNavigationTiming.h
@@ -90,17 +90,17 @@ public:
 
   inline DOMHighResTimeStamp TimeStampToDOMHighRes(mozilla::TimeStamp aStamp)
   {
     mozilla::TimeDuration duration = aStamp - mNavigationStartTimeStamp;
     return duration.ToMilliseconds();
   }
 
 private:
-  nsDOMNavigationTiming(const nsDOMNavigationTiming &) MOZ_DELETE;
+  nsDOMNavigationTiming(const nsDOMNavigationTiming &) = delete;
   ~nsDOMNavigationTiming();
 
   void Clear();
 
   nsCOMPtr<nsIURI> mUnloadedURI;
   nsCOMPtr<nsIURI> mLoadedURI;
 
   nsDOMPerformanceNavigationType mNavigationType;
--- a/dom/bindings/BindingDeclarations.h
+++ b/dom/bindings/BindingDeclarations.h
@@ -166,18 +166,18 @@ public:
   }
 
   // If we ever decide to add conversion operators for optional arrays
   // like the ones Nullable has, we'll need to ensure that Maybe<> has
   // the boolean before the actual data.
 
 private:
   // Forbid copy-construction and assignment
-  Optional_base(const Optional_base& other) MOZ_DELETE;
-  const Optional_base &operator=(const Optional_base &other) MOZ_DELETE;
+  Optional_base(const Optional_base& other) = delete;
+  const Optional_base &operator=(const Optional_base &other) = delete;
 
 protected:
   Maybe<InternalType> mImpl;
 };
 
 template<typename T>
 class Optional : public Optional_base<T, T>
 {
@@ -256,19 +256,19 @@ public:
   }
 };
 
 // A specialization of Optional for JS::Value to make sure no one ever uses it.
 template<>
 class Optional<JS::Value>
 {
 private:
-  Optional() MOZ_DELETE;
+  Optional() = delete;
 
-  explicit Optional(JS::Value aValue) MOZ_DELETE;
+  explicit Optional(JS::Value aValue) = delete;
 };
 
 // A specialization of Optional for NonNull that lets us get a T& from Value()
 template<typename U> class NonNull;
 template<typename T>
 class Optional<NonNull<T> > : public Optional_base<T, NonNull<T> >
 {
 public:
@@ -349,18 +349,18 @@ public:
   const nsAString& Value() const
   {
     MOZ_ASSERT(WasPassed());
     return *mStr;
   }
 
 private:
   // Forbid copy-construction and assignment
-  Optional(const Optional& other) MOZ_DELETE;
-  const Optional &operator=(const Optional &other) MOZ_DELETE;
+  Optional(const Optional& other) = delete;
+  const Optional &operator=(const Optional &other) = delete;
 
   bool mPassed;
   const nsAString* mStr;
 };
 
 template<class T>
 class NonNull
 {
--- a/dom/bindings/BindingUtils.h
+++ b/dom/bindings/BindingUtils.h
@@ -1917,18 +1917,18 @@ struct FakeString {
 private:
   nsString::char_type* mData;
   nsString::size_type mLength;
   uint32_t mFlags;
 
   static const size_t sInlineCapacity = 64;
   nsString::char_type mInlineStorage[sInlineCapacity];
 
-  FakeString(const FakeString& other) MOZ_DELETE;
-  void operator=(const FakeString& other) MOZ_DELETE;
+  FakeString(const FakeString& other) = delete;
+  void operator=(const FakeString& other) = delete;
 
   void SetData(nsString::char_type* aData) {
     MOZ_ASSERT(mFlags == nsString::F_TERMINATED);
     mData = const_cast<nsString::char_type*>(aData);
   }
 
   // A class to use for our static asserts to ensure our object layout
   // matches that of nsString.
@@ -2057,122 +2057,122 @@ public:
 // Class used to trace sequences, with specializations for various
 // sequence types.
 template<typename T,
          bool isDictionary=IsBaseOf<DictionaryBase, T>::value,
          bool isTypedArray=IsBaseOf<AllTypedArraysBase, T>::value,
          bool isOwningUnion=IsBaseOf<AllOwningUnionBase, T>::value>
 class SequenceTracer
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 };
 
 // sequence<object> or sequence<object?>
 template<>
 class SequenceTracer<JSObject*, false, false, false>
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 
 public:
   static void TraceSequence(JSTracer* trc, JSObject** objp, JSObject** end) {
     for (; objp != end; ++objp) {
       JS_CallUnbarrieredObjectTracer(trc, objp, "sequence<object>");
     }
   }
 };
 
 // sequence<any>
 template<>
 class SequenceTracer<JS::Value, false, false, false>
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 
 public:
   static void TraceSequence(JSTracer* trc, JS::Value* valp, JS::Value* end) {
     for (; valp != end; ++valp) {
       JS_CallUnbarrieredValueTracer(trc, valp, "sequence<any>");
     }
   }
 };
 
 // sequence<sequence<T>>
 template<typename T>
 class SequenceTracer<Sequence<T>, false, false, false>
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 
 public:
   static void TraceSequence(JSTracer* trc, Sequence<T>* seqp, Sequence<T>* end) {
     for (; seqp != end; ++seqp) {
       DoTraceSequence(trc, *seqp);
     }
   }
 };
 
 // sequence<sequence<T>> as return value
 template<typename T>
 class SequenceTracer<nsTArray<T>, false, false, false>
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 
 public:
   static void TraceSequence(JSTracer* trc, nsTArray<T>* seqp, nsTArray<T>* end) {
     for (; seqp != end; ++seqp) {
       DoTraceSequence(trc, *seqp);
     }
   }
 };
 
 // sequence<someDictionary>
 template<typename T>
 class SequenceTracer<T, true, false, false>
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 
 public:
   static void TraceSequence(JSTracer* trc, T* dictp, T* end) {
     for (; dictp != end; ++dictp) {
       dictp->TraceDictionary(trc);
     }
   }
 };
 
 // sequence<SomeTypedArray>
 template<typename T>
 class SequenceTracer<T, false, true, false>
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 
 public:
   static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
     for (; arrayp != end; ++arrayp) {
       arrayp->TraceSelf(trc);
     }
   }
 };
 
 // sequence<SomeOwningUnion>
 template<typename T>
 class SequenceTracer<T, false, false, true>
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 
 public:
   static void TraceSequence(JSTracer* trc, T* arrayp, T* end) {
     for (; arrayp != end; ++arrayp) {
       arrayp->TraceUnion(trc);
     }
   }
 };
 
 // sequence<T?> with T? being a Nullable<T>
 template<typename T>
 class SequenceTracer<Nullable<T>, false, false, false>
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 
 public:
   static void TraceSequence(JSTracer* trc, Nullable<T>* seqp,
                             Nullable<T>* end) {
     for (; seqp != end; ++seqp) {
       if (!seqp->IsNull()) {
         // Pretend like we actually have a length-one sequence here so
         // we can do template instantiation correctly for T.
@@ -2202,17 +2202,17 @@ void TraceMozMap(JSTracer* trc, MozMap<T
 {
   map.EnumerateValues(TraceMozMapValue<T>, trc);
 }
 
 // sequence<MozMap>
 template<typename T>
 class SequenceTracer<MozMap<T>, false, false, false>
 {
-  explicit SequenceTracer() MOZ_DELETE; // Should never be instantiated
+  explicit SequenceTracer() = delete; // Should never be instantiated
 
 public:
   static void TraceSequence(JSTracer* trc, MozMap<T>* seqp, MozMap<T>* end) {
     for (; seqp != end; ++seqp) {
       seqp->EnumerateValues(TraceMozMapValue<T>, trc);
     }
   }
 };
@@ -3113,17 +3113,17 @@ template<class T>
 inline T*
 StrongOrRawPtr(T* aPtr)
 {
   return aPtr;
 }
 
 template<class T, template<typename> class SmartPtr, class S>
 inline void
-StrongOrRawPtr(SmartPtr<S>&& aPtr) MOZ_DELETE;
+StrongOrRawPtr(SmartPtr<S>&& aPtr) = delete;
 
 inline
 JSObject*
 GetErrorPrototype(JSContext* aCx, JS::Handle<JSObject*> aForObj)
 {
   return JS_GetErrorPrototype(aCx);
 }
 
--- a/dom/bindings/CallbackObject.h
+++ b/dom/bindings/CallbackObject.h
@@ -126,18 +126,18 @@ private:
     mCallback = aCallback;
     if (aIncumbentGlobal) {
       mIncumbentGlobal = aIncumbentGlobal;
       mIncumbentJSGlobal = aIncumbentGlobal->GetGlobalJSObject();
     }
     mozilla::HoldJSObjects(this);
   }
 
-  CallbackObject(const CallbackObject&) MOZ_DELETE;
-  CallbackObject& operator =(const CallbackObject&) MOZ_DELETE;
+  CallbackObject(const CallbackObject&) = delete;
+  CallbackObject& operator =(const CallbackObject&) = delete;
 
 protected:
   void DropJSObjects()
   {
     MOZ_ASSERT_IF(mIncumbentJSGlobal, mCallback);
     if (mCallback) {
       mCallback = nullptr;
       mIncumbentJSGlobal = nullptr;
@@ -176,17 +176,17 @@ protected:
 
     JSContext* GetContext() const
     {
       return mCx;
     }
 
   private:
     // We better not get copy-constructed
-    CallSetup(const CallSetup&) MOZ_DELETE;
+    CallSetup(const CallSetup&) = delete;
 
     bool ShouldRethrowException(JS::Handle<JS::Value> aException);
 
     // Members which can go away whenever
     JSContext* mCx;
 
     // Caller's compartment. This will only have a sensible value if
     // mExceptionHandling == eRethrowContentExceptions.
--- a/dom/bindings/Codegen.py
+++ b/dom/bindings/Codegen.py
@@ -9498,18 +9498,18 @@ class CGClass(CGThing):
 
         if self.disallowCopyConstruction:
             class DisallowedCopyConstructor(object):
                 def __init__(self):
                     self.visibility = "private"
 
                 def declare(self, cgClass):
                     name = cgClass.getNameString()
-                    return ("%s(const %s&) MOZ_DELETE;\n"
-                            "void operator=(const %s) MOZ_DELETE;\n" % (name, name, name))
+                    return ("%s(const %s&) = delete;\n"
+                            "void operator=(const %s) = delete;\n" % (name, name, name))
 
             disallowedCopyConstructors = [DisallowedCopyConstructor()]
         else:
             disallowedCopyConstructors = []
 
         order = [self.enums, self.unions,
                  self.typedefs, self.members,
                  self.constructors + disallowedCopyConstructors,
--- a/dom/bindings/ErrorResult.h
+++ b/dom/bindings/ErrorResult.h
@@ -153,17 +153,17 @@ private:
 #ifdef DEBUG
   // Used to keep track of codepaths that might throw JS exceptions,
   // for assertion purposes.
   bool mMightHaveUnreportedJSException;
 #endif
 
   // Not to be implemented, to make sure people always pass this by
   // reference, not by value.
-  ErrorResult(const ErrorResult&) MOZ_DELETE;
+  ErrorResult(const ErrorResult&) = delete;
 };
 
 /******************************************************************************
  ** Macros for checking results
  ******************************************************************************/
 
 #define ENSURE_SUCCESS(res, ret)                                          \
   do {                                                                    \
--- a/dom/bindings/TypedArray.h
+++ b/dom/bindings/TypedArray.h
@@ -48,17 +48,17 @@ public:
       JS_CallUnbarrieredObjectTracer(trc, &mTypedObj, "TypedArray.mTypedObj");
     }
     if (mWrappedObj) {
       JS_CallUnbarrieredObjectTracer(trc, &mTypedObj, "TypedArray.mWrappedObj");
     }
   }
 
 private:
-  TypedArrayObjectStorage(const TypedArrayObjectStorage&) MOZ_DELETE;
+  TypedArrayObjectStorage(const TypedArrayObjectStorage&) = delete;
 };
 
 /*
  * Various typed array classes for argument conversion.  We have a base class
  * that has a way of initializing a TypedArray from an existing typed array, and
  * a subclass of the base class that supports creation of a relevant typed array
  * or array buffer object.
  */
@@ -128,17 +128,17 @@ public:
   {
     MOZ_ASSERT(inited());
     MOZ_ASSERT(!mComputed);
     GetLengthAndData(mTypedObj, &mLength, &mData);
     mComputed = true;
   }
 
 private:
-  TypedArray_base(const TypedArray_base&) MOZ_DELETE;
+  TypedArray_base(const TypedArray_base&) = delete;
 };
 
 
 template<typename T,
          JSObject* UnwrapArray(JSObject*),
          T* GetData(JSObject*, const JS::AutoCheckCannotGC&),
          void GetLengthAndData(JSObject*, uint32_t*, T**),
          JSObject* CreateNew(JSContext*, uint32_t)>
@@ -183,17 +183,17 @@ private:
     if (data) {
       JS::AutoCheckCannotGC nogc;
       T* buf = static_cast<T*>(GetData(obj, nogc));
       memcpy(buf, data, length*sizeof(T));
     }
     return obj;
   }
 
-  TypedArray(const TypedArray&) MOZ_DELETE;
+  TypedArray(const TypedArray&) = delete;
 };
 
 typedef TypedArray<int8_t, js::UnwrapInt8Array, JS_GetInt8ArrayData,
                    js::GetInt8ArrayLengthAndData, JS_NewInt8Array>
         Int8Array;
 typedef TypedArray<uint8_t, js::UnwrapUint8Array, JS_GetUint8ArrayData,
                    js::GetUint8ArrayLengthAndData, JS_NewUint8Array>
         Uint8Array;
--- a/dom/bindings/test/TestBindingHeader.h
+++ b/dom/bindings/test/TestBindingHeader.h
@@ -863,226 +863,226 @@ public:
   int8_t EnforcedByte();
   void SetClampedByte(int8_t);
   int8_t ClampedByte();
 
 private:
   // We add signatures here that _could_ start matching if the codegen
   // got data types wrong.  That way if it ever does we'll have a call
   // to these private deleted methods and compilation will fail.
-  void SetReadonlyByte(int8_t) MOZ_DELETE;
+  void SetReadonlyByte(int8_t) = delete;
   template<typename T>
-  void SetWritableByte(T) MOZ_DELETE;
+  void SetWritableByte(T) = delete;
   template<typename T>
-  void PassByte(T) MOZ_DELETE;
-  void PassNullableByte(Nullable<int8_t>&) MOZ_DELETE;
+  void PassByte(T) = delete;
+  void PassNullableByte(Nullable<int8_t>&) = delete;
   template<typename T>
-  void PassOptionalByte(const Optional<T>&) MOZ_DELETE;
+  void PassOptionalByte(const Optional<T>&) = delete;
   template<typename T>
-  void PassOptionalByteWithDefault(T) MOZ_DELETE;
-  void PassVariadicByte(Sequence<int8_t>&) MOZ_DELETE;
+  void PassOptionalByteWithDefault(T) = delete;
+  void PassVariadicByte(Sequence<int8_t>&) = delete;
 
-  void SetReadonlyShort(int16_t) MOZ_DELETE;
+  void SetReadonlyShort(int16_t) = delete;
   template<typename T>
-  void SetWritableShort(T) MOZ_DELETE;
+  void SetWritableShort(T) = delete;
   template<typename T>
-  void PassShort(T) MOZ_DELETE;
+  void PassShort(T) = delete;
   template<typename T>
-  void PassOptionalShort(const Optional<T>&) MOZ_DELETE;
+  void PassOptionalShort(const Optional<T>&) = delete;
   template<typename T>
-  void PassOptionalShortWithDefault(T) MOZ_DELETE;
+  void PassOptionalShortWithDefault(T) = delete;
 
-  void SetReadonlyLong(int32_t) MOZ_DELETE;
+  void SetReadonlyLong(int32_t) = delete;
   template<typename T>
-  void SetWritableLong(T) MOZ_DELETE;
+  void SetWritableLong(T) = delete;
   template<typename T>
-  void PassLong(T) MOZ_DELETE;
+  void PassLong(T) = delete;
   template<typename T>
-  void PassOptionalLong(const Optional<T>&) MOZ_DELETE;
+  void PassOptionalLong(const Optional<T>&) = delete;
   template<typename T>
-  void PassOptionalLongWithDefault(T) MOZ_DELETE;
+  void PassOptionalLongWithDefault(T) = delete;
 
-  void SetReadonlyLongLong(int64_t) MOZ_DELETE;
+  void SetReadonlyLongLong(int64_t) = delete;
   template<typename T>
-  void SetWritableLongLong(T) MOZ_DELETE;
+  void SetWritableLongLong(T) = delete;
   template<typename T>
-  void PassLongLong(T) MOZ_DELETE;
+  void PassLongLong(T) = delete;
   template<typename T>
-  void PassOptionalLongLong(const Optional<T>&) MOZ_DELETE;
+  void PassOptionalLongLong(const Optional<T>&) = delete;
   template<typename T>
-  void PassOptionalLongLongWithDefault(T) MOZ_DELETE;
+  void PassOptionalLongLongWithDefault(T) = delete;
 
-  void SetReadonlyOctet(uint8_t) MOZ_DELETE;
+  void SetReadonlyOctet(uint8_t) = delete;
   template<typename T>
-  void SetWritableOctet(T) MOZ_DELETE;
+  void SetWritableOctet(T) = delete;
   template<typename T>
-  void PassOctet(T) MOZ_DELETE;
+  void PassOctet(T) = delete;
   template<typename T>
-  void PassOptionalOctet(const Optional<T>&) MOZ_DELETE;
+  void PassOptionalOctet(const Optional<T>&) = delete;
   template<typename T>
-  void PassOptionalOctetWithDefault(T) MOZ_DELETE;
+  void PassOptionalOctetWithDefault(T) = delete;
 
-  void SetReadonlyUnsignedShort(uint16_t) MOZ_DELETE;
+  void SetReadonlyUnsignedShort(uint16_t) = delete;
   template<typename T>
-  void SetWritableUnsignedShort(T) MOZ_DELETE;
+  void SetWritableUnsignedShort(T) = delete;
   template<typename T>
-  void PassUnsignedShort(T) MOZ_DELETE;
+  void PassUnsignedShort(T) = delete;
   template<typename T>
-  void PassOptionalUnsignedShort(const Optional<T>&) MOZ_DELETE;
+  void PassOptionalUnsignedShort(const Optional<T>&) = delete;
   template<typename T>
-  void PassOptionalUnsignedShortWithDefault(T) MOZ_DELETE;
+  void PassOptionalUnsignedShortWithDefault(T) = delete;
 
-  void SetReadonlyUnsignedLong(uint32_t) MOZ_DELETE;
+  void SetReadonlyUnsignedLong(uint32_t) = delete;
   template<typename T>
-  void SetWritableUnsignedLong(T) MOZ_DELETE;
+  void SetWritableUnsignedLong(T) = delete;
   template<typename T>
-  void PassUnsignedLong(T) MOZ_DELETE;
+  void PassUnsignedLong(T) = delete;
   template<typename T>
-  void PassOptionalUnsignedLong(const Optional<T>&) MOZ_DELETE;
+  void PassOptionalUnsignedLong(const Optional<T>&) = delete;
   template<typename T>
-  void PassOptionalUnsignedLongWithDefault(T) MOZ_DELETE;
+  void PassOptionalUnsignedLongWithDefault(T) = delete;
 
-  void SetReadonlyUnsignedLongLong(uint64_t) MOZ_DELETE;
+  void SetReadonlyUnsignedLongLong(uint64_t) = delete;
   template<typename T>
-  void SetWritableUnsignedLongLong(T) MOZ_DELETE;
+  void SetWritableUnsignedLongLong(T) = delete;
   template<typename T>
-  void PassUnsignedLongLong(T) MOZ_DELETE;
+  void PassUnsignedLongLong(T) = delete;
   template<typename T>
-  void PassOptionalUnsignedLongLong(const Optional<T>&) MOZ_DELETE;
+  void PassOptionalUnsignedLongLong(const Optional<T>&) = delete;
   template<typename T>
-  void PassOptionalUnsignedLongLongWithDefault(T) MOZ_DELETE;
+  void PassOptionalUnsignedLongLongWithDefault(T) = delete;
 
   // Enforce that only const things are passed for sequences
-  void PassSequence(Sequence<int32_t> &) MOZ_DELETE;
-  void PassNullableSequence(Nullable< Sequence<int32_t> >&) MOZ_DELETE;
-  void PassOptionalNullableSequenceWithDefaultValue(Nullable< Sequence<int32_t> >&) MOZ_DELETE;
-  void PassSequenceOfAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;
-  void PassNullableSequenceOfAny(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;
-  void PassOptionalSequenceOfAny(JSContext*, Optional<Sequence<JS::Value> >&) MOZ_DELETE;
-  void PassOptionalNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;
-  void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;
-  void PassSequenceOfSequenceOfAny(JSContext*, Sequence<Sequence<JS::Value> >&) MOZ_DELETE;
-  void PassSequenceOfNullableSequenceOfAny(JSContext*, Sequence<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;
-  void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&) MOZ_DELETE;
-  void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&) MOZ_DELETE;
-  void PassSequenceOfObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
-  void PassSequenceOfNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
-  void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;
-  void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;
+  void PassSequence(Sequence<int32_t> &) = delete;
+  void PassNullableSequence(Nullable< Sequence<int32_t> >&) = delete;
+  void PassOptionalNullableSequenceWithDefaultValue(Nullable< Sequence<int32_t> >&) = delete;
+  void PassSequenceOfAny(JSContext*, Sequence<JS::Value>&) = delete;
+  void PassNullableSequenceOfAny(JSContext*, Nullable<Sequence<JS::Value> >&) = delete;
+  void PassOptionalSequenceOfAny(JSContext*, Optional<Sequence<JS::Value> >&) = delete;
+  void PassOptionalNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<JS::Value> > >&) = delete;
+  void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, Nullable<Sequence<JS::Value> >&) = delete;
+  void PassSequenceOfSequenceOfAny(JSContext*, Sequence<Sequence<JS::Value> >&) = delete;
+  void PassSequenceOfNullableSequenceOfAny(JSContext*, Sequence<Nullable<Sequence<JS::Value> > >&) = delete;
+  void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&) = delete;
+  void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&) = delete;
+  void PassSequenceOfObject(JSContext*, Sequence<JSObject*>&) = delete;
+  void PassSequenceOfNullableObject(JSContext*, Sequence<JSObject*>&) = delete;
+  void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) = delete;
+  void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) = delete;
 
   // Enforce that only const things are passed for optional
-  void PassOptionalByte(Optional<int8_t>&) MOZ_DELETE;
-  void PassOptionalNullableByte(Optional<Nullable<int8_t> >&) MOZ_DELETE;
-  void PassOptionalShort(Optional<int16_t>&) MOZ_DELETE;
-  void PassOptionalLong(Optional<int32_t>&) MOZ_DELETE;
-  void PassOptionalLongLong(Optional<int64_t>&) MOZ_DELETE;
-  void PassOptionalOctet(Optional<uint8_t>&) MOZ_DELETE;
-  void PassOptionalUnsignedShort(Optional<uint16_t>&) MOZ_DELETE;
-  void PassOptionalUnsignedLong(Optional<uint32_t>&) MOZ_DELETE;
-  void PassOptionalUnsignedLongLong(Optional<uint64_t>&) MOZ_DELETE;
-  void PassOptionalSelf(Optional<TestInterface*> &) MOZ_DELETE;
-  void PassOptionalNonNullSelf(Optional<NonNull<TestInterface> >&) MOZ_DELETE;
+  void PassOptionalByte(Optional<int8_t>&) = delete;
+  void PassOptionalNullableByte(Optional<Nullable<int8_t> >&) = delete;
+  void PassOptionalShort(Optional<int16_t>&) = delete;
+  void PassOptionalLong(Optional<int32_t>&) = delete;
+  void PassOptionalLongLong(Optional<int64_t>&) = delete;
+  void PassOptionalOctet(Optional<uint8_t>&) = delete;
+  void PassOptionalUnsignedShort(Optional<uint16_t>&) = delete;
+  void PassOptionalUnsignedLong(Optional<uint32_t>&) = delete;
+  void PassOptionalUnsignedLongLong(Optional<uint64_t>&) = delete;
+  void PassOptionalSelf(Optional<TestInterface*> &) = delete;
+  void PassOptionalNonNullSelf(Optional<NonNull<TestInterface> >&) = delete;
   void PassOptionalOther(Optional<IndirectlyImplementedInterface*>&);
   void PassOptionalNonNullOther(Optional<NonNull<IndirectlyImplementedInterface> >&);
-  void PassOptionalExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;
-  void PassOptionalNonNullExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;
-  void PassOptionalSequence(Optional<Sequence<int32_t> >&) MOZ_DELETE;
-  void PassOptionalNullableSequence(Optional<Nullable<Sequence<int32_t> > >&) MOZ_DELETE;
-  void PassOptionalObjectSequence(Optional<Sequence<OwningNonNull<TestInterface> > >&) MOZ_DELETE;
-  void PassOptionalArrayBuffer(Optional<ArrayBuffer>&) MOZ_DELETE;
-  void PassOptionalNullableArrayBuffer(Optional<ArrayBuffer*>&) MOZ_DELETE;
-  void PassOptionalEnum(Optional<TestEnum>&) MOZ_DELETE;
-  void PassOptionalCallback(JSContext*, Optional<OwningNonNull<TestCallback> >&) MOZ_DELETE;
-  void PassOptionalNullableCallback(JSContext*, Optional<nsRefPtr<TestCallback> >&) MOZ_DELETE;
-  void PassOptionalAny(Optional<JS::Handle<JS::Value> >&) MOZ_DELETE;
+  void PassOptionalExternal(Optional<TestExternalInterface*>&) = delete;
+  void PassOptionalNonNullExternal(Optional<TestExternalInterface*>&) = delete;
+  void PassOptionalSequence(Optional<Sequence<int32_t> >&) = delete;
+  void PassOptionalNullableSequence(Optional<Nullable<Sequence<int32_t> > >&) = delete;
+  void PassOptionalObjectSequence(Optional<Sequence<OwningNonNull<TestInterface> > >&) = delete;
+  void PassOptionalArrayBuffer(Optional<ArrayBuffer>&) = delete;
+  void PassOptionalNullableArrayBuffer(Optional<ArrayBuffer*>&) = delete;
+  void PassOptionalEnum(Optional<TestEnum>&) = delete;
+  void PassOptionalCallback(JSContext*, Optional<OwningNonNull<TestCallback> >&) = delete;
+  void PassOptionalNullableCallback(JSContext*, Optional<nsRefPtr<TestCallback> >&) = delete;
+  void PassOptionalAny(Optional<JS::Handle<JS::Value> >&) = delete;
 
   // And test that string stuff is always const
-  void PassString(nsAString&) MOZ_DELETE;
-  void PassNullableString(nsAString&) MOZ_DELETE;
-  void PassOptionalString(Optional<nsAString>&) MOZ_DELETE;
-  void PassOptionalStringWithDefaultValue(nsAString&) MOZ_DELETE;
-  void PassOptionalNullableString(Optional<nsAString>&) MOZ_DELETE;
-  void PassOptionalNullableStringWithDefaultValue(nsAString&) MOZ_DELETE;
-  void PassVariadicString(Sequence<nsString>&) MOZ_DELETE;
+  void PassString(nsAString&) = delete;
+  void PassNullableString(nsAString&) = delete;
+  void PassOptionalString(Optional<nsAString>&) = delete;
+  void PassOptionalStringWithDefaultValue(nsAString&) = delete;
+  void PassOptionalNullableString(Optional<nsAString>&) = delete;
+  void PassOptionalNullableStringWithDefaultValue(nsAString&) = delete;
+  void PassVariadicString(Sequence<nsString>&) = delete;
 
   // cstrings should be const as well
-  void PassByteString(nsCString&) MOZ_DELETE;
-  void PassNullableByteString(nsCString&) MOZ_DELETE;
-  void PassOptionalByteString(Optional<nsCString>&) MOZ_DELETE;
-  void PassOptionalNullableByteString(Optional<nsCString>&) MOZ_DELETE;
-  void PassVariadicByteString(Sequence<nsCString>&) MOZ_DELETE;
+  void PassByteString(nsCString&) = delete;
+  void PassNullableByteString(nsCString&) = delete;
+  void PassOptionalByteString(Optional<nsCString>&) = delete;
+  void PassOptionalNullableByteString(Optional<nsCString>&) = delete;
+  void PassVariadicByteString(Sequence<nsCString>&) = delete;
 
   // Make sure dictionary arguments are always const
-  void PassDictionary(JSContext*, Dict&) MOZ_DELETE;
-  void PassOtherDictionary(GrandparentDict&) MOZ_DELETE;
-  void PassSequenceOfDictionaries(JSContext*, Sequence<Dict>&) MOZ_DELETE;
-  void PassDictionaryOrLong(JSContext*, Dict&) MOZ_DELETE;
-  void PassDictContainingDict(JSContext*, DictContainingDict&) MOZ_DELETE;
-  void PassDictContainingSequence(DictContainingSequence&) MOZ_DELETE;
+  void PassDictionary(JSContext*, Dict&) = delete;
+  void PassOtherDictionary(GrandparentDict&) = delete;
+  void PassSequenceOfDictionaries(JSContext*, Sequence<Dict>&) = delete;
+  void PassDictionaryOrLong(JSContext*, Dict&) = delete;
+  void PassDictContainingDict(JSContext*, DictContainingDict&) = delete;
+  void PassDictContainingSequence(DictContainingSequence&) = delete;
 
   // Make sure various nullable things are always const
-  void PassNullableEnum(Nullable<TestEnum>&) MOZ_DELETE;
+  void PassNullableEnum(Nullable<TestEnum>&) = delete;
 
   // Make sure unions are always const
-  void PassUnion(JSContext*, ObjectOrLong& arg) MOZ_DELETE;
-  void PassUnionWithNullable(JSContext*, ObjectOrNullOrLong& arg) MOZ_DELETE;
-  void PassNullableUnion(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;
-  void PassOptionalUnion(JSContext*, Optional<ObjectOrLong>&) MOZ_DELETE;
-  void PassOptionalNullableUnion(JSContext*, Optional<Nullable<ObjectOrLong> >&) MOZ_DELETE;
-  void PassOptionalNullableUnionWithDefaultValue(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;
+  void PassUnion(JSContext*, ObjectOrLong& arg) = delete;
+  void PassUnionWithNullable(JSContext*, ObjectOrNullOrLong& arg) = delete;
+  void PassNullableUnion(JSContext*, Nullable<ObjectOrLong>&) = delete;
+  void PassOptionalUnion(JSContext*, Optional<ObjectOrLong>&) = delete;
+  void PassOptionalNullableUnion(JSContext*, Optional<Nullable<ObjectOrLong> >&) = delete;
+  void PassOptionalNullableUnionWithDefaultValue(JSContext*, Nullable<ObjectOrLong>&) = delete;
 
   // Make sure various date stuff is const as needed
-  void PassNullableDate(Nullable<Date>&) MOZ_DELETE;
-  void PassOptionalDate(Optional<Date>&) MOZ_DELETE;
-  void PassOptionalNullableDate(Optional<Nullable<Date> >&) MOZ_DELETE;
-  void PassOptionalNullableDateWithDefaultValue(Nullable<Date>&) MOZ_DELETE;
-  void PassDateSequence(Sequence<Date>&) MOZ_DELETE;
-  void PassNullableDateSequence(Sequence<Nullable<Date> >&) MOZ_DELETE;
+  void PassNullableDate(Nullable<Date>&) = delete;
+  void PassOptionalDate(Optional<Date>&) = delete;
+  void PassOptionalNullableDate(Optional<Nullable<Date> >&) = delete;
+  void PassOptionalNullableDateWithDefaultValue(Nullable<Date>&) = delete;
+  void PassDateSequence(Sequence<Date>&) = delete;
+  void PassNullableDateSequence(Sequence<Nullable<Date> >&) = delete;
 
   // Make sure variadics are const as needed
-  void PassVariadicAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;
-  void PassVariadicObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
-  void PassVariadicNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
+  void PassVariadicAny(JSContext*, Sequence<JS::Value>&) = delete;
+  void PassVariadicObject(JSContext*, Sequence<JSObject*>&) = delete;
+  void PassVariadicNullableObject(JSContext*, Sequence<JSObject*>&) = delete;
 
   // Ensure NonNull does not leak in
-  void PassSelf(NonNull<TestInterface>&) MOZ_DELETE;
-  void PassSelf(OwningNonNull<TestInterface>&) MOZ_DELETE;
-  void PassSelf(const NonNull<TestInterface>&) MOZ_DELETE;
-  void PassSelf(const OwningNonNull<TestInterface>&) MOZ_DELETE;
-  void PassOther(NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
-  void PassOther(const NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
-  void PassOther(OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
-  void PassOther(const OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
-  void PassCallbackInterface(OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;
-  void PassCallbackInterface(const OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;
-  void PassCallbackInterface(NonNull<TestCallbackInterface>&) MOZ_DELETE;
-  void PassCallbackInterface(const NonNull<TestCallbackInterface>&) MOZ_DELETE;
-  void PassCallback(OwningNonNull<TestCallback>&) MOZ_DELETE;
-  void PassCallback(const OwningNonNull<TestCallback>&) MOZ_DELETE;
-  void PassCallback(NonNull<TestCallback>&) MOZ_DELETE;
-  void PassCallback(const NonNull<TestCallback>&) MOZ_DELETE;
-  void PassString(const NonNull<nsAString>&) MOZ_DELETE;
-  void PassString(NonNull<nsAString>&) MOZ_DELETE;
-  void PassString(const OwningNonNull<nsAString>&) MOZ_DELETE;
-  void PassString(OwningNonNull<nsAString>&) MOZ_DELETE;
+  void PassSelf(NonNull<TestInterface>&) = delete;
+  void PassSelf(OwningNonNull<TestInterface>&) = delete;
+  void PassSelf(const NonNull<TestInterface>&) = delete;
+  void PassSelf(const OwningNonNull<TestInterface>&) = delete;
+  void PassOther(NonNull<IndirectlyImplementedInterface>&) = delete;
+  void PassOther(const NonNull<IndirectlyImplementedInterface>&) = delete;
+  void PassOther(OwningNonNull<IndirectlyImplementedInterface>&) = delete;
+  void PassOther(const OwningNonNull<IndirectlyImplementedInterface>&) = delete;
+  void PassCallbackInterface(OwningNonNull<TestCallbackInterface>&) = delete;
+  void PassCallbackInterface(const OwningNonNull<TestCallbackInterface>&) = delete;
+  void PassCallbackInterface(NonNull<TestCallbackInterface>&) = delete;
+  void PassCallbackInterface(const NonNull<TestCallbackInterface>&) = delete;
+  void PassCallback(OwningNonNull<TestCallback>&) = delete;
+  void PassCallback(const OwningNonNull<TestCallback>&) = delete;
+  void PassCallback(NonNull<TestCallback>&) = delete;
+  void PassCallback(const NonNull<TestCallback>&) = delete;
+  void PassString(const NonNull<nsAString>&) = delete;
+  void PassString(NonNull<nsAString>&) = delete;
+  void PassString(const OwningNonNull<nsAString>&) = delete;
+  void PassString(OwningNonNull<nsAString>&) = delete;
 };
 
 class TestIndexedGetterInterface : public nsISupports,
                                    public nsWrapperCache
 {
 public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   uint32_t IndexedGetter(uint32_t, bool&);
-  uint32_t IndexedGetter(uint32_t&) MOZ_DELETE;
+  uint32_t IndexedGetter(uint32_t&) = delete;
   uint32_t Item(uint32_t&);
-  uint32_t Item(uint32_t, bool&) MOZ_DELETE;
+  uint32_t Item(uint32_t, bool&) = delete;
   uint32_t Length();
   void LegacyCall(JS::Handle<JS::Value>);
 };
 
 class TestNamedGetterInterface : public nsISupports,
                                  public nsWrapperCache
 {
 public:
@@ -1183,17 +1183,17 @@ class TestIndexedAndNamedGetterAndSetter
 {
 public:
   uint32_t IndexedGetter(uint32_t, bool&);
   uint32_t Item(uint32_t);
   void NamedGetter(const nsAString&, bool&, nsAString&);
   bool NameIsEnumerable(const nsAString&);
   void NamedItem(const nsAString&, nsAString&);
   void IndexedSetter(uint32_t, int32_t&);
-  void IndexedSetter(uint32_t, const nsAString&) MOZ_DELETE;
+  void IndexedSetter(uint32_t, const nsAString&) = delete;
   void NamedSetter(const nsAString&, const nsAString&);
   void Stringify(nsAString&);
   uint32_t Length();
   void GetSupportedNames(unsigned, nsTArray<nsString>&);
 };
 
 class TestCppKeywordNamedMethodsInterface : public nsISupports,
                                             public nsWrapperCache
@@ -1214,38 +1214,38 @@ class TestIndexedDeleterInterface : publ
 {
 public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   void IndexedDeleter(uint32_t, bool&);
-  void IndexedDeleter(uint32_t) MOZ_DELETE;
+  void IndexedDeleter(uint32_t) = delete;
   long IndexedGetter(uint32_t, bool&);
   uint32_t Length();
   void DelItem(uint32_t);
-  void DelItem(uint32_t, bool&) MOZ_DELETE;
+  void DelItem(uint32_t, bool&) = delete;
 };
 
 class TestIndexedDeleterWithRetvalInterface : public nsISupports,
                                               public nsWrapperCache
 {
 public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   bool IndexedDeleter(uint32_t, bool&);
-  bool IndexedDeleter(uint32_t) MOZ_DELETE;
+  bool IndexedDeleter(uint32_t) = delete;
   long IndexedGetter(uint32_t, bool&);
   uint32_t Length();
   bool DelItem(uint32_t);
-  bool DelItem(uint32_t, bool&) MOZ_DELETE;
+  bool DelItem(uint32_t, bool&) = delete;
 };
 
 class TestNamedDeleterInterface : public nsISupports,
                                   public nsWrapperCache
 {
 public:
   NS_DECL_ISUPPORTS
 
@@ -1263,21 +1263,21 @@ class TestNamedDeleterWithRetvalInterfac
 {
 public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   bool NamedDeleter(const nsAString&, bool&);
-  bool NamedDeleter(const nsAString&) MOZ_DELETE;
+  bool NamedDeleter(const nsAString&) = delete;
   long NamedGetter(const nsAString&, bool&);
   bool NameIsEnumerable(const nsAString&);
   bool DelNamedItem(const nsAString&);
-  bool DelNamedItem(const nsAString&, bool&) MOZ_DELETE;
+  bool DelNamedItem(const nsAString&, bool&) = delete;
   void GetSupportedNames(unsigned, nsTArray<nsString>&);
 };
 
 class TestIndexedAndNamedDeleterInterface : public nsISupports,
                                             public nsWrapperCache
 {
 public:
   NS_DECL_ISUPPORTS
@@ -1285,21 +1285,21 @@ public:
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   void IndexedDeleter(uint32_t, bool&);
   long IndexedGetter(uint32_t, bool&);
   uint32_t Length();
 
   void NamedDeleter(const nsAString&, bool&);
-  void NamedDeleter(const nsAString&) MOZ_DELETE;
+  void NamedDeleter(const nsAString&) = delete;
   long NamedGetter(const nsAString&, bool&);
   bool NameIsEnumerable(const nsAString&);
   void DelNamedItem(const nsAString&);
-  void DelNamedItem(const nsAString&, bool&) MOZ_DELETE;
+  void DelNamedItem(const nsAString&, bool&) = delete;
   void GetSupportedNames(unsigned, nsTArray<nsString>&);
 };
 
 class TestParentInterface : public nsISupports,
                             public nsWrapperCache
 {
 public:
   NS_DECL_ISUPPORTS
--- a/dom/camera/CameraControlImpl.h
+++ b/dom/camera/CameraControlImpl.h
@@ -126,15 +126,15 @@ protected:
 
   CameraControlListener::CameraListenerConfiguration mCurrentConfiguration;
 
   CameraControlListener::PreviewState   mPreviewState;
   CameraControlListener::HardwareState  mHardwareState;
   nsresult                              mHardwareStateChangeReason;
 
 private:
-  CameraControlImpl(const CameraControlImpl&) MOZ_DELETE;
-  CameraControlImpl& operator=(const CameraControlImpl&) MOZ_DELETE;
+  CameraControlImpl(const CameraControlImpl&) = delete;
+  CameraControlImpl& operator=(const CameraControlImpl&) = delete;
 };
 
 } // namespace mozilla
 
 #endif // DOM_CAMERA_CAMERACONTROLIMPL_H
--- a/dom/camera/DOMCameraControl.h
+++ b/dom/camera/DOMCameraControl.h
@@ -229,17 +229,17 @@ protected:
 #ifdef MOZ_WIDGET_GONK
   // cached camera control, to improve start-up time
   static StaticRefPtr<ICameraControl> sCachedCameraControl;
   static nsresult sCachedCameraControlStartResult;
   static nsCOMPtr<nsITimer> sDiscardCachedCameraControlTimer;
 #endif
 
 private:
-  nsDOMCameraControl(const nsDOMCameraControl&) MOZ_DELETE;
-  nsDOMCameraControl& operator=(const nsDOMCameraControl&) MOZ_DELETE;
+  nsDOMCameraControl(const nsDOMCameraControl&) = delete;
+  nsDOMCameraControl& operator=(const nsDOMCameraControl&) = delete;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsDOMCameraControl, NS_DOM_CAMERA_CONTROL_CID)
 
 } // namespace mozilla
 
 #endif // DOM_CAMERA_DOMCAMERACONTROL_H
--- a/dom/camera/DOMCameraControlListener.h
+++ b/dom/camera/DOMCameraControlListener.h
@@ -36,15 +36,15 @@ protected:
   virtual ~DOMCameraControlListener();
 
   nsMainThreadPtrHandle<nsISupports> mDOMCameraControl;
   CameraPreviewMediaStream* mStream;
 
   class DOMCallback;
 
 private:
-  DOMCameraControlListener(const DOMCameraControlListener&) MOZ_DELETE;
-  DOMCameraControlListener& operator=(const DOMCameraControlListener&) MOZ_DELETE;
+  DOMCameraControlListener(const DOMCameraControlListener&) = delete;
+  DOMCameraControlListener& operator=(const DOMCameraControlListener&) = delete;
 };
 
 } // namespace mozilla
 
 #endif // DOM_CAMERA_DOMCAMERACONTROLLISTENER_H
--- a/dom/camera/DOMCameraManager.h
+++ b/dom/camera/DOMCameraManager.h
@@ -81,20 +81,20 @@ public:
 #endif
 
 protected:
   void XpComShutdown();
   void Shutdown(uint64_t aWindowId);
   ~nsDOMCameraManager();
 
 private:
-  nsDOMCameraManager() MOZ_DELETE;
+  nsDOMCameraManager() = delete;
   explicit nsDOMCameraManager(nsPIDOMWindow* aWindow);
-  nsDOMCameraManager(const nsDOMCameraManager&) MOZ_DELETE;
-  nsDOMCameraManager& operator=(const nsDOMCameraManager&) MOZ_DELETE;
+  nsDOMCameraManager(const nsDOMCameraManager&) = delete;
+  nsDOMCameraManager& operator=(const nsDOMCameraManager&) = delete;
 
 protected:
   uint64_t mWindowId;
   uint32_t mPermission;
   nsCOMPtr<nsPIDOMWindow> mWindow;
   /**
    * 'sActiveWindows' is only ever accessed while in the Main Thread,
    * so it is not otherwise protected.
--- a/dom/camera/FallbackCameraControl.cpp
+++ b/dom/camera/FallbackCameraControl.cpp
@@ -63,11 +63,11 @@ protected:
   virtual nsresult StartRecordingImpl(DeviceStorageFileDescriptor* aFileDescriptor,
                                       const StartRecordingOptions* aOptions = nullptr) MOZ_OVERRIDE
                                         { return NS_ERROR_NOT_INITIALIZED; }
   virtual nsresult StopRecordingImpl() MOZ_OVERRIDE { return NS_ERROR_NOT_INITIALIZED; }
   virtual nsresult PushParametersImpl() MOZ_OVERRIDE { return NS_ERROR_NOT_INITIALIZED; }
   virtual nsresult PullParametersImpl() MOZ_OVERRIDE { return NS_ERROR_NOT_INITIALIZED; }
 
 private:
-  FallbackCameraControl(const FallbackCameraControl&) MOZ_DELETE;
-  FallbackCameraControl& operator=(const FallbackCameraControl&) MOZ_DELETE;
+  FallbackCameraControl(const FallbackCameraControl&) = delete;
+  FallbackCameraControl& operator=(const FallbackCameraControl&) = delete;
 };
--- a/dom/camera/GonkCameraControl.h
+++ b/dom/camera/GonkCameraControl.h
@@ -188,18 +188,18 @@ protected:
 
   nsRefPtr<DeviceStorageFile> mVideoFile;
   nsString                  mFileFormat;
 
   // Guards against calling StartPreviewImpl() while in OnTakePictureComplete().
   ReentrantMonitor          mReentrantMonitor;
 
 private:
-  nsGonkCameraControl(const nsGonkCameraControl&) MOZ_DELETE;
-  nsGonkCameraControl& operator=(const nsGonkCameraControl&) MOZ_DELETE;
+  nsGonkCameraControl(const nsGonkCameraControl&) = delete;
+  nsGonkCameraControl& operator=(const nsGonkCameraControl&) = delete;
 };
 
 // camera driver callbacks
 void OnRateLimitPreview(nsGonkCameraControl* gc, bool aLimit);
 void OnTakePictureComplete(nsGonkCameraControl* gc, uint8_t* aData, uint32_t aLength);
 void OnTakePictureError(nsGonkCameraControl* gc);
 void OnAutoFocusComplete(nsGonkCameraControl* gc, bool aSuccess);
 void OnAutoFocusMoving(nsGonkCameraControl* gc, bool aIsMoving);
--- a/dom/camera/GonkCameraHwMgr.h
+++ b/dom/camera/GonkCameraHwMgr.h
@@ -119,15 +119,15 @@ protected:
   sp<Camera>                    mCamera;
   mozilla::nsGonkCameraControl* mTarget;
   sp<GonkNativeWindow>          mNativeWindow;
   sp<GonkCameraListener>        mListener;
   int                           mRawSensorOrientation;
   int                           mSensorOrientation;
 
 private:
-  GonkCameraHardware(const GonkCameraHardware&) MOZ_DELETE;
-  GonkCameraHardware& operator=(const GonkCameraHardware&) MOZ_DELETE;
+  GonkCameraHardware(const GonkCameraHardware&) = delete;
+  GonkCameraHardware& operator=(const GonkCameraHardware&) = delete;
 };
 
 } // namespace android
 
 #endif // GONK_IMPL_HW_MGR_H
--- a/dom/camera/TestGonkCameraControl.h
+++ b/dom/camera/TestGonkCameraControl.h
@@ -54,18 +54,18 @@ protected:
   virtual nsresult StartRecordingImpl(DeviceStorageFileDescriptor* aFileDescriptor,
                                       const StartRecordingOptions* aOptions = nullptr) MOZ_OVERRIDE;
   virtual nsresult StopRecordingImpl() MOZ_OVERRIDE;
 
   nsresult ForceMethodFailWithCodeInternal(const char* aFile, int aLine);
   nsresult ForceAsyncFailWithCodeInternal(const char* aFile, int aLine);
 
 private:
-  TestGonkCameraControl(const TestGonkCameraControl&) MOZ_DELETE;
-  TestGonkCameraControl& operator=(const TestGonkCameraControl&) MOZ_DELETE;
+  TestGonkCameraControl(const TestGonkCameraControl&) = delete;
+  TestGonkCameraControl& operator=(const TestGonkCameraControl&) = delete;
 };
 
 #define ForceMethodFailWithCode() ForceMethodFailWithCodeInternal(__FILE__, __LINE__)
 #define ForceAsyncFailWithCode()  ForceAsyncFailWithCodeInternal(__FILE__, __LINE__)
 
 } // namespace mozilla
 
 #endif // DOM_CAMERA_TESTGONKCAMERACONTROL_H
--- a/dom/camera/TestGonkCameraHardware.h
+++ b/dom/camera/TestGonkCameraHardware.h
@@ -60,17 +60,17 @@ protected:
   const nsCString GetExtraParameters();
   bool IsTestCaseInternal(const char* aTest, const char* aFile, int aLine);
   int TestCaseError(int aDefaultError);
 
   int StartAutoFocusMoving(bool aIsMoving);
   void InjectFakeSystemFailure();
 
 private:
-  TestGonkCameraHardware(const TestGonkCameraHardware&) MOZ_DELETE;
-  TestGonkCameraHardware& operator=(const TestGonkCameraHardware&) MOZ_DELETE;
+  TestGonkCameraHardware(const TestGonkCameraHardware&) = delete;
+  TestGonkCameraHardware& operator=(const TestGonkCameraHardware&) = delete;
 };
 
 #define IsTestCase(test)  IsTestCaseInternal((test), __FILE__, __LINE__)
 
 } // namespace android
 
 #endif // DOM_CAMERA_TESTGONKCAMERAHARDWARE_H
--- a/dom/canvas/ImageData.h
+++ b/dom/canvas/ImageData.h
@@ -74,17 +74,17 @@ public:
   }
 
   JSObject* WrapObject(JSContext* cx);
 
 private:
   void HoldData();
   void DropData();
 
-  ImageData() MOZ_DELETE;
+  ImageData() = delete;
 
   uint32_t mWidth, mHeight;
   JS::Heap<JSObject*> mData;
 };
 
 } // namespace dom
 } // namespace mozilla
 
--- a/dom/cellbroadcast/CellBroadcast.h
+++ b/dom/cellbroadcast/CellBroadcast.h
@@ -36,17 +36,17 @@ public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSICELLBROADCASTLISTENER
 
   NS_REALLY_FORWARD_NSIDOMEVENTTARGET(DOMEventTargetHelper)
 
   static already_AddRefed<CellBroadcast>
   Create(nsPIDOMWindow* aOwner, ErrorResult& aRv);
 
-  CellBroadcast() MOZ_DELETE;
+  CellBroadcast() = delete;
   CellBroadcast(nsPIDOMWindow *aWindow,
                 nsICellBroadcastService* aService);
 
   nsPIDOMWindow*
   GetParentObject() const { return GetOwner(); }
 
   virtual JSObject*
   WrapObject(JSContext* aCx) MOZ_OVERRIDE;
--- a/dom/encoding/EncodingUtils.h
+++ b/dom/encoding/EncodingUtils.h
@@ -134,15 +134,15 @@ public:
    *
    * @param      aEncoding, incoming label describing charset to be decoded.
    * @param      aOutGroup, returning corresponding language group.
    */
   static void LangGroupForEncoding(const nsACString& aEncoding,
                                    nsACString& aOutGroup);
 
 private:
-  EncodingUtils() MOZ_DELETE;
+  EncodingUtils() = delete;
 };
 
 } // dom
 } // mozilla
 
 #endif // mozilla_dom_encodingutils_h_
--- a/dom/events/JSEventHandler.h
+++ b/dom/events/JSEventHandler.h
@@ -138,17 +138,17 @@ public:
   bool operator==(const TypedEventHandler& aOther) const
   {
     return
       Ptr() && aOther.Ptr() &&
       Ptr()->CallbackPreserveColor() == aOther.Ptr()->CallbackPreserveColor();
   }
 
 private:
-  void operator=(const TypedEventHandler&) MOZ_DELETE;
+  void operator=(const TypedEventHandler&) = delete;
 
   void ReleaseHandler()
   {
     nsISupports* ptr = Ptr();
     NS_IF_RELEASE(ptr);
   }
 
   void Assign(nsISupports* aHandler, HandlerType aType)
--- a/dom/fetch/FetchDriver.h
+++ b/dom/fetch/FetchDriver.h
@@ -35,19 +35,19 @@ public:
   explicit FetchDriver(InternalRequest* aRequest);
   NS_IMETHOD Fetch(FetchDriverObserver* aObserver);
 
 private:
   nsRefPtr<InternalRequest> mRequest;
   nsRefPtr<FetchDriverObserver> mObserver;
   uint32_t mFetchRecursionCount;
 
-  FetchDriver() MOZ_DELETE;
-  FetchDriver(const FetchDriver&) MOZ_DELETE;
-  FetchDriver& operator=(const FetchDriver&) MOZ_DELETE;
+  FetchDriver() = delete;
+  FetchDriver(const FetchDriver&) = delete;
+  FetchDriver& operator=(const FetchDriver&) = delete;
   ~FetchDriver();
 
   nsresult Fetch(bool aCORSFlag);
   nsresult ContinueFetch(bool aCORSFlag);
   nsresult BasicFetch();
   nsresult FailWithNetworkError();
   nsresult BeginResponse(InternalResponse* aResponse);
   nsresult SucceedWithResponse();
--- a/dom/fetch/Headers.h
+++ b/dom/fetch/Headers.h
@@ -48,17 +48,17 @@ private:
 
 public:
   explicit Headers(nsISupports* aOwner, InternalHeaders* aInternalHeaders)
     : mOwner(aOwner)
     , mInternalHeaders(aInternalHeaders)
   {
   }
 
-  explicit Headers(const Headers& aOther) MOZ_DELETE;
+  explicit Headers(const Headers& aOther) = delete;
 
   static bool PrefEnabled(JSContext* cx, JSObject* obj);
 
   static already_AddRefed<Headers>
   Constructor(const GlobalObject& aGlobal,
               const Optional<HeadersOrByteStringSequenceSequenceOrByteStringMozMap>& aInit,
               ErrorResult& aRv);
 
--- a/dom/fetch/Response.h
+++ b/dom/fetch/Response.h
@@ -29,17 +29,17 @@ class Response MOZ_FINAL : public nsISup
                          , public FetchBody<Response>
 {
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Response)
 
 public:
   Response(nsIGlobalObject* aGlobal, InternalResponse* aInternalResponse);
 
-  Response(const Response& aOther) MOZ_DELETE;
+  Response(const Response& aOther) = delete;
 
   JSObject*
   WrapObject(JSContext* aCx) MOZ_OVERRIDE
   {
     return ResponseBinding::Wrap(aCx, this);
   }
 
   ResponseType
--- a/dom/indexedDB/ActorsChild.h
+++ b/dom/indexedDB/ActorsChild.h
@@ -123,18 +123,18 @@ public:
 
     return mCurrentTransaction;
   }
 
 private:
   explicit ThreadLocal(const nsID& aBackgroundChildLoggingId);
   ~ThreadLocal();
 
-  ThreadLocal() MOZ_DELETE;
-  ThreadLocal(const ThreadLocal& aOther) MOZ_DELETE;
+  ThreadLocal() = delete;
+  ThreadLocal(const ThreadLocal& aOther) = delete;
 };
 
 class BackgroundFactoryChild MOZ_FINAL
   : public PBackgroundIDBFactoryChild
 {
   friend class mozilla::ipc::BackgroundChildImpl;
   friend class IDBFactory;
 
@@ -188,17 +188,17 @@ private:
                                    PBackgroundIDBFactoryRequestChild* aRequest)
                                    MOZ_OVERRIDE;
 
   virtual bool
   DeallocPBackgroundIDBDatabaseChild(PBackgroundIDBDatabaseChild* aActor)
                                      MOZ_OVERRIDE;
 
   bool
-  SendDeleteMe() MOZ_DELETE;
+  SendDeleteMe() = delete;
 };
 
 class BackgroundDatabaseChild;
 
 class BackgroundRequestChildBase
 {
 protected:
   nsRefPtr<IDBRequest> mRequest;
@@ -391,17 +391,17 @@ private:
   RecvVersionChange(const uint64_t& aOldVersion,
                     const NullableVersion& aNewVersion)
                     MOZ_OVERRIDE;
 
   virtual bool
   RecvInvalidate() MOZ_OVERRIDE;
 
   bool
-  SendDeleteMe() MOZ_DELETE;
+  SendDeleteMe() = delete;
 };
 
 class BackgroundVersionChangeTransactionChild;
 
 class BackgroundTransactionBase
 {
   friend class BackgroundVersionChangeTransactionChild;
 
@@ -491,17 +491,17 @@ private:
   virtual PBackgroundIDBCursorChild*
   AllocPBackgroundIDBCursorChild(const OpenCursorParams& aParams) MOZ_OVERRIDE;
 
   virtual bool
   DeallocPBackgroundIDBCursorChild(PBackgroundIDBCursorChild* aActor)
                                    MOZ_OVERRIDE;
 
   bool
-  SendDeleteMe() MOZ_DELETE;
+  SendDeleteMe() = delete;
 };
 
 class BackgroundVersionChangeTransactionChild MOZ_FINAL
   : public BackgroundTransactionBase
   , public PBackgroundIDBVersionChangeTransactionChild
 {
   friend class BackgroundDatabaseChild;
 
@@ -547,17 +547,17 @@ private:
   virtual PBackgroundIDBCursorChild*
   AllocPBackgroundIDBCursorChild(const OpenCursorParams& aParams) MOZ_OVERRIDE;
 
   virtual bool
   DeallocPBackgroundIDBCursorChild(PBackgroundIDBCursorChild* aActor)
                                    MOZ_OVERRIDE;
 
   bool
-  SendDeleteMe() MOZ_DELETE;
+  SendDeleteMe() = delete;
 };
 
 class BackgroundRequestChild MOZ_FINAL
   : public BackgroundRequestChildBase
   , public PBackgroundIDBRequestChild
 {
   friend class BackgroundTransactionChild;
   friend class BackgroundVersionChangeTransactionChild;
@@ -714,20 +714,20 @@ private:
   virtual void
   ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
 
   virtual bool
   RecvResponse(const CursorResponse& aResponse) MOZ_OVERRIDE;
 
   // Force callers to use SendContinueInternal.
   bool
-  SendContinue(const CursorRequestParams& aParams) MOZ_DELETE;
+  SendContinue(const CursorRequestParams& aParams) = delete;
 
   bool
-  SendDeleteMe() MOZ_DELETE;
+  SendDeleteMe() = delete;
 };
 
 // XXX This doesn't belong here. However, we're not yet porting MutableFile
 //     stuff to PBackground so this is necessary for the time being.
 void
 DispatchMutableFileResult(IDBRequest* aRequest,
                           nsresult aResultCode,
                           IDBMutableFile* aMutableFile);
--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -3694,18 +3694,18 @@ private:
     mStatement = aStatement;
 
     if (mStatement) {
       mScoper.emplace(mStatement);
     }
   }
 
   // No funny business allowed.
-  CachedStatement(const CachedStatement&) MOZ_DELETE;
-  CachedStatement& operator=(const CachedStatement&) MOZ_DELETE;
+  CachedStatement(const CachedStatement&) = delete;
+  CachedStatement& operator=(const CachedStatement&) = delete;
 };
 
 class NormalTransaction MOZ_FINAL
   : public TransactionBase
   , public PBackgroundIDBTransactionParent
 {
   friend class Database;
 
@@ -4893,17 +4893,17 @@ private:
   Start(const OpenCursorParams& aParams);
 
   void
   SendResponseInternal(CursorResponse& aResponse,
                        const nsTArray<StructuredCloneFile>& aFiles);
 
   // Must call SendResponseInternal!
   bool
-  SendResponse(const CursorResponse& aResponse) MOZ_DELETE;
+  SendResponse(const CursorResponse& aResponse) = delete;
 
   // IPDL methods.
   virtual void
   ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
 
   virtual bool
   RecvDeleteMe() MOZ_OVERRIDE;
 
--- a/dom/ipc/TabContext.h
+++ b/dom/ipc/TabContext.h
@@ -271,18 +271,18 @@ public:
   /**
    * If IsValid(), this function returns a reference to a TabContext
    * corresponding to the IPCTabContext passed to our constructor.  If
    * !IsValid(), this function crashes.
    */
   const TabContext& GetTabContext();
 
 private:
-  MaybeInvalidTabContext(const MaybeInvalidTabContext&) MOZ_DELETE;
-  MaybeInvalidTabContext& operator=(const MaybeInvalidTabContext&) MOZ_DELETE;
+  MaybeInvalidTabContext(const MaybeInvalidTabContext&) = delete;
+  MaybeInvalidTabContext& operator=(const MaybeInvalidTabContext&) = delete;
 
   const char* mInvalidReason;
   MutableTabContext mTabContext;
 };
 
 } // namespace dom
 } // namespace mozilla
 
--- a/dom/media/MediaRecorder.h
+++ b/dom/media/MediaRecorder.h
@@ -102,29 +102,29 @@ public:
   IMPL_EVENT_HANDLER(stop)
   IMPL_EVENT_HANDLER(warning)
 
   NS_DECL_NSIDOCUMENTACTIVITY
 
 protected:
   virtual ~MediaRecorder();
 
-  MediaRecorder& operator = (const MediaRecorder& x) MOZ_DELETE;
+  MediaRecorder& operator = (const MediaRecorder& x) = delete;
   // Create dataavailable event with Blob data and it runs in main thread
   nsresult CreateAndDispatchBlobEvent(already_AddRefed<nsIDOMBlob>&& aBlob);
   // Creating a simple event to notify UA simple event.
   void DispatchSimpleEvent(const nsAString & aStr);
   // Creating a error event with message.
   void NotifyError(nsresult aRv);
   // Check if the recorder's principal is the subsume of mediaStream
   bool CheckPrincipal();
   // Set encoded MIME type.
   void SetMimeType(const nsString &aMimeType);
 
-  MediaRecorder(const MediaRecorder& x) MOZ_DELETE; // prevent bad usage
+  MediaRecorder(const MediaRecorder& x) = delete; // prevent bad usage
   // Remove session pointer.
   void RemoveSession(Session* aSession);
   // Functions for Session to query input source info.
   MediaStream* GetSourceMediaStream();
   nsIPrincipal* GetSourcePrincipal();
   // DOM wrapper for source media stream. Will be null when input is audio node.
   nsRefPtr<DOMMediaStream> mDOMStream;
   // Source audio node. Will be null when input is a media stream.
--- a/dom/media/SelfRef.h
+++ b/dom/media/SelfRef.h
@@ -32,16 +32,16 @@ public:
     if (mHeld) {
       mHeld = false;
       t->Release();
     }
   }
 
   operator bool() const { return mHeld; }
 
-  SelfReference(const SelfReference& aOther) MOZ_DELETE;
-  void operator=(const SelfReference& aOther) MOZ_DELETE;
+  SelfReference(const SelfReference& aOther) = delete;
+  void operator=(const SelfReference& aOther) = delete;
 private:
   bool mHeld;
 };
 } // mozilla
 
 #endif // SELF_REF_H
--- a/dom/media/eme/CDMCaps.h
+++ b/dom/media/eme/CDMCaps.h
@@ -106,15 +106,15 @@ private:
   nsTArray<UsableKey> mUsableKeyIds;
 
   nsTArray<WaitForKeys> mWaitForKeys;
 
   nsTArray<nsRefPtr<nsIRunnable>> mWaitForCaps;
   uint64_t mCaps;
 
   // It is not safe to copy this object.
-  CDMCaps(const CDMCaps&) MOZ_DELETE;
-  CDMCaps& operator=(const CDMCaps&) MOZ_DELETE;
+  CDMCaps(const CDMCaps&) = delete;
+  CDMCaps& operator=(const CDMCaps&) = delete;
 };
 
 } // namespace mozilla
 
 #endif
--- a/dom/media/encoder/fmp4_muxer/ISOMediaBoxes.h
+++ b/dom/media/encoder/fmp4_muxer/ISOMediaBoxes.h
@@ -61,17 +61,17 @@ public:
     ~BoxSizeChecker();
 
     uint32_t ori_size;
     uint32_t box_size;
     ISOControl* mControl;
   };
 
 protected:
-  Box() MOZ_DELETE;
+  Box() = delete;
   Box(const nsACString& aType, ISOControl* aControl);
 
   ISOControl* mControl;
   nsRefPtr<AudioTrackMetadata> mAudioMeta;
   nsRefPtr<VideoTrackMetadata> mVideoMeta;
 };
 
 /**
@@ -89,17 +89,17 @@ public:
 
   // MuxerOperation methods
   nsresult Write() MOZ_OVERRIDE;
 
 protected:
   // FullBox methods
   FullBox(const nsACString& aType, uint8_t aVersion, uint32_t aFlags,
           ISOControl* aControl);
-  FullBox() MOZ_DELETE;
+  FullBox() = delete;
 };
 
 /**
  * The default implementation of the container box.
  * Basically, the container box inherits this class and overrides the
  * constructor only.
  *
  * According to 14496-12 3.1.1 'container box', a container box is
@@ -113,17 +113,17 @@ public:
   nsresult Generate(uint32_t* aBoxSize) MOZ_OVERRIDE;
   nsresult Write() MOZ_OVERRIDE;
   nsresult Find(const nsACString& aType,
                 nsTArray<nsRefPtr<MuxerOperation>>& aOperations) MOZ_OVERRIDE;
 
 protected:
   // DefaultContainerImpl methods
   DefaultContainerImpl(const nsACString& aType, ISOControl* aControl);
-  DefaultContainerImpl() MOZ_DELETE;
+  DefaultContainerImpl() = delete;
 
   nsTArray<nsRefPtr<MuxerOperation>> boxes;
 };
 
 // 14496-12 4.3 'File Type Box'
 // Box type: 'ftyp'
 class FileTypeBox : public Box {
 public:
@@ -497,17 +497,17 @@ public:
 
   // sampleentrybox methods
   SampleEntryBox(const nsACString& aFormat, ISOControl* aControl);
 
   // MuxerOperation methods
   nsresult Write() MOZ_OVERRIDE;
 
 protected:
-  SampleEntryBox() MOZ_DELETE;
+  SampleEntryBox() = delete;
 };
 
 // 14496-12 8.5.2 'Sample Description Box'
 // Box type: 'stsd'
 class SampleDescriptionBox : public FullBox {
 public:
   // ISO BMFF members
   uint32_t entry_count;
--- a/dom/media/fmp4/gonk/GonkVideoDecoderManager.h
+++ b/dom/media/fmp4/gonk/GonkVideoDecoderManager.h
@@ -76,38 +76,38 @@ private:
   public:
     MessageHandler(GonkVideoDecoderManager *aManager);
     ~MessageHandler();
 
     virtual void onMessageReceived(const android::sp<android::AMessage> &aMessage);
 
   private:
     // Forbidden
-    MessageHandler() MOZ_DELETE;
-    MessageHandler(const MessageHandler &rhs) MOZ_DELETE;
-    const MessageHandler &operator=(const MessageHandler &rhs) MOZ_DELETE;
+    MessageHandler() = delete;
+    MessageHandler(const MessageHandler &rhs) = delete;
+    const MessageHandler &operator=(const MessageHandler &rhs) = delete;
 
     GonkVideoDecoderManager *mManager;
   };
   friend class MessageHandler;
 
   class VideoResourceListener : public android::MediaCodecProxy::CodecResourceListener
   {
   public:
     VideoResourceListener(GonkVideoDecoderManager *aManager);
     ~VideoResourceListener();
 
     virtual void codecReserved() MOZ_OVERRIDE;
     virtual void codecCanceled() MOZ_OVERRIDE;
 
   private:
     // Forbidden
-    VideoResourceListener() MOZ_DELETE;
-    VideoResourceListener(const VideoResourceListener &rhs) MOZ_DELETE;
-    const VideoResourceListener &operator=(const VideoResourceListener &rhs) MOZ_DELETE;
+    VideoResourceListener() = delete;
+    VideoResourceListener(const VideoResourceListener &rhs) = delete;
+    const VideoResourceListener &operator=(const VideoResourceListener &rhs) = delete;
 
     GonkVideoDecoderManager *mManager;
   };
   friend class VideoResourceListener;
 
   // FrameTimeInfo keeps the presentation time stamp (pts) and its duration.
   // On MediaDecoderStateMachine, it needs pts and duration to display decoded
   // frame correctly. But OMX can carry one field of time info (kKeyTime) so
--- a/dom/media/omx/I420ColorConverterHelper.h
+++ b/dom/media/omx/I420ColorConverterHelper.h
@@ -50,15 +50,15 @@ private:
   II420ColorConverter mConverter;
 
   bool loadLocked();
   bool loadedLocked() const;
   void unloadLocked();
 
   bool ensureLoaded();
 
-  I420ColorConverterHelper(const I420ColorConverterHelper &) MOZ_DELETE;
-  const I420ColorConverterHelper &operator=(const I420ColorConverterHelper &) MOZ_DELETE;
+  I420ColorConverterHelper(const I420ColorConverterHelper &) = delete;
+  const I420ColorConverterHelper &operator=(const I420ColorConverterHelper &) = delete;
 };
 
 } // namespace android
 
 #endif // I420_COLOR_CONVERTER_HELPER_H
--- a/dom/media/omx/MediaCodecProxy.h
+++ b/dom/media/omx/MediaCodecProxy.h
@@ -143,19 +143,19 @@ protected:
 
   // MediaResourceHandler::EventListener::resourceReserved()
   virtual void resourceReserved();
   // MediaResourceHandler::EventListener::resourceCanceled()
   virtual void resourceCanceled();
 
 private:
   // Forbidden
-  MediaCodecProxy() MOZ_DELETE;
-  MediaCodecProxy(const MediaCodecProxy &) MOZ_DELETE;
-  const MediaCodecProxy &operator=(const MediaCodecProxy &) MOZ_DELETE;
+  MediaCodecProxy() = delete;
+  MediaCodecProxy(const MediaCodecProxy &) = delete;
+  const MediaCodecProxy &operator=(const MediaCodecProxy &) = delete;
 
   // Constructor for MediaCodecProxy::CreateByType
   MediaCodecProxy(sp<ALooper> aLooper,
                   const char *aMime,
                   bool aEncoder,
                   bool aAsync,
                   wp<CodecResourceListener> aListener);
 
--- a/dom/media/omx/MediaCodecReader.h
+++ b/dom/media/omx/MediaCodecReader.h
@@ -160,18 +160,18 @@ protected:
     bool mOutputEndOfStream;
     int64_t mSeekTimeUs;
     bool mFlushed; // meaningless when mSeekTimeUs is invalid.
     bool mDiscontinuity;
     nsRefPtr<MediaTaskQueue> mTaskQueue;
 
   private:
     // Forbidden
-    Track(const Track &rhs) MOZ_DELETE;
-    const Track &operator=(const Track&) MOZ_DELETE;
+    Track(const Track &rhs) = delete;
+    const Track &operator=(const Track&) = delete;
   };
 
   // Receive a message from MessageHandler.
   // Called on MediaCodecReader::mLooper thread.
   void onMessageReceived(const android::sp<android::AMessage>& aMessage);
 
   // Receive a notify from ResourceListener.
   // Called on Binder thread.
@@ -197,19 +197,19 @@ private:
   public:
     MessageHandler(MediaCodecReader* aReader);
     ~MessageHandler();
 
     virtual void onMessageReceived(const android::sp<android::AMessage>& aMessage);
 
   private:
     // Forbidden
-    MessageHandler() MOZ_DELETE;
-    MessageHandler(const MessageHandler& rhs) MOZ_DELETE;
-    const MessageHandler& operator=(const MessageHandler& rhs) MOZ_DELETE;
+    MessageHandler() = delete;
+    MessageHandler(const MessageHandler& rhs) = delete;
+    const MessageHandler& operator=(const MessageHandler& rhs) = delete;
 
     MediaCodecReader *mReader;
   };
   friend class MessageHandler;
 
   // An intermediary class that can be managed by android::sp<T>.
   // Redirect codecReserved() and codecCanceled() to MediaCodecReader.
   class VideoResourceListener : public android::MediaCodecProxy::CodecResourceListener
@@ -218,19 +218,19 @@ private:
     VideoResourceListener(MediaCodecReader* aReader);
     ~VideoResourceListener();
 
     virtual void codecReserved();
     virtual void codecCanceled();
 
   private:
     // Forbidden
-    VideoResourceListener() MOZ_DELETE;
-    VideoResourceListener(const VideoResourceListener& rhs) MOZ_DELETE;
-    const VideoResourceListener& operator=(const VideoResourceListener& rhs) MOZ_DELETE;
+    VideoResourceListener() = delete;
+    VideoResourceListener(const VideoResourceListener& rhs) = delete;
+    const VideoResourceListener& operator=(const VideoResourceListener& rhs) = delete;
 
     MediaCodecReader* mReader;
   };
   friend class VideoResourceListener;
 
   class VorbisInputCopier : public TrackInputCopier
   {
     virtual bool Copy(android::MediaBuffer* aSourceBuffer,
@@ -238,18 +238,18 @@ private:
   };
 
   struct AudioTrack : public Track
   {
     AudioTrack();
 
   private:
     // Forbidden
-    AudioTrack(const AudioTrack &rhs) MOZ_DELETE;
-    const AudioTrack &operator=(const AudioTrack &rhs) MOZ_DELETE;
+    AudioTrack(const AudioTrack &rhs) = delete;
+    const AudioTrack &operator=(const AudioTrack &rhs) = delete;
   };
 
   struct VideoTrack : public Track
   {
     VideoTrack();
 
     int32_t mWidth;
     int32_t mHeight;
@@ -258,18 +258,18 @@ private:
     int32_t mColorFormat;
     int32_t mRotation;
     nsIntSize mFrameSize;
     nsIntRect mPictureRect;
     gfx::IntRect mRelativePictureRect;
 
   private:
     // Forbidden
-    VideoTrack(const VideoTrack &rhs) MOZ_DELETE;
-    const VideoTrack &operator=(const VideoTrack &rhs) MOZ_DELETE;
+    VideoTrack(const VideoTrack &rhs) = delete;
+    const VideoTrack &operator=(const VideoTrack &rhs) = delete;
   };
 
   struct CodecBufferInfo
   {
     CodecBufferInfo();
 
     android::sp<android::ABuffer> mBuffer;
     size_t mIndex;
@@ -286,19 +286,19 @@ private:
 
     SignalObject(const char* aName);
     ~SignalObject();
     void Wait();
     void Signal();
 
   private:
     // Forbidden
-    SignalObject() MOZ_DELETE;
-    SignalObject(const SignalObject &rhs) MOZ_DELETE;
-    const SignalObject &operator=(const SignalObject &rhs) MOZ_DELETE;
+    SignalObject() = delete;
+    SignalObject(const SignalObject &rhs) = delete;
+    const SignalObject &operator=(const SignalObject &rhs) = delete;
 
     Monitor mMonitor;
     bool mSignaled;
   };
 
   class ParseCachedDataRunnable : public nsRunnable
   {
   public:
@@ -307,19 +307,19 @@ private:
                             uint32_t aLength,
                             int64_t aOffset,
                             nsRefPtr<SignalObject> aSignal);
 
     NS_IMETHOD Run() MOZ_OVERRIDE;
 
   private:
     // Forbidden
-    ParseCachedDataRunnable() MOZ_DELETE;
-    ParseCachedDataRunnable(const ParseCachedDataRunnable &rhs) MOZ_DELETE;
-    const ParseCachedDataRunnable &operator=(const ParseCachedDataRunnable &rhs) MOZ_DELETE;
+    ParseCachedDataRunnable() = delete;
+    ParseCachedDataRunnable(const ParseCachedDataRunnable &rhs) = delete;
+    const ParseCachedDataRunnable &operator=(const ParseCachedDataRunnable &rhs) = delete;
 
     nsRefPtr<MediaCodecReader> mReader;
     nsAutoArrayPtr<const char> mBuffer;
     uint32_t mLength;
     int64_t mOffset;
     nsRefPtr<SignalObject> mSignal;
   };
   friend class ParseCachedDataRunnable;
@@ -329,28 +329,28 @@ private:
   public:
     ProcessCachedDataTask(nsRefPtr<MediaCodecReader> aReader,
                           int64_t aOffset);
 
     void Run() MOZ_OVERRIDE;
 
   private:
     // Forbidden
-    ProcessCachedDataTask() MOZ_DELETE;
-    ProcessCachedDataTask(const ProcessCachedDataTask &rhs) MOZ_DELETE;
-    const ProcessCachedDataTask &operator=(const ProcessCachedDataTask &rhs) MOZ_DELETE;
+    ProcessCachedDataTask() = delete;
+    ProcessCachedDataTask(const ProcessCachedDataTask &rhs) = delete;
+    const ProcessCachedDataTask &operator=(const ProcessCachedDataTask &rhs) = delete;
 
     nsRefPtr<MediaCodecReader> mReader;
     int64_t mOffset;
   };
   friend class ProcessCachedDataTask;
 
   // Forbidden
-  MediaCodecReader() MOZ_DELETE;
-  const MediaCodecReader& operator=(const MediaCodecReader& rhs) MOZ_DELETE;
+  MediaCodecReader() = delete;
+  const MediaCodecReader& operator=(const MediaCodecReader& rhs) = delete;
 
   bool ReallocateResources();
   void ReleaseCriticalResources();
   void ReleaseResources();
 
   bool CreateLooper();
   void DestroyLooper();
 
--- a/dom/media/omx/OMXCodecWrapper.h
+++ b/dom/media/omx/OMXCodecWrapper.h
@@ -167,19 +167,19 @@ protected:
   virtual void AppendFrame(nsTArray<uint8_t>* aOutputBuf,
                            const uint8_t* aData, size_t aSize)
   {
     aOutputBuf->AppendElements(aData, aSize);
   }
 
 private:
   // Hide these. User should always use creator functions to get a media codec.
-  OMXCodecWrapper() MOZ_DELETE;
-  OMXCodecWrapper(const OMXCodecWrapper&) MOZ_DELETE;
-  OMXCodecWrapper& operator=(const OMXCodecWrapper&) MOZ_DELETE;
+  OMXCodecWrapper() = delete;
+  OMXCodecWrapper(const OMXCodecWrapper&) = delete;
+  OMXCodecWrapper& operator=(const OMXCodecWrapper&) = delete;
 
   /**
    * Create a media codec of given type. It will be a AVC/H.264 video encoder if
    * aCodecType is CODEC_AVC_ENC, or AAC audio encoder if aCodecType is
    * CODEC_AAC_ENC.
    */
   OMXCodecWrapper(CodecType aCodecType);
 
@@ -233,19 +233,19 @@ public:
   nsresult Encode(mozilla::AudioSegment& aSegment, int aInputFlags = 0);
 
   ~OMXAudioEncoder();
 protected:
   virtual status_t AppendDecoderConfig(nsTArray<uint8_t>* aOutputBuf,
                                        ABuffer* aData) MOZ_OVERRIDE;
 private:
   // Hide these. User should always use creator functions to get a media codec.
-  OMXAudioEncoder() MOZ_DELETE;
-  OMXAudioEncoder(const OMXAudioEncoder&) MOZ_DELETE;
-  OMXAudioEncoder& operator=(const OMXAudioEncoder&) MOZ_DELETE;
+  OMXAudioEncoder() = delete;
+  OMXAudioEncoder(const OMXAudioEncoder&) = delete;
+  OMXAudioEncoder& operator=(const OMXAudioEncoder&) = delete;
 
   /**
    * Create a audio codec. It will be a AAC encoder if aCodecType is
    * CODEC_AAC_ENC.
    */
   OMXAudioEncoder(CodecType aCodecType)
     : OMXCodecWrapper(aCodecType)
     , mResampler(nullptr)
@@ -326,19 +326,19 @@ protected:
   // If configured to output MP4 format blob, AVC/H.264 encoder has to replace
   // NAL unit start code with the unit length as specified in
   // ISO/IEC 14496-15 5.2.3.
   virtual void AppendFrame(nsTArray<uint8_t>* aOutputBuf,
                            const uint8_t* aData, size_t aSize) MOZ_OVERRIDE;
 
 private:
   // Hide these. User should always use creator functions to get a media codec.
-  OMXVideoEncoder() MOZ_DELETE;
-  OMXVideoEncoder(const OMXVideoEncoder&) MOZ_DELETE;
-  OMXVideoEncoder& operator=(const OMXVideoEncoder&) MOZ_DELETE;
+  OMXVideoEncoder() = delete;
+  OMXVideoEncoder(const OMXVideoEncoder&) = delete;
+  OMXVideoEncoder& operator=(const OMXVideoEncoder&) = delete;
 
   /**
    * Create a video codec. It will be a AVC/H.264 encoder if aCodecType is
    * CODEC_AVC_ENC.
    */
   OMXVideoEncoder(CodecType aCodecType)
     : OMXCodecWrapper(aCodecType)
     , mWidth(0)
--- a/dom/media/omx/mediaresourcemanager/MediaResourceHandler.h
+++ b/dom/media/omx/mediaresourcemanager/MediaResourceHandler.h
@@ -45,19 +45,19 @@ public:
   bool IsWaitingResource();
 
 protected:
   // MediaResourceManagerClient::EventListener::statusChanged()
   virtual void statusChanged(int event);
 
 private:
   // Forbidden
-  MediaResourceHandler() MOZ_DELETE;
-  MediaResourceHandler(const MediaResourceHandler &) MOZ_DELETE;
-  const MediaResourceHandler &operator=(const MediaResourceHandler &) MOZ_DELETE;
+  MediaResourceHandler() = delete;
+  MediaResourceHandler(const MediaResourceHandler &) = delete;
+  const MediaResourceHandler &operator=(const MediaResourceHandler &) = delete;
 
   // Resource Notification Listener
   wp<ResourceListener> mListener;
 
   // Resource Management
   Mutex mLock;
   sp<IMediaResourceManagerClient> mClient;
   sp<IMediaResourceManagerService> mService;
--- a/dom/media/webaudio/FFTBlock.h
+++ b/dom/media/webaudio/FFTBlock.h
@@ -138,18 +138,18 @@ public:
   }
 
   size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
   {
     return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
   }
 
 private:
-  FFTBlock(const FFTBlock& other) MOZ_DELETE;
-  void operator=(const FFTBlock& other) MOZ_DELETE;
+  FFTBlock(const FFTBlock& other) = delete;
+  void operator=(const FFTBlock& other) = delete;
 
   void EnsureFFT()
   {
     if (!mFFT) {
       mFFT = kiss_fftr_alloc(mFFTSize, 0, nullptr, nullptr);
     }
   }
   void EnsureIFFT()
--- a/dom/media/webaudio/blink/HRTFDatabase.h
+++ b/dom/media/webaudio/blink/HRTFDatabase.h
@@ -54,18 +54,18 @@ public:
     float sampleRate() const { return m_sampleRate; }
 
     // Number of elevations loaded from resource.
     static const unsigned NumberOfRawElevations;
 
     size_t sizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
 private:
-    HRTFDatabase(const HRTFDatabase& other) MOZ_DELETE;
-    void operator=(const HRTFDatabase& other) MOZ_DELETE;
+    HRTFDatabase(const HRTFDatabase& other) = delete;
+    void operator=(const HRTFDatabase& other) = delete;
 
     explicit HRTFDatabase(float sampleRate);
 
     // Minimum and maximum elevation angles (inclusive) for a HRTFDatabase.
     static const int MinElevation;
     static const int MaxElevation;
     static const unsigned RawElevationAngleSpacing;
 
--- a/dom/media/webaudio/blink/HRTFElevation.h
+++ b/dom/media/webaudio/blink/HRTFElevation.h
@@ -62,18 +62,18 @@ public:
     // Total number of azimuths after interpolation.
     static const unsigned NumberOfTotalAzimuths;
 
     static size_t fftSizeForSampleRate(float sampleRate);
 
     size_t sizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
 private:
-    HRTFElevation(const HRTFElevation& other) MOZ_DELETE;
-    void operator=(const HRTFElevation& other) MOZ_DELETE;
+    HRTFElevation(const HRTFElevation& other) = delete;
+    void operator=(const HRTFElevation& other) = delete;
 
     HRTFElevation(HRTFKernelList *kernelListL, int elevation, float sampleRate)
         : m_elevationAngle(elevation)
         , m_sampleRate(sampleRate)
     {
         m_kernelListL.SwapElements(*kernelListL);
     }
 
--- a/dom/media/webaudio/blink/HRTFKernel.h
+++ b/dom/media/webaudio/blink/HRTFKernel.h
@@ -68,18 +68,18 @@ public:
     size_t sizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
     {
         size_t amount = aMallocSizeOf(this);
         amount += m_fftFrame->SizeOfIncludingThis(aMallocSizeOf);
         return amount;
     }
 
 private:
-    HRTFKernel(const HRTFKernel& other) MOZ_DELETE;
-    void operator=(const HRTFKernel& other) MOZ_DELETE;
+    HRTFKernel(const HRTFKernel& other) = delete;
+    void operator=(const HRTFKernel& other) = delete;
 
     // Note: this is destructive on the passed in |impulseResponse|.
     HRTFKernel(float* impulseResponse, size_t fftSize, float sampleRate);
     
     HRTFKernel(nsAutoPtr<FFTBlock> fftFrame, float frameDelay, float sampleRate)
         : m_fftFrame(fftFrame)
         , m_frameDelay(frameDelay)
         , m_sampleRate(sampleRate)
--- a/dom/mobileconnection/ipc/MobileConnectionChild.h
+++ b/dom/mobileconnection/ipc/MobileConnectionChild.h
@@ -36,17 +36,17 @@ public:
 
   void
   Init();
 
   void
   Shutdown();
 
 private:
-  MobileConnectionChild() MOZ_DELETE;
+  MobileConnectionChild() = delete;
 
   // MOZ_FINAL suppresses -Werror,-Wdelete-non-virtual-dtor
   ~MobileConnectionChild()
   {
     MOZ_COUNT_DTOR(MobileConnectionChild);
   }
 
 protected:
--- a/dom/mobilemessage/MobileMessageThread.h
+++ b/dom/mobilemessage/MobileMessageThread.h
@@ -44,17 +44,17 @@ public:
                          nsIDOMMozMobileMessageThread** aThread);
 
   const ThreadData& GetData() const { return mData; }
 
 private:
   ~MobileMessageThread() {}
 
   // Don't try to use the default constructor.
-  MobileMessageThread() MOZ_DELETE;
+  MobileMessageThread() = delete;
 
   ThreadData mData;
 };
 
 } // namespace dom
 } // namespace mozilla
 
 #endif // mozilla_dom_mobilemessage_MobileMessageThread_h
--- a/dom/nfc/MozNDEFRecord.h
+++ b/dom/nfc/MozNDEFRecord.h
@@ -84,17 +84,17 @@ public:
   }
 
   uint32_t Size() const
   {
     return mSize;
   }
 
 private:
-  MozNDEFRecord() MOZ_DELETE;
+  MozNDEFRecord() = delete;
   nsRefPtr<nsPIDOMWindow> mWindow;
   void HoldData();
   void DropData();
 
   static bool
   ValidateTNF(const MozNDEFRecordOptions& aOptions, ErrorResult& aRv);
 
   TNF mTnf;
--- a/dom/quota/OriginOrPatternString.h
+++ b/dom/quota/OriginOrPatternString.h
@@ -56,17 +56,17 @@ private:
     mIsOrigin(aIsOrigin), mIsPattern(!aIsOrigin), mIsNull(false)
   { }
 
   OriginOrPatternString()
   : mIsOrigin(false), mIsPattern(false), mIsNull(true)
   { }
 
   bool
-  operator==(const OriginOrPatternString& aOther) MOZ_DELETE;
+  operator==(const OriginOrPatternString& aOther) = delete;
 
   bool mIsOrigin;
   bool mIsPattern;
   bool mIsNull;
 };
 
 END_QUOTA_NAMESPACE
 
--- a/dom/svg/SVGFragmentIdentifier.h
+++ b/dom/svg/SVGFragmentIdentifier.h
@@ -19,17 +19,17 @@ class SVGSVGElement;
 
 /**
  * Implements support for parsing SVG fragment identifiers
  * http://www.w3.org/TR/SVG/linking.html#SVGFragmentIdentifiers
  */
 class SVGFragmentIdentifier
 {
   // To prevent the class being instantiated
-  SVGFragmentIdentifier() MOZ_DELETE;
+  SVGFragmentIdentifier() = delete;
 
 public:
   /**
    * Process the SVG fragment identifier, if there is one.
    * @return true if we found something we recognised
    */
   static bool ProcessFragmentIdentifier(nsIDocument *aDocument,
                                         const nsAString &aAnchorName);
--- a/dom/workers/WorkerPrivate.h
+++ b/dom/workers/WorkerPrivate.h
@@ -1310,19 +1310,19 @@ public:
   static already_AddRefed<ChromeWorkerPrivate>
   Constructor(const GlobalObject& aGlobal, const nsAString& aScriptURL,
               ErrorResult& rv);
 
   static bool
   WorkerAvailable(JSContext* aCx, JSObject* /* unused */);
 
 private:
-  ChromeWorkerPrivate() MOZ_DELETE;
-  ChromeWorkerPrivate(const ChromeWorkerPrivate& aRHS) MOZ_DELETE;
-  ChromeWorkerPrivate& operator =(const ChromeWorkerPrivate& aRHS) MOZ_DELETE;
+  ChromeWorkerPrivate() = delete;
+  ChromeWorkerPrivate(const ChromeWorkerPrivate& aRHS) = delete;
+  ChromeWorkerPrivate& operator =(const ChromeWorkerPrivate& aRHS) = delete;
 };
 
 WorkerPrivate*
 GetWorkerPrivateFromContext(JSContext* aCx);
 
 WorkerPrivate*
 GetCurrentThreadWorkerPrivate();
 
--- a/dom/xul/templates/nsTemplateMatch.h
+++ b/dom/xul/templates/nsTemplateMatch.h
@@ -126,14 +126,14 @@ public:
      * match that has a rule set (mRule) is the active match and generates
      * content. The next match is owned by the builder, which will delete
      * template matches when needed.
      */
     nsTemplateMatch *mNext;
 
 private:
 
-    nsTemplateMatch(const nsTemplateMatch& aMatch) MOZ_DELETE;
-    void operator=(const nsTemplateMatch& aMatch) MOZ_DELETE;
+    nsTemplateMatch(const nsTemplateMatch& aMatch) = delete;
+    void operator=(const nsTemplateMatch& aMatch) = delete;
 };
 
 #endif // nsTemplateMatch_h__
 
--- a/extensions/cookie/nsPermissionManager.h
+++ b/extensions/cookie/nsPermissionManager.h
@@ -98,17 +98,17 @@ public:
     NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PermissionKey)
 
     nsCString mHost;
     uint32_t  mAppId;
     bool      mIsInBrowserElement;
 
   private:
     // Default ctor shouldn't be used.
-    PermissionKey() MOZ_DELETE;
+    PermissionKey() = delete;
 
     // Dtor shouldn't be used outside of the class.
     ~PermissionKey() {};
   };
 
   class PermissionHashKey : public nsRefPtrHashKey<PermissionKey>
   {
   public:
@@ -278,17 +278,17 @@ private:
    * If |browserOnly| is true, only permissions related to a browserElement will
    * be in |permissions|.
    */
   struct GetPermissionsForAppStruct {
     uint32_t                  appId;
     bool                      browserOnly;
     nsCOMArray<nsIPermission> permissions;
 
-    GetPermissionsForAppStruct() MOZ_DELETE;
+    GetPermissionsForAppStruct() = delete;
     GetPermissionsForAppStruct(uint32_t aAppId, bool aBrowserOnly)
       : appId(aAppId)
       , browserOnly(aBrowserOnly)
     {}
   };
 
   /**
    * This method will return the list of all permissions that are related to a
--- a/gfx/gl/HeapCopyOfStackArray.h
+++ b/gfx/gl/HeapCopyOfStackArray.h
@@ -30,18 +30,18 @@ public:
     memcpy(mArrayData, &array[0], N * sizeof(ElemType));
   }
 
   ElemType* Data() const { return mArrayData; }
   size_t ArrayLength() const { return mArrayLength; }
   size_t ByteLength() const { return mArrayLength * sizeof(ElemType); }
 
 private:
-  HeapCopyOfStackArray() MOZ_DELETE;
-  HeapCopyOfStackArray(const HeapCopyOfStackArray&) MOZ_DELETE;
+  HeapCopyOfStackArray() = delete;
+  HeapCopyOfStackArray(const HeapCopyOfStackArray&) = delete;
 
   const size_t mArrayLength;
   ScopedDeletePtr<ElemType> const mArrayData;
 };
 
 }
 
 #endif // HEAPCOPYOFSTACKARRAY_H_
\ No newline at end of file
--- a/gfx/layers/basic/AutoMaskData.h
+++ b/gfx/layers/basic/AutoMaskData.h
@@ -45,16 +45,16 @@ private:
   bool IsConstructed()
   {
     return !!mSurface;
   }
 
   gfx::Matrix mTransform;
   RefPtr<gfx::SourceSurface> mSurface;
 
-  AutoMoz2DMaskData(const AutoMoz2DMaskData&) MOZ_DELETE;
-  AutoMoz2DMaskData& operator=(const AutoMoz2DMaskData&) MOZ_DELETE;
+  AutoMoz2DMaskData(const AutoMoz2DMaskData&) = delete;
+  AutoMoz2DMaskData& operator=(const AutoMoz2DMaskData&) = delete;
 };
 
 }
 }
 
 #endif // GFX_AUTOMASKDATA_H_
--- a/gfx/layers/basic/BasicLayersImpl.h
+++ b/gfx/layers/basic/BasicLayersImpl.h
@@ -5,17 +5,17 @@
 
 #ifndef GFX_BASICLAYERSIMPL_H
 #define GFX_BASICLAYERSIMPL_H
 
 #include "BasicImplData.h"              // for BasicImplData
 #include "BasicLayers.h"                // for BasicLayerManager
 #include "ReadbackLayer.h"              // for ReadbackLayer
 #include "gfxContext.h"                 // for gfxContext, etc
-#include "mozilla/Attributes.h"         // for MOZ_DELETE, MOZ_STACK_CLASS
+#include "mozilla/Attributes.h"         // for MOZ_STACK_CLASS
 #include "mozilla/Maybe.h"              // for Maybe
 #include "nsAutoPtr.h"                  // for nsRefPtr
 #include "nsDebug.h"                    // for NS_ASSERTION
 #include "nsISupportsImpl.h"            // for gfxContext::Release, etc
 #include "nsRegion.h"                   // for nsIntRegion
 
 namespace mozilla {
 namespace gfx {
--- a/gfx/layers/composite/AsyncCompositionManager.h
+++ b/gfx/layers/composite/AsyncCompositionManager.h
@@ -3,17 +3,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef GFX_ASYNCCOMPOSITIONMANAGER_H
 #define GFX_ASYNCCOMPOSITIONMANAGER_H
 
 #include "Units.h"                      // for ScreenPoint, etc
 #include "mozilla/layers/LayerManagerComposite.h"  // for LayerManagerComposite
-#include "mozilla/Attributes.h"         // for MOZ_DELETE, MOZ_FINAL, etc
+#include "mozilla/Attributes.h"         // for MOZ_FINAL, etc
 #include "mozilla/RefPtr.h"             // for RefCounted
 #include "mozilla/TimeStamp.h"          // for TimeStamp
 #include "mozilla/dom/ScreenOrientation.h"  // for ScreenOrientation
 #include "mozilla/gfx/BasePoint.h"      // for BasePoint
 #include "mozilla/gfx/Matrix.h"         // for Matrix4x4
 #include "mozilla/layers/LayersMessages.h"  // for TargetConfig
 #include "nsAutoPtr.h"                  // for nsRefPtr
 #include "nsISupportsImpl.h"            // for LayerManager::AddRef, etc
@@ -222,16 +222,16 @@ public:
     if (mManager) {
       mManager->DetachRefLayers();
     }
   }
 
 private:
   AsyncCompositionManager* mManager;
 
-  AutoResolveRefLayers(const AutoResolveRefLayers&) MOZ_DELETE;
-  AutoResolveRefLayers& operator=(const AutoResolveRefLayers&) MOZ_DELETE;
+  AutoResolveRefLayers(const AutoResolveRefLayers&) = delete;
+  AutoResolveRefLayers& operator=(const AutoResolveRefLayers&) = delete;
 };
 
 } // layers
 } // mozilla
 
 #endif
--- a/gfx/thebes/gfxDWriteFontList.cpp
+++ b/gfx/thebes/gfxDWriteFontList.cpp
@@ -1795,19 +1795,19 @@ public:
     BundledFontFileEnumerator(IDWriteFactory *aFactory,
                               nsIFile        *aFontDir);
 
     IFACEMETHODIMP MoveNext(BOOL * hasCurrentFile);
 
     IFACEMETHODIMP GetCurrentFontFile(IDWriteFontFile ** fontFile);
 
 private:
-    BundledFontFileEnumerator() MOZ_DELETE;
-    BundledFontFileEnumerator(const BundledFontFileEnumerator&) MOZ_DELETE;
-    BundledFontFileEnumerator& operator=(const BundledFontFileEnumerator&) MOZ_DELETE;
+    BundledFontFileEnumerator() = delete;
+    BundledFontFileEnumerator(const BundledFontFileEnumerator&) = delete;
+    BundledFontFileEnumerator& operator=(const BundledFontFileEnumerator&) = delete;
 
     nsRefPtr<IDWriteFactory>      mFactory;
 
     nsCOMPtr<nsIFile>             mFontDir;
     nsCOMPtr<nsISimpleEnumerator> mEntries;
     nsCOMPtr<nsISupports>         mCurrent;
 };
 
@@ -1863,18 +1863,18 @@ public:
 
     IFACEMETHODIMP CreateEnumeratorFromKey(
         IDWriteFactory *aFactory,
         const void *aCollectionKey,
         UINT32 aCollectionKeySize,
         IDWriteFontFileEnumerator **aFontFileEnumerator);
 
 private:
-    BundledFontLoader(const BundledFontLoader&) MOZ_DELETE;
-    BundledFontLoader& operator=(const BundledFontLoader&) MOZ_DELETE;
+    BundledFontLoader(const BundledFontLoader&) = delete;
+    BundledFontLoader& operator=(const BundledFontLoader&) = delete;
 };
 
 IFACEMETHODIMP
 BundledFontLoader::CreateEnumeratorFromKey(
     IDWriteFactory *aFactory,
     const void *aCollectionKey,
     UINT32  aCollectionKeySize,
     IDWriteFontFileEnumerator **aFontFileEnumerator)
--- a/gfx/thebes/gfxFontEntry.h
+++ b/gfx/thebes/gfxFontEntry.h
@@ -302,18 +302,18 @@ public:
             if (mBlob) {
                 hb_blob_destroy(mBlob);
             }
         }
         operator hb_blob_t*() const { return mBlob; }
     private:
         hb_blob_t* mBlob;
         // not implemented:
-        AutoTable(const AutoTable&) MOZ_DELETE;
-        AutoTable& operator=(const AutoTable&) MOZ_DELETE;
+        AutoTable(const AutoTable&) = delete;
+        AutoTable& operator=(const AutoTable&) = delete;
     };
 
     already_AddRefed<gfxFont>
     FindOrMakeFont(const gfxFontStyle *aStyle,
                    bool aNeedsBold,
                    gfxCharacterMap* aUnicodeRangeMap = nullptr);
 
     // Get an existing font table cache entry in aBlob if it has been
--- a/gfx/thebes/gfxFontMissingGlyphs.h
+++ b/gfx/thebes/gfxFontMissingGlyphs.h
@@ -22,17 +22,17 @@ class Pattern;
  */
 class gfxFontMissingGlyphs MOZ_FINAL
 {
     typedef mozilla::gfx::DrawTarget DrawTarget;
     typedef mozilla::gfx::Float Float;
     typedef mozilla::gfx::Pattern Pattern;
     typedef mozilla::gfx::Rect Rect;
 
-    gfxFontMissingGlyphs() MOZ_DELETE; // prevent instantiation
+    gfxFontMissingGlyphs() = delete; // prevent instantiation
 
 public:
     /**
      * Draw hexboxes for a missing glyph.
      * @param aChar the UTF16 codepoint for the character
      * @param aRect the glyph-box for the glyph that is missing
      * @param aDrawTarget the DrawTarget to draw to
      * @param aPattern the pattern currently being used to paint
--- a/gfx/thebes/gfxGlyphExtents.h
+++ b/gfx/thebes/gfxGlyphExtents.h
@@ -132,13 +132,13 @@ private:
     };
 
     GlyphWidths             mContainedGlyphWidths;
     nsTHashtable<HashEntry> mTightGlyphExtents;
     int32_t                 mAppUnitsPerDevUnit;
 
 private:
     // not implemented:
-    gfxGlyphExtents(const gfxGlyphExtents& aOther) MOZ_DELETE;
-    gfxGlyphExtents& operator=(const gfxGlyphExtents& aOther) MOZ_DELETE;
+    gfxGlyphExtents(const gfxGlyphExtents& aOther) = delete;
+    gfxGlyphExtents& operator=(const gfxGlyphExtents& aOther) = delete;
 };
 
 #endif
--- a/gfx/thebes/gfxPrefs.h
+++ b/gfx/thebes/gfxPrefs.h
@@ -369,15 +369,15 @@ private:
   static void PrefSet(const char* aPref, int32_t aValue);
   static void PrefSet(const char* aPref, uint32_t aValue);
   static void PrefSet(const char* aPref, float aValue);
 
   static void AssertMainThread();
 
   gfxPrefs();
   ~gfxPrefs();
-  gfxPrefs(const gfxPrefs&) MOZ_DELETE;
-  gfxPrefs& operator=(const gfxPrefs&) MOZ_DELETE;
+  gfxPrefs(const gfxPrefs&) = delete;
+  gfxPrefs& operator=(const gfxPrefs&) = delete;
 };
 
 #undef DECL_GFX_PREF /* Don't need it outside of this file */
 
 #endif /* GFX_PREFS_H */
--- a/gfx/thebes/gfxQuartzNativeDrawing.h
+++ b/gfx/thebes/gfxQuartzNativeDrawing.h
@@ -50,18 +50,18 @@ public:
      * for drawing after that time, the result is undefined. */
     CGContextRef BeginNativeDrawing();
 
     /* Marks the end of native drawing */
     void EndNativeDrawing();
 
 private:
     // don't allow copying via construction or assignment
-    gfxQuartzNativeDrawing(const gfxQuartzNativeDrawing&) MOZ_DELETE;
-    const gfxQuartzNativeDrawing& operator=(const gfxQuartzNativeDrawing&) MOZ_DELETE;
+    gfxQuartzNativeDrawing(const gfxQuartzNativeDrawing&) = delete;
+    const gfxQuartzNativeDrawing& operator=(const gfxQuartzNativeDrawing&) = delete;
 
     // Final destination context
     mozilla::RefPtr<DrawTarget> mDrawTarget;
     mozilla::RefPtr<DrawTarget> mTempDrawTarget;
     mozilla::gfx::BorrowedCGContext mBorrowedContext;
     mozilla::gfx::Rect mNativeRect;
 
     // saved state
--- a/image/src/ProgressTracker.h
+++ b/image/src/ProgressTracker.h
@@ -164,17 +164,17 @@ public:
   bool FirstObserverIs(IProgressObserver* aObserver);
 
 private:
   typedef nsTObserverArray<mozilla::WeakPtr<IProgressObserver>> ObserverArray;
   friend class AsyncNotifyRunnable;
   friend class AsyncNotifyCurrentStateRunnable;
   friend class ProgressTrackerInit;
 
-  ProgressTracker(const ProgressTracker& aOther) MOZ_DELETE;
+  ProgressTracker(const ProgressTracker& aOther) = delete;
 
   // This method should only be called once, and only on an ProgressTracker
   // that was initialized without an image. ProgressTrackerInit automates this.
   void SetImage(Image* aImage);
 
   // Resets our weak reference to our image, for when mImage is about to go out
   // of scope.  ProgressTrackerInit automates this.
   void ResetImage();
--- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -191,18 +191,18 @@ public:
 private:
     const char* mMessageName;
     int32_t mMessageRoutingId;
     Semantics mMesageSemantics;
     Direction mDirection;
     DebugOnly<bool> mMoved;
 
     // Disable harmful methods.
-    InterruptFrame(const InterruptFrame& aOther) MOZ_DELETE;
-    InterruptFrame& operator=(const InterruptFrame&) MOZ_DELETE;
+    InterruptFrame(const InterruptFrame& aOther) = delete;
+    InterruptFrame& operator=(const InterruptFrame&) = delete;
 };
 
 class MOZ_STACK_CLASS MessageChannel::CxxStackFrame
 {
 public:
     CxxStackFrame(MessageChannel& that, Direction direction, const Message* msg)
       : mThat(that)
     {
@@ -241,19 +241,19 @@ public:
 
         if (exitingStack)
             mThat.ExitedCxxStack();
     }
 private:
     MessageChannel& mThat;
 
     // Disable harmful methods.
-    CxxStackFrame() MOZ_DELETE;
-    CxxStackFrame(const CxxStackFrame&) MOZ_DELETE;
-    CxxStackFrame& operator=(const CxxStackFrame&) MOZ_DELETE;
+    CxxStackFrame() = delete;
+    CxxStackFrame(const CxxStackFrame&) = delete;
+    CxxStackFrame& operator=(const CxxStackFrame&) = delete;
 };
 
 namespace {
 
 class MOZ_STACK_CLASS MaybeScriptBlocker {
 public:
     explicit MaybeScriptBlocker(MessageChannel *aChannel, bool aBlock
                                 MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
--- a/js/public/Debug.h
+++ b/js/public/Debug.h
@@ -172,17 +172,17 @@ class Builder {
 
         typedef void (BuiltThing::* ConvertibleToBool)();
         operator ConvertibleToBool() const {
             // If we ever instantiate BuiltThink<Value>, this might not suffice.
             return value ? &BuiltThing::nonNull : 0;
         }
 
       private:
-        BuiltThing() MOZ_DELETE;
+        BuiltThing() = delete;
     };
 
   public:
     // A reference to a trusted object, possibly null. Instances of Object are
     // always properly rooted. They can be copied and assigned, as if they were
     // pointers.
     class Object: private BuiltThing<JSObject *> {
         friend class Builder;           // for construction
--- a/js/public/HashTable.h
+++ b/js/public/HashTable.h
@@ -264,18 +264,18 @@ class HashMap
     HashMap(HashMap &&rhs) : impl(mozilla::Move(rhs.impl)) {}
     void operator=(HashMap &&rhs) {
         MOZ_ASSERT(this != &rhs, "self-move assignment is prohibited");
         impl = mozilla::Move(rhs.impl);
     }
 
   private:
     // HashMap is not copyable or assignable
-    HashMap(const HashMap &hm) MOZ_DELETE;
-    HashMap &operator=(const HashMap &hm) MOZ_DELETE;
+    HashMap(const HashMap &hm) = delete;
+    HashMap &operator=(const HashMap &hm) = delete;
 
     friend class Impl::Enum;
 };
 
 /*****************************************************************************/
 
 // A JS-friendly, STL-like container providing a hash-based set of values. In
 // particular, HashSet calls constructors and destructors of all objects added
@@ -489,18 +489,18 @@ class HashSet
     HashSet(HashSet &&rhs) : impl(mozilla::Move(rhs.impl)) {}
     void operator=(HashSet &&rhs) {
         MOZ_ASSERT(this != &rhs, "self-move assignment is prohibited");
         impl = mozilla::Move(rhs.impl);
     }
 
   private:
     // HashSet is not copyable or assignable
-    HashSet(const HashSet &hs) MOZ_DELETE;
-    HashSet &operator=(const HashSet &hs) MOZ_DELETE;
+    HashSet(const HashSet &hs) = delete;
+    HashSet &operator=(const HashSet &hs) = delete;
 
     friend class Impl::Enum;
 };
 
 /*****************************************************************************/
 
 // Hash Policy
 //
@@ -648,18 +648,18 @@ class HashMapEntry
     typedef Key KeyType;
     typedef Value ValueType;
 
     const Key & key() const { return key_; }
     const Value & value() const { return value_; }
     Value & value() { return value_; }
 
   private:
-    HashMapEntry(const HashMapEntry &) MOZ_DELETE;
-    void operator=(const HashMapEntry &) MOZ_DELETE;
+    HashMapEntry(const HashMapEntry &) = delete;
+    void operator=(const HashMapEntry &) = delete;
 };
 
 } // namespace js
 
 namespace mozilla {
 
 template <typename T>
 struct IsPod<js::detail::HashTableEntry<T> > : IsPod<T> {};
@@ -691,19 +691,19 @@ class HashTableEntry
     static const HashNumber sRemovedKey = 1;
     static const HashNumber sCollisionBit = 1;
 
     static bool isLiveHash(HashNumber hash)
     {
         return hash > sRemovedKey;
     }
 
-    HashTableEntry(const HashTableEntry &) MOZ_DELETE;
-    void operator=(const HashTableEntry &) MOZ_DELETE;
-    ~HashTableEntry() MOZ_DELETE;
+    HashTableEntry(const HashTableEntry &) = delete;
+    void operator=(const HashTableEntry &) = delete;
+    ~HashTableEntry() = delete;
 
   public:
     // NB: HashTableEntry is treated as a POD: no constructor or destructor calls.
 
     void destroyIfLive() {
         if (isLive())
             mem.addr()->~T();
     }
@@ -932,18 +932,18 @@ class HashTable : private AllocPolicy
     {
         friend class HashTable;
 
         HashTable &table_;
         bool rekeyed;
         bool removed;
 
         /* Not copyable. */
-        Enum(const Enum &) MOZ_DELETE;
-        void operator=(const Enum &) MOZ_DELETE;
+        Enum(const Enum &) = delete;
+        void operator=(const Enum &) = delete;
 
       public:
         template<class Map> explicit
         Enum(Map &map) : Range(map.all()), table_(map.impl), rekeyed(false), removed(false) {}
 
         // Removes the |front()| element from the table, leaving |front()|
         // invalid until the next call to |popFront()|. For example:
         //
@@ -1002,18 +1002,18 @@ class HashTable : private AllocPolicy
         if (table)
             destroyTable(*this, table, capacity());
         mozilla::PodAssign(this, &rhs);
         rhs.table = nullptr;
     }
 
   private:
     // HashTable is not copyable or assignable
-    HashTable(const HashTable &) MOZ_DELETE;
-    void operator=(const HashTable &) MOZ_DELETE;
+    HashTable(const HashTable &) = delete;
+    void operator=(const HashTable &) = delete;
 
   private:
     static const size_t CAP_BITS = 24;
 
   public:
     Entry       *table;                 // entry storage
     uint32_t    gen;                    // entry storage generation number
     uint32_t    entryCount;             // number of entries in table
--- a/js/public/MemoryMetrics.h
+++ b/js/public/MemoryMetrics.h
@@ -185,17 +185,17 @@ struct NotableClassInfo : public ClassIn
 
     ~NotableClassInfo() {
         js_free(className_);
     }
 
     char *className_;
 
   private:
-    NotableClassInfo(const NotableClassInfo& info) MOZ_DELETE;
+    NotableClassInfo(const NotableClassInfo& info) = delete;
 };
 
 // Data for tracking JIT-code memory usage.
 struct CodeSizes
 {
 #define FOR_EACH_SIZE(macro) \
     macro(_, _, ion) \
     macro(_, _, baseline) \
@@ -309,17 +309,17 @@ struct NotableStringInfo : public String
     ~NotableStringInfo() {
         js_free(buffer);
     }
 
     char *buffer;
     size_t length;
 
   private:
-    NotableStringInfo(const NotableStringInfo& info) MOZ_DELETE;
+    NotableStringInfo(const NotableStringInfo& info) = delete;
 };
 
 // This class holds information about the memory taken up by script sources
 // from a particular file.
 struct ScriptSourceInfo
 {
 #define FOR_EACH_SIZE(macro) \
     macro(_, _, compressed) \
@@ -370,17 +370,17 @@ struct NotableScriptSourceInfo : public 
 
     ~NotableScriptSourceInfo() {
         js_free(filename_);
     }
 
     char *filename_;
 
   private:
-    NotableScriptSourceInfo(const NotableScriptSourceInfo& info) MOZ_DELETE;
+    NotableScriptSourceInfo(const NotableScriptSourceInfo& info) = delete;
 };
 
 // These measurements relate directly to the JSRuntime, and not to zones and
 // compartments within it.
 struct RuntimeSizes
 {
 #define FOR_EACH_SIZE(macro) \
     macro(_, _, object) \
--- a/js/public/RootingAPI.h
+++ b/js/public/RootingAPI.h
@@ -487,18 +487,18 @@ class MOZ_NONHEAP_CLASS Handle : public 
     Handle() {}
 
     enum Disambiguator { DeliberatelyChoosingThisOverload = 42 };
     enum CallerIdentity { ImUsingThisOnlyInFromFromMarkedLocation = 17 };
     MOZ_CONSTEXPR Handle(const T *p, Disambiguator, CallerIdentity) : ptr(p) {}
 
     const T *ptr;
 
-    template <typename S> void operator=(S) MOZ_DELETE;
-    void operator=(Handle) MOZ_DELETE;
+    template <typename S> void operator=(S) = delete;
+    void operator=(Handle) = delete;
 };
 
 /*
  * Similar to a handle, but the underlying storage can be changed. This is
  * useful for outparams.
  *
  * If you want to add additional methods to MutableHandle for a specific
  * specialization, define a MutableHandleBase<T> specialization containing
@@ -515,17 +515,17 @@ class MOZ_STACK_CLASS MutableHandle : pu
     // Disallow true nullptr and emulated nullptr (gcc 4.4/4.5, __null, appears
     // as int/long [32/64-bit]) for overloading purposes.
     template<typename N>
     MutableHandle(N,
                   typename mozilla::EnableIf<mozilla::IsNullPointer<N>::value ||
                                              mozilla::IsSame<N, int>::value ||
                                              mozilla::IsSame<N, long>::value,
                                              int>::Type dummy = 0)
-    MOZ_DELETE;
+    = delete;
 
   public:
     void set(T v) {
         MOZ_ASSERT(!js::GCMethods<T>::poisoned(v));
         *ptr = v;
     }
 
     /*
@@ -551,18 +551,18 @@ class MOZ_STACK_CLASS MutableHandle : pu
     operator const T&() const { return get(); }
     T operator->() const { return get(); }
 
   private:
     MutableHandle() {}
 
     T *ptr;
 
-    template <typename S> void operator=(S v) MOZ_DELETE;
-    void operator=(MutableHandle other) MOZ_DELETE;
+    template <typename S> void operator=(S v) = delete;
+    void operator=(MutableHandle other) = delete;
 };
 
 } /* namespace JS */
 
 namespace js {
 
 /*
  * InternalHandle is a handle to an internal pointer into a gcthing. Use
@@ -619,17 +619,17 @@ class InternalHandle<T*>
      * Make this private to prevent accidental misuse; this is only for
      * fromMarkedLocation().
      */
     explicit InternalHandle(T *field)
       : holder(reinterpret_cast<void * const *>(&js::NullPtr::constNullValue)),
         offset(uintptr_t(field))
     {}
 
-    void operator=(InternalHandle<T*> other) MOZ_DELETE;
+    void operator=(InternalHandle<T*> other) = delete;
 };
 
 /*
  * By default, things should use the inheritance hierarchy to find their
  * ThingRootKind. Some pointer types are explicitly set in jspubtd.h so that
  * Rooted<T> may be used without the class definition being available.
  */
 template <typename T>
@@ -831,17 +831,17 @@ class MOZ_STACK_CLASS Rooted : public js
     /*
      * |ptr| must be the last field in Rooted because the analysis treats all
      * Rooted as Rooted<void*> during the analysis. See bug 829372.
      */
     T ptr;
 
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
-    Rooted(const Rooted &) MOZ_DELETE;
+    Rooted(const Rooted &) = delete;
 };
 
 } /* namespace JS */
 
 namespace js {
 
 /*
  * Augment the generic Rooted<T> interface when T = JSObject* with
@@ -922,17 +922,17 @@ class FakeRooted : public RootedBase<T>
     bool operator!=(const T &other) const { return ptr != other; }
     bool operator==(const T &other) const { return ptr == other; }
 
   private:
     T ptr;
 
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
-    FakeRooted(const FakeRooted &) MOZ_DELETE;
+    FakeRooted(const FakeRooted &) = delete;
 };
 
 /* Interface substitute for MutableHandle<T> which is not required to point to rooted memory. */
 template <typename T>
 class FakeMutableHandle : public js::MutableHandleBase<T>
 {
   public:
     MOZ_IMPLICIT FakeMutableHandle(T *t) {
@@ -955,19 +955,19 @@ class FakeMutableHandle : public js::Mut
     T operator->() const { return get(); }
 
   private:
     FakeMutableHandle() {}
 
     T *ptr;
 
     template <typename S>
-    void operator=(S v) MOZ_DELETE;
+    void operator=(S v) = delete;
 
-    void operator=(const FakeMutableHandle<T>& other) MOZ_DELETE;
+    void operator=(const FakeMutableHandle<T>& other) = delete;
 };
 
 /*
  * Types for a variable that either should or shouldn't be rooted, depending on
  * the template parameter allowGC. Used for implementing functions that can
  * operate on either rooted or unrooted data.
  *
  * The toHandle() and toMutableHandle() functions are for calling functions
--- a/js/public/StructuredClone.h
+++ b/js/public/StructuredClone.h
@@ -207,18 +207,18 @@ class JS_PUBLIC_API(JSAutoStructuredClon
     bool write(JSContext *cx, JS::HandleValue v,
                const JSStructuredCloneCallbacks *optionalCallbacks=nullptr, void *closure=nullptr);
 
     bool write(JSContext *cx, JS::HandleValue v, JS::HandleValue transferable,
                const JSStructuredCloneCallbacks *optionalCallbacks=nullptr, void *closure=nullptr);
 
   private:
     // Copy and assignment are not supported.
-    JSAutoStructuredCloneBuffer(const JSAutoStructuredCloneBuffer &other) MOZ_DELETE;
-    JSAutoStructuredCloneBuffer &operator=(const JSAutoStructuredCloneBuffer &other) MOZ_DELETE;
+    JSAutoStructuredCloneBuffer(const JSAutoStructuredCloneBuffer &other) = delete;
+    JSAutoStructuredCloneBuffer &operator=(const JSAutoStructuredCloneBuffer &other) = delete;
 };
 
 // The range of tag values the application may use for its own custom object types.
 #define JS_SCTAG_USER_MIN  ((uint32_t) 0xFFFF8000)
 #define JS_SCTAG_USER_MAX  ((uint32_t) 0xFFFFFFFF)
 
 #define JS_SCERR_RECURSION 0
 #define JS_SCERR_TRANSFERABLE 1
--- a/js/public/UbiNode.h
+++ b/js/public/UbiNode.h
@@ -202,18 +202,18 @@ class Base {
 
     // Return the compartment for this node. Some ubi::Node referents are not
     // associated with JSCompartments, such as JSStrings (which are associated
     // with Zones). When the referent is not associated with a compartment,
     // nullptr is returned.
     virtual JSCompartment *compartment() const { return nullptr; }
 
   private:
-    Base(const Base &rhs) MOZ_DELETE;
-    Base &operator=(const Base &rhs) MOZ_DELETE;
+    Base(const Base &rhs) = delete;
+    Base &operator=(const Base &rhs) = delete;
 };
 
 // A traits template with a specialization for each referent type that
 // ubi::Node supports. The specialization must be the concrete subclass of
 // Base that represents a pointer to the referent type. It must also
 // include the members described here.
 template<typename Referent>
 struct Concrete {
@@ -380,18 +380,18 @@ class Edge {
     // creating tons of strings when the names follow a pattern; and we'll need
     // to think about lifetimes carefully to ensure traversal stays cheap.)
     const char16_t *name;
 
     // This edge's referent.
     Node referent;
 
   private:
-    Edge(const Edge &) MOZ_DELETE;
-    Edge &operator=(const Edge &) MOZ_DELETE;
+    Edge(const Edge &) = delete;
+    Edge &operator=(const Edge &) = delete;
 };
 
 
 // EdgeRange is an abstract base class for iterating over a node's outgoing
 // edges. (This is modeled after js::HashTable<K,V>::Range.)
 //
 // Concrete instances of this class need not be as lightweight as Node itself,
 // since they're usually only instantiated while iterating over a particular
@@ -416,26 +416,26 @@ class EdgeRange {
     // the EdgeRange is destructed.
     const Edge &front() { return *front_; }
 
     // Remove the front edge from this range. This should only be called if
     // !empty().
     virtual void popFront() = 0;
 
   private:
-    EdgeRange(const EdgeRange &) MOZ_DELETE;
-    EdgeRange &operator=(const EdgeRange &) MOZ_DELETE;
+    EdgeRange(const EdgeRange &) = delete;
+    EdgeRange &operator=(const EdgeRange &) = delete;
 };
 
 
 // A dumb Edge concrete class. All but the most essential members have the
 // default behavior.
 class SimpleEdge : public Edge {
-    SimpleEdge(SimpleEdge &) MOZ_DELETE;
-    SimpleEdge &operator=(const SimpleEdge &) MOZ_DELETE;
+    SimpleEdge(SimpleEdge &) = delete;
+    SimpleEdge &operator=(const SimpleEdge &) = delete;
 
   public:
     SimpleEdge() : Edge() { }
 
     // Construct an initialized SimpleEdge, taking ownership of |name|.
     SimpleEdge(char16_t *name, const Node &referent) {
         this->name = name;
         this->referent = referent;
--- a/js/public/WeakMapPtr.h
+++ b/js/public/WeakMapPtr.h
@@ -34,15 +34,15 @@ class JS_PUBLIC_API(WeakMapPtr)
     bool put(JSContext *cx, const K &key, const V &value);
 
     static void keyMarkCallback(JSTracer *trc, K key, void *data);
 
   private:
     void *ptr;
 
     // WeakMapPtr is neither copyable nor assignable.
-    WeakMapPtr(const WeakMapPtr &wmp) MOZ_DELETE;
-    WeakMapPtr &operator=(const WeakMapPtr &wmp) MOZ_DELETE;
+    WeakMapPtr(const WeakMapPtr &wmp) = delete;
+    WeakMapPtr &operator=(const WeakMapPtr &wmp) = delete;
 };
 
 } /* namespace JS */
 
 #endif  /* js_WeakMapPtr_h */
--- a/js/src/builtin/MapObject.cpp
+++ b/js/src/builtin/MapObject.cpp
@@ -354,17 +354,17 @@ class OrderedHashTable
         ~Range() {
             *prevp = next;
             if (next)
                 next->prevp = prevp;
         }
 
       private:
         // Prohibit copy assignment.
-        Range &operator=(const Range &other) MOZ_DELETE;
+        Range &operator=(const Range &other) = delete;
 
         void seek() {
             while (i < ht.dataLength && Ops::isEmpty(Ops::getKey(ht.data[i].element)))
                 i++;
         }
 
         /*
          * The hash table calls this when an entry is removed.
@@ -662,18 +662,18 @@ class OrderedHashTable
         hashShift = newHashShift;
         MOZ_ASSERT(hashBuckets() == newHashBuckets);
 
         compacted();
         return true;
     }
 
     // Not copyable.
-    OrderedHashTable &operator=(const OrderedHashTable &) MOZ_DELETE;
-    OrderedHashTable(const OrderedHashTable &) MOZ_DELETE;
+    OrderedHashTable &operator=(const OrderedHashTable &) = delete;
+    OrderedHashTable(const OrderedHashTable &) = delete;
 };
 
 }  // namespace detail
 
 template <class Key, class Value, class OrderedHashPolicy, class AllocPolicy>
 class OrderedHashMap
 {
   public:
--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -1835,18 +1835,18 @@ class BackEdge {
         return *this;
     }
 
     EdgeName forgetName() { return Move(name_); }
     JS::ubi::Node predecessor() const { return predecessor_; }
 
   private:
     // No copy constructor or copying assignment.
-    BackEdge(const BackEdge &) MOZ_DELETE;
-    BackEdge &operator=(const BackEdge &) MOZ_DELETE;
+    BackEdge(const BackEdge &) = delete;
+    BackEdge &operator=(const BackEdge &) = delete;
 };
 
 // A path-finding handler class for use with JS::ubi::BreadthFirst.
 struct FindPathHandler {
     typedef BackEdge NodeData;
     typedef JS::ubi::BreadthFirst<FindPathHandler> Traversal;
 
     FindPathHandler(JS::ubi::Node start, JS::ubi::Node target,
--- a/js/src/ds/LifoAlloc.h
+++ b/js/src/ds/LifoAlloc.h
@@ -162,18 +162,18 @@ class LifoAlloc
     BumpChunk   *first;
     BumpChunk   *latest;
     BumpChunk   *last;
     size_t      markCount;
     size_t      defaultChunkSize_;
     size_t      curSize_;
     size_t      peakSize_;
 
-    void operator=(const LifoAlloc &) MOZ_DELETE;
-    LifoAlloc(const LifoAlloc &) MOZ_DELETE;
+    void operator=(const LifoAlloc &) = delete;
+    LifoAlloc(const LifoAlloc &) = delete;
 
     // Return a BumpChunk that can perform an allocation of at least size |n|
     // and add it to the chain appropriately.
     //
     // Side effect: if retval is non-null, |first| and |latest| are initialized
     // appropriately.
     BumpChunk *getOrCreateChunk(size_t n);
 
--- a/js/src/ds/PriorityQueue.h
+++ b/js/src/ds/PriorityQueue.h
@@ -21,18 +21,18 @@ namespace js {
  */
 template <class T, class P,
           size_t MinInlineCapacity = 0,
           class AllocPolicy = TempAllocPolicy>
 class PriorityQueue
 {
     Vector<T, MinInlineCapacity, AllocPolicy> heap;
 
-    PriorityQueue(const PriorityQueue &) MOZ_DELETE;
-    PriorityQueue &operator=(const PriorityQueue &) MOZ_DELETE;
+    PriorityQueue(const PriorityQueue &) = delete;
+    PriorityQueue &operator=(const PriorityQueue &) = delete;
 
   public:
 
     explicit PriorityQueue(AllocPolicy ap = AllocPolicy())
       : heap(ap)
     {}
 
     bool reserve(size_t capacity) {
--- a/js/src/ds/SplayTree.h
+++ b/js/src/ds/SplayTree.h
@@ -34,18 +34,18 @@ class SplayTree
 
     LifoAlloc *alloc;
     Node *root, *freeList;
 
 #ifdef DEBUG
     bool enableCheckCoherency;
 #endif
 
-    SplayTree(const SplayTree &) MOZ_DELETE;
-    SplayTree &operator=(const SplayTree &) MOZ_DELETE;
+    SplayTree(const SplayTree &) = delete;
+    SplayTree &operator=(const SplayTree &) = delete;
 
   public:
 
     explicit SplayTree(LifoAlloc *alloc = nullptr)
       : alloc(alloc), root(nullptr), freeList(nullptr)
 #ifdef DEBUG
       , enableCheckCoherency(true)
 #endif
--- a/js/src/frontend/BytecodeEmitter.cpp
+++ b/js/src/frontend/BytecodeEmitter.cpp
@@ -583,17 +583,17 @@ namespace {
 
 class NonLocalExitScope {
     ExclusiveContext *cx;
     BytecodeEmitter *bce;
     const uint32_t savedScopeIndex;
     const int savedDepth;
     uint32_t openScopeIndex;
 
-    NonLocalExitScope(const NonLocalExitScope &) MOZ_DELETE;
+    NonLocalExitScope(const NonLocalExitScope &) = delete;
 
   public:
     explicit NonLocalExitScope(ExclusiveContext *cx_, BytecodeEmitter *bce_)
       : cx(cx_),
         bce(bce_),
         savedScopeIndex(bce->blockScopeList.length()),
         savedDepth(bce->stackDepth),
         openScopeIndex(UINT32_MAX) {
--- a/js/src/frontend/ParseMaps.h
+++ b/js/src/frontend/ParseMaps.h
@@ -411,18 +411,18 @@ class AtomDecls
 
     /* AtomDeclsIter needs to get at the DefnListMap directly. */
     friend class AtomDeclsIter;
 
     ExclusiveContext *cx;
     LifoAlloc &alloc;
     AtomDefnListMap  *map;
 
-    AtomDecls(const AtomDecls &other) MOZ_DELETE;
-    void operator=(const AtomDecls &other) MOZ_DELETE;
+    AtomDecls(const AtomDecls &other) = delete;
+    void operator=(const AtomDecls &other) = delete;
 
   public:
     explicit AtomDecls(ExclusiveContext *cx, LifoAlloc &alloc) : cx(cx),
                                                                  alloc(alloc),
                                                                  map(nullptr) {}
 
     ~AtomDecls();
 
--- a/js/src/frontend/ParseNode.h
+++ b/js/src/frontend/ParseNode.h
@@ -461,18 +461,18 @@ class ParseNode
 {
     uint32_t            pn_type   : 16, /* PNK_* type */
                         pn_op     : 8,  /* see JSOp enum and jsopcode.tbl */
                         pn_arity  : 5,  /* see ParseNodeArity enum */
                         pn_parens : 1,  /* this expr was enclosed in parens */
                         pn_used   : 1,  /* name node is on a use-chain */
                         pn_defn   : 1;  /* this node is a Definition */
 
-    ParseNode(const ParseNode &other) MOZ_DELETE;
-    void operator=(const ParseNode &other) MOZ_DELETE;
+    ParseNode(const ParseNode &other) = delete;
+    void operator=(const ParseNode &other) = delete;
 
   public:
     ParseNode(ParseNodeKind kind, JSOp op, ParseNodeArity arity)
       : pn_type(kind), pn_op(op), pn_arity(arity), pn_parens(0), pn_used(0), pn_defn(0),
         pn_pos(0, 0), pn_offset(0), pn_next(nullptr), pn_link(nullptr)
     {
         MOZ_ASSERT(kind < PNK_LIMIT);
         memset(&pn_u, 0, sizeof pn_u);
--- a/js/src/frontend/TokenStream.h
+++ b/js/src/frontend/TokenStream.h
@@ -176,18 +176,18 @@ struct CompileError {
     ErrorArgumentsType argumentsType;
     CompileError() : message(nullptr), argumentsType(ArgumentsAreUnicode) {}
     ~CompileError();
     void throwError(JSContext *cx);
 
   private:
     // CompileError owns raw allocated memory, so disable assignment and copying
     // for safety.
-    void operator=(const CompileError &) MOZ_DELETE;
-    CompileError(const CompileError &) MOZ_DELETE;
+    void operator=(const CompileError &) = delete;
+    CompileError(const CompileError &) = delete;
 };
 
 // Ideally, tokenizing would be entirely independent of context.  But the
 // strict mode flag, which is in SharedContext, affects tokenizing, and
 // TokenStream needs to see it.
 //
 // This class is a tiny back-channel from TokenStream to the strict mode flag
 // that avoids exposing the rest of SharedContext to TokenStream.
@@ -510,17 +510,17 @@ class MOZ_STACK_CLASS TokenStream
         // rooting we must ensure collection of atoms is disabled while objects
         // of this class are live.  Do this by requiring a dummy AutoKeepAtoms
         // reference in the constructor.
         //
         // This class is explicity ignored by the analysis, so don't add any
         // more pointers to GC things here!
         explicit Position(AutoKeepAtoms&) { }
       private:
-        Position(const Position&) MOZ_DELETE;
+        Position(const Position&) = delete;
         friend class TokenStream;
         const char16_t *buf;
         Flags flags;
         unsigned lineno;
         size_t linebase;
         size_t prevLinebase;
         Token currentToken;
         unsigned lookahead;
--- a/js/src/gc/Barrier.h
+++ b/js/src/gc/Barrier.h
@@ -556,18 +556,18 @@ class HeapPtr : public BarrieredBase<T>
   private:
     /*
      * Unlike RelocatablePtr<T>, HeapPtr<T> must be managed with GC lifetimes.
      * Specifically, the memory used by the pointer itself must be live until
      * at least the next minor GC. For that reason, move semantics are invalid
      * and are deleted here. Please note that not all containers support move
      * semantics, so this does not completely prevent invalid uses.
      */
-    HeapPtr(HeapPtr<T> &&) MOZ_DELETE;
-    HeapPtr<T> &operator=(HeapPtr<T> &&) MOZ_DELETE;
+    HeapPtr(HeapPtr<T> &&) = delete;
+    HeapPtr<T> &operator=(HeapPtr<T> &&) = delete;
 };
 
 /*
  * ImmutableTenuredPtr is designed for one very narrow case: replacing
  * immutable raw pointers to GC-managed things, implicitly converting to a
  * handle type for ease of use. Pointers encapsulated by this type must:
  *
  *   be immutable (no incremental write barriers),
@@ -839,17 +839,17 @@ typedef ReadBarriered<Value> ReadBarrier
 class HeapSlot : public BarrieredBase<Value>
 {
   public:
     enum Kind {
         Slot = 0,
         Element = 1
     };
 
-    explicit HeapSlot() MOZ_DELETE;
+    explicit HeapSlot() = delete;
 
     explicit HeapSlot(NativeObject *obj, Kind kind, uint32_t slot, const Value &v)
       : BarrieredBase<Value>(v)
     {
         MOZ_ASSERT(!IsPoisonedValue(v));
         post(obj, kind, slot, v);
     }
 
--- a/js/src/gc/GCInternals.h
+++ b/js/src/gc/GCInternals.h
@@ -44,18 +44,18 @@ class AutoTraceSession
     explicit AutoTraceSession(JSRuntime *rt, HeapState state = Tracing);
     ~AutoTraceSession();
 
   protected:
     AutoLockForExclusiveAccess lock;
     JSRuntime *runtime;
 
   private:
-    AutoTraceSession(const AutoTraceSession&) MOZ_DELETE;
-    void operator=(const AutoTraceSession&) MOZ_DELETE;
+    AutoTraceSession(const AutoTraceSession&) = delete;
+    void operator=(const AutoTraceSession&) = delete;
 
     HeapState prevState;
 };
 
 struct AutoPrepareForTracing
 {
     AutoFinishGC finish;
     AutoTraceSession session;
--- a/js/src/gc/Nursery.h
+++ b/js/src/gc/Nursery.h
@@ -82,17 +82,17 @@ class Nursery
 
     /* Return true if no allocations have been made since the last collection. */
     bool isEmpty() const;
 
     /*
      * Check whether an arbitrary pointer is within the nursery. This is
      * slower than IsInsideNursery(Cell*), but works on all types of pointers.
      */
-    MOZ_ALWAYS_INLINE bool isInside(gc::Cell *cellp) const MOZ_DELETE;
+    MOZ_ALWAYS_INLINE bool isInside(gc::Cell *cellp) const = delete;
     MOZ_ALWAYS_INLINE bool isInside(const void *p) const {
         return uintptr_t(p) >= heapStart_ && uintptr_t(p) < heapEnd_;
     }
 
     /*
      * Allocate and return a pointer to a new GC object with its |slots|
      * pointer pre-filled. Returns nullptr if the Nursery is full.
      */
--- a/js/src/gc/StoreBuffer.h
+++ b/js/src/gc/StoreBuffer.h
@@ -153,17 +153,17 @@ class StoreBuffer
         /* Mark the source of all edges in the store buffer. */
         void mark(StoreBuffer *owner, JSTracer *trc);
 
         size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) {
             return stores_.sizeOfExcludingThis(mallocSizeOf);
         }
 
       private:
-        MonoTypeBuffer &operator=(const MonoTypeBuffer& other) MOZ_DELETE;
+        MonoTypeBuffer &operator=(const MonoTypeBuffer& other) = delete;
     };
 
     struct GenericBuffer
     {
         LifoAlloc *storage_;
 
         explicit GenericBuffer() : storage_(nullptr) {}
         ~GenericBuffer() { js_delete(storage_); }
@@ -210,17 +210,17 @@ class StoreBuffer
                 owner->setAboutToOverflow();
         }
 
         size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) {
             return storage_ ? storage_->sizeOfIncludingThis(mallocSizeOf) : 0;
         }
 
       private:
-        GenericBuffer &operator=(const GenericBuffer& other) MOZ_DELETE;
+        GenericBuffer &operator=(const GenericBuffer& other) = delete;
     };
 
     template <typename Edge>
     struct PointerEdgeHasher
     {
         typedef Edge Lookup;
         static HashNumber hash(const Lookup &l) { return uintptr_t(l.edge) >> 3; }
         static bool match(const Edge &k, const Lookup &l) { return k == l; }
--- a/js/src/irregexp/RegExpEngine.h
+++ b/js/src/irregexp/RegExpEngine.h
@@ -1484,15 +1484,15 @@ class Analysis : public NodeVisitor
     }
 
   private:
     JSContext *cx;
     bool ignore_case_;
     bool is_ascii_;
     const char* error_message_;
 
-    Analysis(Analysis &) MOZ_DELETE;
-    void operator=(Analysis &) MOZ_DELETE;
+    Analysis(Analysis &) = delete;
+    void operator=(Analysis &) = delete;
 };
 
 } }  // namespace js::irregexp
 
 #endif  // V8_JSREGEXP_H_
--- a/js/src/jit/InlineList.h
+++ b/js/src/jit/InlineList.h
@@ -18,17 +18,17 @@ template <typename T>
 class InlineForwardListNode
 {
   public:
     InlineForwardListNode() : next(nullptr)
     { }
     explicit InlineForwardListNode(InlineForwardListNode<T> *n) : next(n)
     { }
 
-    InlineForwardListNode(const InlineForwardListNode<T> &) MOZ_DELETE;
+    InlineForwardListNode(const InlineForwardListNode<T> &) = delete;
 
   protected:
     friend class InlineForwardList<T>;
     friend class InlineForwardListIterator<T>;
 
     InlineForwardListNode<T> *next;
 };
 
@@ -224,18 +224,18 @@ class InlineListNode : public InlineForw
         prev = newPrev;
 
         // Update the pointers in the adjacent nodes to point to this node's new
         // location.
         newNext->prev = this;
         newPrev->next = this;
     }
 
-    InlineListNode(const InlineListNode<T> &) MOZ_DELETE;
-    void operator=(const InlineListNode<T> &) MOZ_DELETE;
+    InlineListNode(const InlineListNode<T> &) = delete;
+    void operator=(const InlineListNode<T> &) = delete;
 
   protected:
     friend class InlineList<T>;
     friend class InlineListIterator<T>;
     friend class InlineListReverseIterator<T>;
 
     InlineListNode<T> *prev;
 };
@@ -556,17 +556,17 @@ class InlineSpaghettiStackNode : public 
   public:
     InlineSpaghettiStackNode() : Parent()
     { }
 
     explicit InlineSpaghettiStackNode(InlineSpaghettiStackNode<T> *n)
       : Parent(n)
     { }
 
-    InlineSpaghettiStackNode(const InlineSpaghettiStackNode<T> &) MOZ_DELETE;
+    InlineSpaghettiStackNode(const InlineSpaghettiStackNode<T> &) = delete;
 
   protected:
     friend class InlineSpaghettiStack<T>;
     friend class InlineSpaghettiStackIterator<T>;
 };
 
 template <typename T>
 class InlineSpaghettiStack : protected InlineSpaghettiStackNode<T>
--- a/js/src/jit/JitFrameIterator.h
+++ b/js/src/jit/JitFrameIterator.h
@@ -795,16 +795,16 @@ class InlineFrameIterator
         return frameCount() - framesRead_;
     }
     size_t frameCount() const {
         MOZ_ASSERT(frameCount_ != UINT32_MAX);
         return frameCount_;
     }
 
   private:
-    InlineFrameIterator() MOZ_DELETE;
-    InlineFrameIterator(const InlineFrameIterator &iter) MOZ_DELETE;
+    InlineFrameIterator() = delete;
+    InlineFrameIterator(const InlineFrameIterator &iter) = delete;
 };
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_JitFrameIterator_h */
--- a/js/src/jit/LiveRangeAllocator.h
+++ b/js/src/jit/LiveRangeAllocator.h
@@ -428,18 +428,18 @@ class VirtualRegister
 {
     LNode *ins_;
     LDefinition *def_;
     Vector<LiveInterval *, 1, JitAllocPolicy> intervals_;
 
     // Whether def_ is a temp or an output.
     bool isTemp_ : 1;
 
-    void operator=(const VirtualRegister &) MOZ_DELETE;
-    VirtualRegister(const VirtualRegister &) MOZ_DELETE;
+    void operator=(const VirtualRegister &) = delete;
+    VirtualRegister(const VirtualRegister &) = delete;
 
   protected:
     explicit VirtualRegister(TempAllocator &alloc)
       : intervals_(alloc)
     {}
 
   public:
     bool init(TempAllocator &alloc, LNode *ins, LDefinition *def,
@@ -525,18 +525,18 @@ class VirtualRegister
 // Index of the virtual registers in a graph. VREG is a subclass of
 // VirtualRegister extended with any allocator specific state for the vreg.
 template <typename VREG>
 class VirtualRegisterMap
 {
   private:
     FixedList<VREG> vregs_;
 
-    void operator=(const VirtualRegisterMap &) MOZ_DELETE;
-    VirtualRegisterMap(const VirtualRegisterMap &) MOZ_DELETE;
+    void operator=(const VirtualRegisterMap &) = delete;
+    VirtualRegisterMap(const VirtualRegisterMap &) = delete;
 
   public:
     VirtualRegisterMap()
       : vregs_()
     { }
 
     bool init(MIRGenerator *gen, uint32_t numVregs) {
         if (!vregs_.init(gen->alloc(), numVregs))
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -2600,19 +2600,19 @@ class AlwaysTenured
         MOZ_ASSERT_IF(pt->runtimeIfOnOwnerThread(), pt->suppressGC);
 #endif
     }
 
     operator T() const { return static_cast<T>(ptr_); }
     T operator->() const { return static_cast<T>(ptr_); }
 
   private:
-    AlwaysTenured() MOZ_DELETE;
-    AlwaysTenured(const AlwaysTenured<T> &) MOZ_DELETE;
-    AlwaysTenured<T> &operator=(const AlwaysTenured<T> &) MOZ_DELETE;
+    AlwaysTenured() = delete;
+    AlwaysTenured(const AlwaysTenured<T> &) = delete;
+    AlwaysTenured<T> &operator=(const AlwaysTenured<T> &) = delete;
 };
 
 typedef AlwaysTenured<JSObject*> AlwaysTenuredObject;
 typedef AlwaysTenured<NativeObject*> AlwaysTenuredNativeObject;
 typedef AlwaysTenured<JSFunction*> AlwaysTenuredFunction;
 typedef AlwaysTenured<JSScript*> AlwaysTenuredScript;
 typedef AlwaysTenured<PropertyName*> AlwaysTenuredPropertyName;
 typedef AlwaysTenured<Shape*> AlwaysTenuredShape;
--- a/js/src/jit/RegisterAllocator.h
+++ b/js/src/jit/RegisterAllocator.h
@@ -246,18 +246,18 @@ class InstructionDataMap
     LNode *const &operator[](uint32_t ins) const {
         return insData_[ins];
     }
 };
 
 // Common superclass for register allocators.
 class RegisterAllocator
 {
-    void operator=(const RegisterAllocator &) MOZ_DELETE;
-    RegisterAllocator(const RegisterAllocator &) MOZ_DELETE;
+    void operator=(const RegisterAllocator &) = delete;
+    RegisterAllocator(const RegisterAllocator &) = delete;
 
   protected:
     // Context
     MIRGenerator *mir;
     LIRGenerator *lir;
     LIRGraph &graph;
 
     // Pool of all registers that should be considered allocateable
--- a/js/src/jit/TypePolicy.cpp
+++ b/js/src/jit/TypePolicy.cpp
@@ -1047,17 +1047,17 @@ namespace jit {
 }
 
 namespace {
 
 // For extra-good measure in case an unqualified use is ever introduced.  (The
 // main use in the macro below is explicitly qualified so as not to consult
 // this scope and find this function.)
 inline TypePolicy *
-thisTypePolicy() MOZ_DELETE;
+thisTypePolicy() = delete;
 
 static MIRType
 thisTypeSpecialization()
 {
     MOZ_CRASH("TypeSpecialization lacks definition of thisTypeSpecialization.");
 }
 
 }
--- a/js/src/jit/arm/Simulator-arm.cpp
+++ b/js/src/jit/arm/Simulator-arm.cpp
@@ -275,19 +275,19 @@ class SimInstruction {
     // bit specifier. one_bit is the position of the additional single bit
     // specifier.
     inline int VFPGlueRegValue(VFPRegPrecision pre, int four_bit, int one_bit) {
         if (pre == kSinglePrecision)
             return (bits(four_bit + 3, four_bit) << 1) | bit(one_bit);
         return (bit(one_bit) << 4) | bits(four_bit + 3, four_bit);
     }
 
-    SimInstruction() MOZ_DELETE;
-    SimInstruction(const SimInstruction &other) MOZ_DELETE;
-    void operator=(const SimInstruction &other) MOZ_DELETE;
+    SimInstruction() = delete;
+    SimInstruction(const SimInstruction &other) = delete;
+    void operator=(const SimInstruction &other) = delete;
 };
 
 double
 SimInstruction::doubleImmedVmov() const
 {
     // Reconstruct a double from the immediate encoded in the vmov instruction.
     //
     //   instruction: [xxxxxxxx,xxxxabcd,xxxxxxxx,xxxxefgh]
--- a/js/src/jit/mips/Simulator-mips.cpp
+++ b/js/src/jit/mips/Simulator-mips.cpp
@@ -234,19 +234,19 @@ class SimInstruction
     bool isForbiddenInBranchDelay() const;
     // Say if the instruction 'links'. e.g. jal, bal.
     bool isLinkingInstruction() const;
     // Say if the instruction is a break or a trap.
     bool isTrap() const;
 
   private:
 
-    SimInstruction() MOZ_DELETE;
-    SimInstruction(const SimInstruction &other) MOZ_DELETE;
-    void operator=(const SimInstruction &other) MOZ_DELETE;
+    SimInstruction() = delete;
+    SimInstruction(const SimInstruction &other) = delete;
+    void operator=(const SimInstruction &other) = delete;
 };
 
 bool
 SimInstruction::isForbiddenInBranchDelay() const
 {
     const int op = opcodeFieldRaw();
     switch (op) {
       case op_j:
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -316,18 +316,18 @@ class AutoHashMapRooter : protected Auto
 
     void remove(const Lookup &l) {
         map.remove(l);
     }
 
     friend void AutoGCRooter::trace(JSTracer *trc);
 
   private:
-    AutoHashMapRooter(const AutoHashMapRooter &hmr) MOZ_DELETE;
-    AutoHashMapRooter &operator=(const AutoHashMapRooter &hmr) MOZ_DELETE;
+    AutoHashMapRooter(const AutoHashMapRooter &hmr) = delete;
+    AutoHashMapRooter &operator=(const AutoHashMapRooter &hmr) = delete;
 
     HashMapImpl map;
 
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
 template<class T>
 class AutoHashSetRooter : protected AutoGCRooter
@@ -425,18 +425,18 @@ class AutoHashSetRooter : protected Auto
 
     void remove(const Lookup &l) {
         set.remove(l);
     }
 
     friend void AutoGCRooter::trace(JSTracer *trc);
 
   private:
-    AutoHashSetRooter(const AutoHashSetRooter &hmr) MOZ_DELETE;
-    AutoHashSetRooter &operator=(const AutoHashSetRooter &hmr) MOZ_DELETE;
+    AutoHashSetRooter(const AutoHashSetRooter &hmr) = delete;
+    AutoHashSetRooter &operator=(const AutoHashSetRooter &hmr) = delete;
 
     HashSetImpl set;
 
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
 class MOZ_STACK_CLASS AutoValueVector : public AutoVectorRooter<Value>
 {
@@ -927,18 +927,18 @@ class MOZ_STACK_CLASS SourceBufferHolder
     // consequences.
     char16_t *take() {
         MOZ_ASSERT(ownsChars_);
         ownsChars_ = false;
         return const_cast<char16_t *>(data_);
     }
 
   private:
-    SourceBufferHolder(SourceBufferHolder &) MOZ_DELETE;
-    SourceBufferHolder &operator=(SourceBufferHolder &) MOZ_DELETE;
+    SourceBufferHolder(SourceBufferHolder &) = delete;
+    SourceBufferHolder &operator=(SourceBufferHolder &) = delete;
 
     const char16_t *data_;
     size_t length_;
     bool ownsChars_;
 };
 
 } /* namespace JS */
 
@@ -2349,18 +2349,18 @@ class AutoIdArray : private AutoGCRooter
     inline void trace(JSTracer *trc);
 
   private:
     JSContext *context;
     JSIdArray *idArray;
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
     /* No copy or assignment semantics. */
-    AutoIdArray(AutoIdArray &ida) MOZ_DELETE;
-    void operator=(AutoIdArray &ida) MOZ_DELETE;
+    AutoIdArray(AutoIdArray &ida) = delete;
+    void operator=(AutoIdArray &ida) = delete;
 };
 
 } /* namespace JS */
 
 extern JS_PUBLIC_API(bool)
 JS_ValueToId(JSContext *cx, JS::HandleValue v, JS::MutableHandleId idp);
 
 extern JS_PUBLIC_API(bool)
@@ -3755,17 +3755,17 @@ class JS_FRIEND_API(ReadOnlyCompileOptio
     // one of "eval", "Function", or "GeneratorFunction".
     const char *introductionType;
     unsigned introductionLineno;
     uint32_t introductionOffset;
     bool hasIntroductionInfo;
 
   private:
     static JSObject * const nullObjectPtr;
-    void operator=(const ReadOnlyCompileOptions &) MOZ_DELETE;
+    void operator=(const ReadOnlyCompileOptions &) = delete;
 };
 
 /*
  * Compilation options, with dynamic lifetime. An instance of this type
  * makes a copy of / holds / roots all dynamically allocated resources
  * (principals; elements; strings) that it refers to. Its destructor frees
  * / drops / unroots them. This is heavier than CompileOptions, below, but
  * unlike CompileOptions, it can outlive any given stack frame.
@@ -3845,17 +3845,17 @@ class JS_FRIEND_API(OwningCompileOptions
         introductionLineno = line;
         introductionScriptRoot = script;
         introductionOffset = offset;
         hasIntroductionInfo = true;
         return true;
     }
 
   private:
-    void operator=(const CompileOptions &rhs) MOZ_DELETE;
+    void operator=(const CompileOptions &rhs) = delete;
 };
 
 /*
  * Compilation options stored on the stack. An instance of this type
  * simply holds references to dynamically allocated resources (element;
  * filename; source map URL) that are owned by something else. If you
  * create an instance of this type, it's up to you to guarantee that
  * everything you store in it will outlive it.
@@ -3931,17 +3931,17 @@ class MOZ_STACK_CLASS JS_FRIEND_API(Comp
         return *this;
     }
     CompileOptions &maybeMakeStrictMode(bool strict) {
         strictOption = strictOption || strict;
         return *this;
     }
 
   private:
-    void operator=(const CompileOptions &rhs) MOZ_DELETE;
+    void operator=(const CompileOptions &rhs) = delete;
 };
 
 /*
  * |script| will always be set. On failure, it will be set to nullptr.
  */
 extern JS_PUBLIC_API(bool)
 Compile(JSContext *cx, JS::HandleObject obj, const ReadOnlyCompileOptions &options,
         SourceBufferHolder &srcBuf, JS::MutableHandleScript script);
@@ -5136,18 +5136,18 @@ namespace JS {
 /*
  * AutoFilename encapsulates a pointer to a C-string and keeps the C-string
  * alive for as long as the associated AutoFilename object is alive.
  */
 class MOZ_STACK_CLASS JS_PUBLIC_API(AutoFilename)
 {
     void *scriptSource_;
 
-    AutoFilename(const AutoFilename &) MOZ_DELETE;
-    void operator=(const AutoFilename &) MOZ_DELETE;
+    AutoFilename(const AutoFilename &) = delete;
+    void operator=(const AutoFilename &) = delete;
 
   public:
     AutoFilename() : scriptSource_(nullptr) {}
     ~AutoFilename() { reset(nullptr); }
 
     const char *get() const;
 
     void reset(void *newScriptSource);
@@ -5333,18 +5333,18 @@ class MOZ_STACK_CLASS JS_PUBLIC_API(ForO
      *
      * The cases are distinguished by whether or not |index| is equal to NOT_ARRAY.
      */
     JS::RootedObject iterator;
     uint32_t index;
 
     static const uint32_t NOT_ARRAY = UINT32_MAX;
 
-    ForOfIterator(const ForOfIterator &) MOZ_DELETE;
-    ForOfIterator &operator=(const ForOfIterator &) MOZ_DELETE;
+    ForOfIterator(const ForOfIterator &) = delete;
+    ForOfIterator &operator=(const ForOfIterator &) = delete;
 
   public:
     explicit ForOfIterator(JSContext *cx) : cx_(cx), iterator(cx_), index(NOT_ARRAY) { }
 
     enum NonIterableBehavior {
         ThrowOnNonIterable,
         AllowNonIterable
     };
--- a/js/src/jscompartment.h
+++ b/js/src/jscompartment.h
@@ -99,17 +99,17 @@ struct CrossCompartmentKey
     CrossCompartmentKey(Kind kind, JSObject *dbg, js::gc::Cell *wrapped)
       : kind(kind), debugger(dbg), wrapped(wrapped)
     {
         MOZ_RELEASE_ASSERT(dbg);
         MOZ_RELEASE_ASSERT(wrapped);
     }
 
   private:
-    CrossCompartmentKey() MOZ_DELETE;
+    CrossCompartmentKey() = delete;
 };
 
 struct WrapperHasher : public DefaultHasher<CrossCompartmentKey>
 {
     static HashNumber hash(const CrossCompartmentKey &key) {
         MOZ_ASSERT(!IsPoisonedPtr(key.wrapped));
         static_assert(sizeof(HashNumber) == sizeof(uint32_t),
                       "subsequent code assumes a four-byte hash");
@@ -592,18 +592,18 @@ class AutoCompartment
     inline AutoCompartment(ExclusiveContext *cx, JSObject *target);
     inline AutoCompartment(ExclusiveContext *cx, JSCompartment *target);
     inline ~AutoCompartment();
 
     ExclusiveContext *context() const { return cx_; }
     JSCompartment *origin() const { return origin_; }
 
   private:
-    AutoCompartment(const AutoCompartment &) MOZ_DELETE;
-    AutoCompartment & operator=(const AutoCompartment &) MOZ_DELETE;
+    AutoCompartment(const AutoCompartment &) = delete;
+    AutoCompartment & operator=(const AutoCompartment &) = delete;
 };
 
 /*
  * Use this to change the behavior of an AutoCompartment slightly on error. If
  * the exception happens to be an Error object, copy it to the origin compartment
  * instead of wrapping it.
  */
 class ErrorCopier
--- a/js/src/jsdate.cpp
+++ b/js/src/jsdate.cpp
@@ -299,17 +299,17 @@ DayFromMonth(int month, bool isLeapYear)
     };
 
     MOZ_ASSERT(0 <= month && month <= 12);
     return firstDayOfMonth[isLeapYear][month];
 }
 
 template<typename T>
 static inline int
-DayFromMonth(T month, bool isLeapYear) MOZ_DELETE;
+DayFromMonth(T month, bool isLeapYear) = delete;
 
 /* ES5 15.9.1.12 (out of order to accommodate DaylightSavingTA). */
 static double
 MakeDay(double year, double month, double date)
 {
     /* Step 1. */
     if (!IsFinite(year) || !IsFinite(month) || !IsFinite(date))
         return GenericNaN();
--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -1328,18 +1328,18 @@ class MOZ_STACK_CLASS AutoStableStringCh
         if (!ownsChars_)
             return false;
         state_ = Uninitialized;
         ownsChars_ = false;
         return true;
     }
 
   private:
-    AutoStableStringChars(const AutoStableStringChars &other) MOZ_DELETE;
-    void operator=(const AutoStableStringChars &other) MOZ_DELETE;
+    AutoStableStringChars(const AutoStableStringChars &other) = delete;
+    void operator=(const AutoStableStringChars &other) = delete;
 };
 
 // Creates a string of the form |ErrorType: ErrorMessage| for a JSErrorReport,
 // which generally matches the toString() behavior of an ErrorObject.
 extern JS_FRIEND_API(JSString *)
 ErrorReportToString(JSContext *cx, JSErrorReport *reportp);
 
 struct MOZ_STACK_CLASS JS_FRIEND_API(ErrorReport)
--- a/js/src/jsgc.h
+++ b/js/src/jsgc.h
@@ -1403,18 +1403,18 @@ class ZoneList
     void append(Zone *zone);
     void transferFrom(ZoneList &other);
     void removeFront();
 
   private:
     explicit ZoneList(Zone *singleZone);
     void check() const;
 
-    ZoneList(const ZoneList &other) MOZ_DELETE;
-    ZoneList &operator=(const ZoneList &other) MOZ_DELETE;
+    ZoneList(const ZoneList &other) = delete;
+    ZoneList &operator=(const ZoneList &other) = delete;
 };
 
 } /* namespace gc */
 
 #ifdef DEBUG
 /* Use this to avoid assertions when manipulating the wrapper map. */
 class AutoDisableProxyCheck
 {
--- a/js/src/jshashutil.h
+++ b/js/src/jshashutil.h
@@ -43,16 +43,16 @@ struct DependentAddPtr
     operator ConvertibleToBool() const { return found() ? &DependentAddPtr::nonNull : 0; }
     const Entry &operator*() const     { return *addPtr; }
     const Entry *operator->() const    { return &*addPtr; }
 
   private:
     AddPtr addPtr ;
     const uint64_t originalGcNumber;
 
-    DependentAddPtr() MOZ_DELETE;
-    DependentAddPtr(const DependentAddPtr&) MOZ_DELETE;
-    DependentAddPtr& operator=(const DependentAddPtr&) MOZ_DELETE;
+    DependentAddPtr() = delete;
+    DependentAddPtr(const DependentAddPtr&) = delete;
+    DependentAddPtr& operator=(const DependentAddPtr&) = delete;
 };
 
 } // namespace js
 
 #endif
--- a/js/src/jsobj.h
+++ b/js/src/jsobj.h
@@ -748,19 +748,19 @@ class JSObject : public js::gc::Cell
 
     static size_t offsetOfShape() { return offsetof(JSObject, shape_); }
     js::HeapPtrShape *addressOfShape() { return &shape_; }
 
     static size_t offsetOfType() { return offsetof(JSObject, type_); }
     js::HeapPtrTypeObject *addressOfType() { return &type_; }
 
   private:
-    JSObject() MOZ_DELETE;
-    JSObject(const JSObject &other) MOZ_DELETE;
-    void operator=(const JSObject &other) MOZ_DELETE;
+    JSObject() = delete;
+    JSObject(const JSObject &other) = delete;
+    void operator=(const JSObject &other) = delete;
 };
 
 template <class U>
 MOZ_ALWAYS_INLINE JS::Handle<U*>
 js::RootedBase<JSObject*>::as() const
 {
     const JS::Rooted<JSObject*> &self = *static_cast<const JS::Rooted<JSObject*>*>(this);
     MOZ_ASSERT(self->is<U>());
--- a/js/src/jspubtd.h
+++ b/js/src/jspubtd.h
@@ -268,18 +268,18 @@ class JS_PUBLIC_API(AutoGCRooter)
         CUSTOM =      -26, /* js::CustomAutoRooter */
         FUNVECTOR =   -27  /* js::AutoFunctionVector */
     };
 
   private:
     AutoGCRooter ** const stackTop;
 
     /* No copy or assignment semantics. */
-    AutoGCRooter(AutoGCRooter &ida) MOZ_DELETE;
-    void operator=(AutoGCRooter &ida) MOZ_DELETE;
+    AutoGCRooter(AutoGCRooter &ida) = delete;
+    void operator=(AutoGCRooter &ida) = delete;
 };
 
 } /* namespace JS */
 
 namespace js {
 
 /*
  * Parallel operations in general can have one of three states. They may
--- a/js/src/jsscript.h
+++ b/js/src/jsscript.h
@@ -2100,18 +2100,18 @@ struct SharedScriptData
         return reinterpret_cast<HeapPtrAtom *>(data + length - sizeof(JSAtom *) * natoms);
     }
 
     static SharedScriptData *fromBytecode(const jsbytecode *bytecode) {
         return (SharedScriptData *)(bytecode - offsetof(SharedScriptData, data));
     }
 
   private:
-    SharedScriptData() MOZ_DELETE;
-    SharedScriptData(const SharedScriptData&) MOZ_DELETE;
+    SharedScriptData() = delete;
+    SharedScriptData(const SharedScriptData&) = delete;
 };
 
 struct ScriptBytecodeHasher
 {
     struct Lookup
     {
         jsbytecode          *code;
         uint32_t            length;
--- a/js/src/jsstr.cpp
+++ b/js/src/jsstr.cpp
@@ -2180,18 +2180,18 @@ class MOZ_STACK_CLASS StringRegExpGuard
 
     bool regExpIsObject() { return obj_ != nullptr; }
     HandleObject regExpObject() {
         MOZ_ASSERT(regExpIsObject());
         return obj_;
     }
 
   private:
-    StringRegExpGuard(const StringRegExpGuard &) MOZ_DELETE;
-    void operator=(const StringRegExpGuard &) MOZ_DELETE;
+    StringRegExpGuard(const StringRegExpGuard &) = delete;
+    void operator=(const StringRegExpGuard &) = delete;
 };
 
 } /* anonymous namespace */
 
 static bool
 DoMatchLocal(JSContext *cx, CallArgs args, RegExpStatics *res, HandleLinearString input,
              RegExpShared &re)
 {
@@ -2433,18 +2433,18 @@ js::str_search(JSContext *cx, unsigned a
     return true;
 }
 
 // Utility for building a rope (lazy concatenation) of strings.
 class RopeBuilder {
     JSContext *cx;
     RootedString res;
 
-    RopeBuilder(const RopeBuilder &other) MOZ_DELETE;
-    void operator=(const RopeBuilder &other) MOZ_DELETE;
+    RopeBuilder(const RopeBuilder &other) = delete;
+    void operator=(const RopeBuilder &other) = delete;
 
   public:
     explicit RopeBuilder(JSContext *cx)
       : cx(cx), res(cx, cx->runtime()->emptyString)
     {}
 
     inline bool append(HandleString str) {
         res = ConcatStrings<CanGC>(cx, res, str);
--- a/js/src/jsstr.h
+++ b/js/src/jsstr.h
@@ -179,17 +179,17 @@ StringToSource(JSContext *cx, JSString *
  * Test if strings are equal. The caller can call the function even if str1
  * or str2 are not GC-allocated things.
  */
 extern bool
 EqualStrings(JSContext *cx, JSString *str1, JSString *str2, bool *result);
 
 /* Use the infallible method instead! */
 extern bool
-EqualStrings(JSContext *cx, JSLinearString *str1, JSLinearString *str2, bool *result) MOZ_DELETE;
+EqualStrings(JSContext *cx, JSLinearString *str1, JSLinearString *str2, bool *result) = delete;
 
 /* EqualStrings is infallible on linear strings. */
 extern bool
 EqualStrings(JSLinearString *str1, JSLinearString *str2);
 
 extern bool
 EqualChars(JSLinearString *str1, JSLinearString *str2);
 
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -958,17 +958,17 @@ ParseCompileOptions(JSContext *cx, Compi
 class AutoNewContext
 {
   private:
     JSContext *oldcx;
     JSContext *newcx;
     Maybe<JSAutoRequest> newRequest;
     Maybe<AutoCompartment> newCompartment;
 
-    AutoNewContext(const AutoNewContext &) MOZ_DELETE;
+    AutoNewContext(const AutoNewContext &) = delete;
 
   public:
     AutoNewContext() : oldcx(nullptr), newcx(nullptr) {}
 
     bool enter(JSContext *cx) {
         MOZ_ASSERT(!JS_IsExceptionPending(cx));
         oldcx = cx;
         newcx = NewContext(JS_GetRuntime(cx));
--- a/js/src/shell/jsheaptools.cpp
+++ b/js/src/shell/jsheaptools.cpp
@@ -97,18 +97,18 @@ class HeapReverser : public JSTracer, pu
          * be constructible with no arguments.
          */
         Vector<Edge, 0, SystemAllocPolicy> incoming;
 
         /* A mark bit, for other traversals. */
         bool marked;
 
       private:
-        Node(const Node &) MOZ_DELETE;
-        Node &operator=(const Node &) MOZ_DELETE;
+        Node(const Node &) = delete;
+        Node &operator=(const Node &) = delete;
     };
 
     /* Metadata for a heap edge we have traversed. */
     struct Edge {
       public:
         Edge(char *name, void *origin) : name(name), origin(origin) { }
         ~Edge() { js_free(name); }
 
--- a/js/src/vm/Debugger.h
+++ b/js/src/vm/Debugger.h
@@ -746,18 +746,18 @@ class Debugger : private mozilla::Linked
     /*
      * Return the Debugger.Source object for |source|, or create a new one if
      * needed. The context |cx| must be in the debugger compartment; |source|
      * must be a script source object in a debuggee compartment.
      */
     JSObject *wrapSource(JSContext *cx, js::HandleScriptSource source);
 
   private:
-    Debugger(const Debugger &) MOZ_DELETE;
-    Debugger & operator=(const Debugger &) MOZ_DELETE;
+    Debugger(const Debugger &) = delete;
+    Debugger & operator=(const Debugger &) = delete;
 };
 
 class BreakpointSite {
     friend class Breakpoint;
     friend struct ::JSCompartment;
     friend class ::JSScript;
     friend class Debugger;
 
--- a/js/src/vm/GlobalObject.h
+++ b/js/src/vm/GlobalObject.h
@@ -257,17 +257,17 @@ class GlobalObject : public NativeObject
         setSlot(CREATE_DATAVIEW_FOR_THIS, ObjectValue(*fun));
     }
 
     template<typename T>
     inline void setCreateArrayFromBuffer(Handle<JSFunction*> fun);
 
   private:
     // Disallow use of unqualified JSObject::create in GlobalObject.
-    static GlobalObject *create(...) MOZ_DELETE;
+    static GlobalObject *create(...) = delete;
 
     friend struct ::JSRuntime;
     static GlobalObject *createInternal(JSContext *cx, const Class *clasp);
 
   public:
     static GlobalObject *
     new_(JSContext *cx, const Class *clasp, JSPrincipals *principals,
          JS::OnNewGlobalHookOption hookOption, const JS::CompartmentOptions &options);
--- a/js/src/vm/Interpreter-inl.h
+++ b/js/src/vm/Interpreter-inl.h
@@ -880,15 +880,15 @@ class FastInvokeGuard
                 script_->incWarmUpCounter(5);
             }
         }
 
         return Invoke(cx, args_);
     }
 
   private:
-    FastInvokeGuard(const FastInvokeGuard& other) MOZ_DELETE;
-    const FastInvokeGuard& operator=(const FastInvokeGuard& other) MOZ_DELETE;
+    FastInvokeGuard(const FastInvokeGuard& other) = delete;
+    const FastInvokeGuard& operator=(const FastInvokeGuard& other) = delete;
 };
 
 }  /* namespace js */
 
 #endif /* vm_Interpreter_inl_h */
--- a/js/src/vm/Interpreter.h
+++ b/js/src/vm/Interpreter.h
@@ -144,20 +144,20 @@ class RunState
     JS::HandleScript script() const { return script_; }
 
     virtual InterpreterFrame *pushInterpreterFrame(JSContext *cx) = 0;
     virtual void setReturnValue(Value v) = 0;
 
     bool maybeCreateThisForConstructor(JSContext *cx);
 
   private:
-    RunState(const RunState &other) MOZ_DELETE;
-    RunState(const ExecuteState &other) MOZ_DELETE;
-    RunState(const InvokeState &other) MOZ_DELETE;
-    void operator=(const RunState &other) MOZ_DELETE;
+    RunState(const RunState &other) = delete;
+    RunState(const ExecuteState &other) = delete;
+    RunState(const InvokeState &other) = delete;
+    void operator=(const RunState &other) = delete;
 };
 
 // Eval or global script.
 class ExecuteState : public RunState
 {
     ExecuteType type_;
 
     RootedValue thisv_;
--- a/js/src/vm/JSONParser.h
+++ b/js/src/vm/JSONParser.h
@@ -170,18 +170,18 @@ class MOZ_STACK_CLASS JSONParserBase : p
     bool finishArray(MutableHandleValue vp, ElementVector &elements);
 
   private:
     friend void AutoGCRooter::trace(JSTracer *trc);
     void trace(JSTracer *trc);
 
     JSObject *createFinishedObject(PropertyVector &properties);
 
-    JSONParserBase(const JSONParserBase &other) MOZ_DELETE;
-    void operator=(const JSONParserBase &other) MOZ_DELETE;
+    JSONParserBase(const JSONParserBase &other) = delete;
+    void operator=(const JSONParserBase &other) = delete;
 };
 
 template <typename CharT>
 class MOZ_STACK_CLASS JSONParser : public JSONParserBase
 {
   private:
     typedef mozilla::RangedPtr<const CharT> CharPtr;
 
@@ -226,15 +226,15 @@ class MOZ_STACK_CLASS JSONParser : publi
     Token advanceAfterObjectOpen();
     Token advanceAfterArrayElement();
 
     void error(const char *msg);
 
     void getTextPosition(uint32_t *column, uint32_t *line);
 
   private:
-    JSONParser(const JSONParser &other) MOZ_DELETE;
-    void operator=(const JSONParser &other) MOZ_DELETE;
+    JSONParser(const JSONParser &other) = delete;
+    void operator=(const JSONParser &other) = delete;
 };
 
 } /* namespace js */
 
 #endif /* vm_JSONParser_h */
--- a/js/src/vm/PIC.h
+++ b/js/src/vm/PIC.h
@@ -68,17 +68,17 @@ class PICChain
     typedef typename Category::Stub CatStub;
     typedef typename Category::Chain CatChain;
 
   protected:
     CatStub *stubs_;
 
     PICChain() : stubs_(nullptr) {}
     // PICs should never be copy constructed.
-    PICChain(const PICChain<Category> &other) MOZ_DELETE;
+    PICChain(const PICChain<Category> &other) = delete;
 
   public:
     CatStub *stubs() const {
         return stubs_;
     }
 
     void addStub(CatStub *stub) {
         MOZ_ASSERT(stub);
@@ -117,18 +117,18 @@ class PICChain
  *  ForOfPIC defines a PIC category for optimizing for-of operations.
  */
 struct ForOfPIC
 {
     /* Forward declarations so template-substitution works. */
     class Stub;
     class Chain;
 
-    ForOfPIC() MOZ_DELETE;
-    ForOfPIC(const ForOfPIC &other) MOZ_DELETE;
+    ForOfPIC() = delete;
+    ForOfPIC(const ForOfPIC &other) = delete;
 
     typedef PICStub<ForOfPIC> BaseStub;
     typedef PICChain<ForOfPIC> BaseChain;
 
     /*
      * A ForOfPIC has only one kind of stub for now: one that holds the shape
      * of an array object that does not override its @@iterator property.
      */
--- a/js/src/vm/RegExpObject.h
+++ b/js/src/vm/RegExpObject.h
@@ -237,18 +237,18 @@ class RegExpShared
 /*
  * Extend the lifetime of a given RegExpShared to at least the lifetime of
  * the guard object. See Regular Expression comment at the top.
  */
 class RegExpGuard : public JS::CustomAutoRooter
 {
     RegExpShared *re_;
 
-    RegExpGuard(const RegExpGuard &) MOZ_DELETE;
-    void operator=(const RegExpGuard &) MOZ_DELETE;
+    RegExpGuard(const RegExpGuard &) = delete;
+    void operator=(const RegExpGuard &) = delete;
 
   public:
     explicit RegExpGuard(ExclusiveContext *cx)
       : CustomAutoRooter(cx), re_(nullptr)
     {}
 
     RegExpGuard(ExclusiveContext *cx, RegExpShared &re)
       : CustomAutoRooter(cx), re_(nullptr)
@@ -466,17 +466,17 @@ class RegExpObject : public NativeObject
      * Side effect: sets the private field.
      */
     bool createShared(JSContext *cx, RegExpGuard *g);
     RegExpShared *maybeShared() const {
         return static_cast<RegExpShared *>(NativeObject::getPrivate(PRIVATE_SLOT));
     }
 
     /* Call setShared in preference to setPrivate. */
-    void setPrivate(void *priv) MOZ_DELETE;
+    void setPrivate(void *priv) = delete;
 };
 
 /*
  * Parse regexp flags. Report an error and return false if an invalid
  * sequence of flags is encountered (repeat/invalid flag).
  *
  * N.B. flagStr must be rooted.
  */
--- a/js/src/vm/Runtime.h
+++ b/js/src/vm/Runtime.h
@@ -1535,18 +1535,18 @@ class MOZ_STACK_CLASS AutoLockGC
     }
 #endif
 
   private:
     JSRuntime *runtime_;
     mozilla::DebugOnly<bool> wasUnlocked_;
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
-    AutoLockGC(const AutoLockGC&) MOZ_DELETE;
-    AutoLockGC& operator=(const AutoLockGC&) MOZ_DELETE;
+    AutoLockGC(const AutoLockGC&) = delete;
+    AutoLockGC& operator=(const AutoLockGC&) = delete;
 };
 
 class MOZ_STACK_CLASS AutoUnlockGC
 {
   public:
     explicit AutoUnlockGC(AutoLockGC& lock
                           MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
       : lock(lock)
@@ -1558,18 +1558,18 @@ class MOZ_STACK_CLASS AutoUnlockGC
     ~AutoUnlockGC() {
         lock.lock();
     }
 
   private:
     AutoLockGC& lock;
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
-    AutoUnlockGC(const AutoUnlockGC&) MOZ_DELETE;
-    AutoUnlockGC& operator=(const AutoUnlockGC&) MOZ_DELETE;
+    AutoUnlockGC(const AutoUnlockGC&) = delete;
+    AutoUnlockGC& operator=(const AutoUnlockGC&) = delete;
 };
 
 class MOZ_STACK_CLASS AutoKeepAtoms
 {
     PerThreadData *pt;
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
   public:
--- a/js/src/vm/ScopeObject.h
+++ b/js/src/vm/ScopeObject.h
@@ -696,19 +696,19 @@ class ScopeIter
     RootedObject cur_;
     Rooted<NestedScopeObject *> staticScope_;
     Type type_;
     bool hasScopeObject_;
 
     void settle();
 
     /* ScopeIter does not have value semantics. */
-    ScopeIter(const ScopeIter &si) MOZ_DELETE;
+    ScopeIter(const ScopeIter &si) = delete;
 
-    ScopeIter(JSContext *cx) MOZ_DELETE;
+    ScopeIter(JSContext *cx) = delete;
 
   public:
 
     /* Constructing from a copy of an existing ScopeIter. */
     ScopeIter(const ScopeIter &si, JSContext *cx
               MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
 
     /* Constructing from AbstractFramePtr places ScopeIter on the innermost scope. */
--- a/js/src/vm/Shape.h
+++ b/js/src/vm/Shape.h
@@ -352,17 +352,17 @@ class BaseShape : public gc::TenuredCell
                                          * dictionary last properties. */
 
     /* For owned BaseShapes, the canonical unowned BaseShape. */
     HeapPtrUnownedBaseShape unowned_;
 
     /* For owned BaseShapes, the shape's shape table. */
     ShapeTable       *table_;
 
-    BaseShape(const BaseShape &base) MOZ_DELETE;
+    BaseShape(const BaseShape &base) = delete;
 
   public:
     void finalize(FreeOp *fop);
 
     BaseShape(JSCompartment *comp, const Class *clasp, JSObject *parent, JSObject *metadata,
               uint32_t objectFlags)
     {
         MOZ_ASSERT(!(objectFlags & ~OBJECT_FLAG_MASK));
@@ -773,17 +773,17 @@ class Shape : public gc::TenuredCell
 
     /* Get a shape identical to this one, without parent/kids information. */
     inline Shape(const StackShape &other, uint32_t nfixed);
 
     /* Used by EmptyShape (see jsscopeinlines.h). */
     inline Shape(UnownedBaseShape *base, uint32_t nfixed);
 
     /* Copy constructor disabled, to avoid misuse of the above form. */
-    Shape(const Shape &other) MOZ_DELETE;
+    Shape(const Shape &other) = delete;
 
     /* Allocate a new shape based on the given StackShape. */
     static inline Shape *new_(ExclusiveContext *cx, StackShape &unrootedOther, uint32_t nfixed);
 
     /*
      * Whether this shape has a valid slot value. This may be true even if
      * !hasSlot() (see SlotInfo comment above), and may be false even if
      * hasSlot() if the shape is being constructed and has not had a slot
--- a/js/src/vm/Stack.h
+++ b/js/src/vm/Stack.h
@@ -1129,18 +1129,18 @@ class Activation
         MOZ_ASSERT(hideScriptedCallerCount_ > 0);
         hideScriptedCallerCount_--;
     }
     bool scriptedCallerIsHidden() const {
         return hideScriptedCallerCount_ > 0;
     }
 
   private:
-    Activation(const Activation &other) MOZ_DELETE;
-    void operator=(const Activation &other) MOZ_DELETE;
+    Activation(const Activation &other) = delete;
+    void operator=(const Activation &other) = delete;
 };
 
 // This variable holds a special opcode value which is greater than all normal
 // opcodes, and is chosen such that the bitwise or of this value with any
 // opcode is this value.
 static const jsbytecode EnableInterruptsPseudoOpcode = -1;
 
 static_assert(EnableInterruptsPseudoOpcode >= JSOP_LIMIT,
--- a/js/src/vm/String.h
+++ b/js/src/vm/String.h
@@ -503,19 +503,19 @@ class JSString : public js::gc::TenuredC
     static MOZ_ALWAYS_INLINE void writeBarrierPre(JSString *thing) {
         if (isNullLike(thing) || thing->isPermanentAtom())
             return;
 
         TenuredCell::writeBarrierPre(thing);
     }
 
   private:
-    JSString() MOZ_DELETE;
-    JSString(const JSString &other) MOZ_DELETE;
-    void operator=(const JSString &other) MOZ_DELETE;
+    JSString() = delete;
+    JSString(const JSString &other) = delete;
+    void operator=(const JSString &other) = delete;
 };
 
 class JSRope : public JSString
 {
     template <typename CharT>
     bool copyCharsInternal(js::ThreadSafeContext *cx, js::ScopedJSFreePtr<CharT> &out,
                            bool nullTerminate) const;
 
@@ -574,19 +574,19 @@ static_assert(sizeof(JSRope) == sizeof(J
               "string subclasses must be binary-compatible with JSString");
 
 class JSLinearString : public JSString
 {
     friend class JSString;
     friend class js::AutoStableStringChars;
 
     /* Vacuous and therefore unimplemented. */
-    JSLinearString *ensureLinear(JSContext *cx) MOZ_DELETE;
-    bool isLinear() const MOZ_DELETE;
-    JSLinearString &asLinear() const MOZ_DELETE;
+    JSLinearString *ensureLinear(JSContext *cx) = delete;
+    bool isLinear() const = delete;
+    JSLinearString &asLinear() const = delete;
 
   protected:
     /* Returns void pointer to latin1/twoByte chars, for finalizers. */
     MOZ_ALWAYS_INLINE
     void *nonInlineCharsRaw() const {
         MOZ_ASSERT(!isInline());
         static_assert(offsetof(JSLinearString, d.s.u2.nonInlineCharsTwoByte) ==
                       offsetof(JSLinearString, d.s.u2.nonInlineCharsLatin1),
@@ -659,18 +659,18 @@ class JSDependentString : public JSLinea
 
     template <typename CharT>
     JSFlatString *undependInternal(js::ExclusiveContext *cx);
 
     void init(js::ThreadSafeContext *cx, JSLinearString *base, size_t start,
               size_t length);
 
     /* Vacuous and therefore unimplemented. */
-    bool isDependent() const MOZ_DELETE;
-    JSDependentString &asDependent() const MOZ_DELETE;
+    bool isDependent() const = delete;
+    JSDependentString &asDependent() const = delete;
 
     /* The offset of this string's chars in base->chars(). */
     size_t baseOffset() const {
         MOZ_ASSERT(JSString::isDependent());
         JS::AutoCheckCannotGC nogc;
         size_t offset;
         if (hasTwoByteChars())
             offset = twoByteChars(nogc) - base()->twoByteChars(nogc);
@@ -690,19 +690,19 @@ class JSDependentString : public JSLinea
 };
 
 static_assert(sizeof(JSDependentString) == sizeof(JSString),
               "string subclasses must be binary-compatible with JSString");
 
 class JSFlatString : public JSLinearString
 {
     /* Vacuous and therefore unimplemented. */
-    JSFlatString *ensureFlat(JSContext *cx) MOZ_DELETE;
-    bool isFlat() const MOZ_DELETE;
-    JSFlatString &asFlat() const MOZ_DELETE;
+    JSFlatString *ensureFlat(JSContext *cx) = delete;
+    bool isFlat() const = delete;
+    JSFlatString &asFlat() const = delete;
 
     template <typename CharT>
     static bool isIndexSlow(const CharT *s, size_t length, uint32_t *indexp);
 
     void init(const char16_t *chars, size_t length);
     void init(const JS::Latin1Char *chars, size_t length);
 
   public:
@@ -751,18 +751,18 @@ class JSFlatString : public JSLinearStri
 };
 
 static_assert(sizeof(JSFlatString) == sizeof(JSString),
               "string subclasses must be binary-compatible with JSString");
 
 class JSExtensibleString : public JSFlatString
 {
     /* Vacuous and therefore unimplemented. */
-    bool isExtensible() const MOZ_DELETE;
-    JSExtensibleString &asExtensible() const MOZ_DELETE;
+    bool isExtensible() const = delete;
+    JSExtensibleString &asExtensible() const = delete;
 
   public:
     MOZ_ALWAYS_INLINE
     size_t capacity() const {
         MOZ_ASSERT(JSString::isExtensible());
         return d.s.u3.capacity;
     }
 };
@@ -902,18 +902,18 @@ static_assert(sizeof(JSFatInlineString) 
               "fat inline strings shouldn't waste space up to the next cell "
               "boundary");
 
 class JSExternalString : public JSFlatString
 {
     void init(const char16_t *chars, size_t length, const JSStringFinalizer *fin);
 
     /* Vacuous and therefore unimplemented. */
-    bool isExternal() const MOZ_DELETE;
-    JSExternalString &asExternal() const MOZ_DELETE;
+    bool isExternal() const = delete;
+    JSExternalString &asExternal() const = delete;
 
   public:
     static inline JSExternalString *new_(JSContext *cx, const char16_t *chars, size_t length,
                                          const JSStringFinalizer *fin);
 
     const JSStringFinalizer *externalFinalizer() const {
         MOZ_ASSERT(JSString::isExternal());
         return d.s.u3.externalFinalizer;
@@ -945,18 +945,18 @@ class JSUndependedString : public JSFlat
 };
 
 static_assert(sizeof(JSUndependedString) == sizeof(JSString),
               "string subclasses must be binary-compatible with JSString");
 
 class JSAtom : public JSFlatString
 {
     /* Vacuous and therefore unimplemented. */
-    bool isAtom() const MOZ_DELETE;
-    JSAtom &asAtom() const MOZ_DELETE;
+    bool isAtom() const = delete;
+    JSAtom &asAtom() const = delete;
 
   public:
     /* Returns the PropertyName for this.  isIndex() must be false. */
     inline js::PropertyName *asPropertyName();
 
     inline void finalize(js::FreeOp *fop);
 
     MOZ_ALWAYS_INLINE
--- a/js/src/vm/StringBuffer.h
+++ b/js/src/vm/StringBuffer.h
@@ -49,18 +49,18 @@ class StringBuffer
      * Make sure ensureTwoByteChars() is called before calling
      * infallibleAppend(char16_t).
      */
     mozilla::DebugOnly<bool> hasEnsuredTwoByteChars_;
 
     /* Number of reserve()'d chars, see inflateChars. */
     size_t reserved_;
 
-    StringBuffer(const StringBuffer &other) MOZ_DELETE;
-    void operator=(const StringBuffer &other) MOZ_DELETE;
+    StringBuffer(const StringBuffer &other) = delete;
+    void operator=(const StringBuffer &other) = delete;
 
     MOZ_ALWAYS_INLINE bool isLatin1() const { return cb.constructed<Latin1CharBuffer>(); }
     MOZ_ALWAYS_INLINE bool isTwoByte() const { return !isLatin1(); }
 
     MOZ_ALWAYS_INLINE Latin1CharBuffer &latin1Chars() { return cb.ref<Latin1CharBuffer>(); }
     MOZ_ALWAYS_INLINE TwoByteCharBuffer &twoByteChars() { return cb.ref<TwoByteCharBuffer>(); }
 
     MOZ_ALWAYS_INLINE const Latin1CharBuffer &latin1Chars() const {
--- a/js/src/vm/Symbol.h
+++ b/js/src/vm/Symbol.h
@@ -30,18 +30,18 @@ class Symbol : public js::gc::TenuredCel
     // The minimum allocation size is sizeof(JSString): 16 bytes on 32-bit
     // architectures and 24 bytes on 64-bit.  8 bytes of padding makes Symbol
     // the minimum size on both.
     uint64_t unused2_;
 
     Symbol(SymbolCode code, JSAtom *desc)
         : code_(code), description_(desc) {}
 
-    Symbol(const Symbol &) MOZ_DELETE;
-    void operator=(const Symbol &) MOZ_DELETE;
+    Symbol(const Symbol &) = delete;
+    void operator=(const Symbol &) = delete;
 
     static Symbol *
     newInternal(js::ExclusiveContext *cx, SymbolCode code, JSAtom *description);
 
   public:
     static Symbol *new_(js::ExclusiveContext *cx, SymbolCode code, JSString *description);
     static Symbol *for_(js::ExclusiveContext *cx, js::HandleString description);
 
--- a/js/xpconnect/loader/mozJSComponentLoader.cpp
+++ b/js/xpconnect/loader/mozJSComponentLoader.cpp
@@ -142,18 +142,18 @@ public:
 
     void reportErrorAfterPop(char *buf);
 
 private:
     JSContext* mContext;
     char*      mBuf;
 
     // prevent copying and assignment
-    JSCLContextHelper(const JSCLContextHelper &) MOZ_DELETE;
-    const JSCLContextHelper& operator=(const JSCLContextHelper &) MOZ_DELETE;
+    JSCLContextHelper(const JSCLContextHelper &) = delete;
+    const JSCLContextHelper& operator=(const JSCLContextHelper &) = delete;
 };
 
 static nsresult
 ReportOnCaller(JSContext *callerContext,
                const char *format, ...) {
     if (!callerContext) {
         return NS_ERROR_FAILURE;
     }
--- a/js/xpconnect/src/xpcObjectHelper.h
+++ b/js/xpconnect/src/xpcObjectHelper.h
@@ -118,17 +118,17 @@ protected:
         if (!mCache && aObject)
             CallQueryInterface(aObject, &mCache);
     }
 
     nsCOMPtr<nsISupports>    mCanonicalStrong;
     nsISupports*             mCanonical;
 
 private:
-    xpcObjectHelper(xpcObjectHelper& aOther) MOZ_DELETE;
+    xpcObjectHelper(xpcObjectHelper& aOther) = delete;
 
     nsISupports*             mObject;
     nsWrapperCache*          mCache;
     nsCOMPtr<nsIClassInfo>   mClassInfo;
     nsRefPtr<nsXPCClassInfo> mXPCClassInfo;
 };
 
 #endif
--- a/js/xpconnect/src/xpcprivate.h
+++ b/js/xpconnect/src/xpcprivate.h
@@ -1934,18 +1934,18 @@ public:
     inline void TraceJS(JSTracer* trc) {}
     inline void AutoTrace(JSTracer* trc) {}
 
     void Mark()       {mJSObject.setFlags(1);}
     void Unmark()     {mJSObject.unsetFlags(1);}
     bool IsMarked() const {return mJSObject.hasFlag(1);}
 
 private:
-    XPCWrappedNativeTearOff(const XPCWrappedNativeTearOff& r) MOZ_DELETE;
-    XPCWrappedNativeTearOff& operator= (const XPCWrappedNativeTearOff& r) MOZ_DELETE;
+    XPCWrappedNativeTearOff(const XPCWrappedNativeTearOff& r) = delete;
+    XPCWrappedNativeTearOff& operator= (const XPCWrappedNativeTearOff& r) = delete;
 
 private:
     XPCNativeInterface* mInterface;
     nsISupports*        mNative;
     JS::TenuredHeap<JSObject*> mJSObject;
 };
 
 /***********************************************/
@@ -3022,18 +3022,18 @@ public:
 private:
     JSContext* mJSContext;
     mozilla::Maybe<JS::AutoSaveExceptionState> mState;
     bool mEvaluated;
     mozilla::Maybe<JSAutoCompartment> mAutoCompartment;
     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
     // No copying or assignment allowed
-    AutoScriptEvaluate(const AutoScriptEvaluate &) MOZ_DELETE;
-    AutoScriptEvaluate & operator =(const AutoScriptEvaluate &) MOZ_DELETE;
+    AutoScriptEvaluate(const AutoScriptEvaluate &) = delete;
+    AutoScriptEvaluate & operator =(const AutoScriptEvaluate &) = delete;
 };
 
 /***************************************************************************/
 class MOZ_STACK_CLASS AutoResolveName
 {
 public:
     AutoResolveName(XPCCallContext& ccx, JS::HandleId name
                     MOZ_GUARD_OBJECT_NOTIFIER_PARAM) :
--- a/js/xpconnect/src/xpcpublic.h
+++ b/js/xpconnect/src/xpcpublic.h
@@ -367,34 +367,34 @@ void SetLocationForGlobal(JSObject *glob
 class ZoneStatsExtras {
 public:
     ZoneStatsExtras()
     {}
 
     nsAutoCString pathPrefix;
 
 private:
-    ZoneStatsExtras(const ZoneStatsExtras &other) MOZ_DELETE;
-    ZoneStatsExtras& operator=(const ZoneStatsExtras &other) MOZ_DELETE;
+    ZoneStatsExtras(const ZoneStatsExtras &other) = delete;
+    ZoneStatsExtras& operator=(const ZoneStatsExtras &other) = delete;
 };
 
 // ReportJSRuntimeExplicitTreeStats will expect this in the |extra| member
 // of JS::CompartmentStats.
 class CompartmentStatsExtras {
 public:
     CompartmentStatsExtras()
     {}
 
     nsAutoCString jsPathPrefix;
     nsAutoCString domPathPrefix;
     nsCOMPtr<nsIURI> location;
 
 private:
-    CompartmentStatsExtras(const CompartmentStatsExtras &other) MOZ_DELETE;
-    CompartmentStatsExtras& operator=(const CompartmentStatsExtras &other) MOZ_DELETE;
+    CompartmentStatsExtras(const CompartmentStatsExtras &other) = delete;
+    CompartmentStatsExtras& operator=(const CompartmentStatsExtras &other) = delete;
 };
 
 // This reports all the stats in |rtStats| that belong in the "explicit" tree,
 // (which isn't all of them).
 // @see ZoneStatsExtras
 // @see CompartmentStatsExtras
 nsresult
 ReportJSRuntimeExplicitTreeStats(const JS::RuntimeStats &rtStats,
--- a/js/xpconnect/wrappers/XrayWrapper.h
+++ b/js/xpconnect/wrappers/XrayWrapper.h
@@ -99,18 +99,18 @@ private:
                                       JS::HandleObject exclusiveGlobal);
     bool getExpandoObjectInternal(JSContext *cx, JS::HandleObject target,
                                   nsIPrincipal *origin, JSObject *exclusiveGlobal,
                                   JS::MutableHandleObject expandoObject);
     JSObject* attachExpandoObject(JSContext *cx, JS::HandleObject target,
                                   nsIPrincipal *origin,
                                   JS::HandleObject exclusiveGlobal);
 
-    XrayTraits(XrayTraits &) MOZ_DELETE;
-    const XrayTraits& operator=(XrayTraits &) MOZ_DELETE;
+    XrayTraits(XrayTraits &) = delete;
+    const XrayTraits& operator=(XrayTraits &) = delete;
 };
 
 class XPCWrappedNativeXrayTraits : public XrayTraits
 {
 public:
     enum {
         HasPrototype = 0
     };
--- a/layout/base/MaskLayerImageCache.h
+++ b/layout/base/MaskLayerImageCache.h
@@ -111,17 +111,17 @@ public:
       return hash;
     }
 
     gfx::Rect mRect;
     // Indices into mRadii are the NS_CORNER_* constants in nsStyleConsts.h
     gfxFloat mRadii[8];
 
   private:
-    PixelRoundedRect() MOZ_DELETE;
+    PixelRoundedRect() = delete;
   };
 
   /**
    * A key to identify cached image containers.
    * The const-ness of this class is with respect to its use as a key into a
    * hashtable, so anything not used to create the hash is mutable.
    * mLayerCount counts the number of mask layers which have a reference to
    * MaskLayerImageEntry::mContainer; it is maintained by MaskLayerUserData,
--- a/layout/base/SelectionCarets.h
+++ b/layout/base/SelectionCarets.h
@@ -103,17 +103,17 @@ public:
   static int32_t SelectionCaretsInflateSize()
   {
     return sSelectionCaretsInflateSize;
   }
 
 private:
   virtual ~SelectionCarets();
 
-  SelectionCarets() MOZ_DELETE;
+  SelectionCarets() = delete;
 
   /**
    * Set visibility for selection caret.
    */
   void SetVisibility(bool aVisible);
 
   /**
    * Update selection caret position base on current selection range.
--- a/layout/base/TouchCaret.h
+++ b/layout/base/TouchCaret.h
@@ -57,17 +57,17 @@ public:
    */
   bool GetVisibility() const
   {
     return mVisible;
   }
 
 private:
   // Hide default constructor.
-  TouchCaret() MOZ_DELETE;
+  TouchCaret() = delete;
 
   ~TouchCaret();
 
   bool IsDisplayable();
 
   void UpdatePosition();
 
   /**
--- a/layout/base/nsCSSFrameConstructor.h
+++ b/layout/base/nsCSSFrameConstructor.h
@@ -65,18 +65,18 @@ public:
   }
 
   // get the alternate text for a content node
   static void GetAlternateTextFor(nsIContent*    aContent,
                                   nsIAtom*       aTag,  // content object's tag
                                   nsXPIDLString& aAltText);
 
 private:
-  nsCSSFrameConstructor(const nsCSSFrameConstructor& aCopy) MOZ_DELETE;
-  nsCSSFrameConstructor& operator=(const nsCSSFrameConstructor& aCopy) MOZ_DELETE;
+  nsCSSFrameConstructor(const nsCSSFrameConstructor& aCopy) = delete;
+  nsCSSFrameConstructor& operator=(const nsCSSFrameConstructor& aCopy) = delete;
 
 public:
   mozilla::RestyleManager* RestyleManager() const
     { return mPresShell->GetPresContext()->RestyleManager(); }
 
   nsIFrame* ConstructRootFrame();
 
   nsresult ReconstructDocElementHierarchy();
@@ -1158,17 +1158,17 @@ private:
     // go into the global popup items.
     bool mIsPopup:1;
     // Whether this item should be treated as a line participant
     bool mIsLineParticipant:1;
     // Whether this item is for an SVG <a> element
     bool mIsForSVGAElement:1;
 
   private:
-    FrameConstructionItem(const FrameConstructionItem& aOther) MOZ_DELETE; /* not implemented */
+    FrameConstructionItem(const FrameConstructionItem& aOther) = delete; /* not implemented */
   };
 
   /**
    * Function to create the anonymous flex or grid items that we need.
    * If aParentFrame is not a nsFlexContainerFrame or nsGridContainerFrame then
    * this method is a NOP.
    * @param aItems the child frame construction items before pseudo creation
    * @param aParentFrame the parent frame
--- a/layout/base/nsStyleChangeList.h
+++ b/layout/base/nsStyleChangeList.h
@@ -60,13 +60,13 @@ protected:
   bool                operator==(const nsStyleChangeList& aOther) const;
 
   nsStyleChangeData*  mArray;
   int32_t             mArraySize;
   int32_t             mCount;
   nsStyleChangeData   mBuffer[kStyleChangeBufferSize];
 
 private:
-  nsStyleChangeList(const nsStyleChangeList&) MOZ_DELETE;
+  nsStyleChangeList(const nsStyleChangeList&) = delete;
 };
 
 
 #endif /* nsStyleChangeList_h___ */
--- a/layout/generic/WritingModes.h
+++ b/layout/generic/WritingModes.h
@@ -629,17 +629,17 @@ private:
    */
 #ifdef DEBUG
   WritingMode GetWritingMode() const { return mWritingMode; }
 #else
   WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
 #endif
 
   // We don't allow construction of a LogicalPoint with no writing mode.
-  LogicalPoint() MOZ_DELETE;
+  LogicalPoint() = delete;
 
   // Accessors that don't take or check a WritingMode value.
   // These are for internal use only; they are called by methods that have
   // themselves already checked the WritingMode passed by the caller.
   nscoord I() const // inline-axis
   {
     return mPoint.x;
   }
@@ -838,17 +838,17 @@ public:
     ISize() -= aOther.ISize();
     BSize() -= aOther.BSize();
     return *this;
   }
 
 private:
   friend class LogicalRect;
 
-  LogicalSize() MOZ_DELETE;
+  LogicalSize() = delete;
 
 #ifdef DEBUG
   WritingMode GetWritingMode() const { return mWritingMode; }
 #else
   WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
 #endif
 
   nscoord ISize() const // inline-size
@@ -1141,17 +1141,17 @@ public:
                          IEnd() - aMargin.IEnd(),
                          BEnd() - aMargin.BEnd(),
                          IStart() - aMargin.IStart());
   }
 
 private:
   friend class LogicalRect;
 
-  LogicalMargin() MOZ_DELETE;
+  LogicalMargin() = delete;
 
 #ifdef DEBUG
   WritingMode GetWritingMode() const { return mWritingMode; }
 #else
   WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
 #endif
 
   nscoord IStart() const // inline-start margin
@@ -1566,17 +1566,17 @@ public:
   {
     CHECK_WRITING_MODE(aFromMode);
     return aToMode == aFromMode ?
       *this : LogicalRect(aToMode, GetPhysicalRect(aFromMode, aContainerWidth),
                           aContainerWidth);
   }
 
 private:
-  LogicalRect() MOZ_DELETE;
+  LogicalRect() = delete;
 
 #ifdef DEBUG
   WritingMode GetWritingMode() const { return mWritingMode; }
 #else
   WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
 #endif
 
   nscoord IStart() const // inline-start edge
--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -1723,23 +1723,23 @@ public:
   // Advances past the packing space (if any) between two flex lines
   void TraversePackingSpace();
 
   // Advances past the given FlexLine
   void TraverseLine(FlexLine& aLine) { mPosition += aLine.GetLineCrossSize(); }
 
 private:
   // Redeclare the frame-related methods from PositionTracker as private with
-  // MOZ_DELETE, to be sure (at compile time) that no client code can invoke
+  // = delete, to be sure (at compile time) that no client code can invoke
   // them. (Unlike the other PositionTracker derived classes, this class here
   // deals with FlexLines, not with individual FlexItems or frames.)
-  void EnterMargin(const nsMargin& aMargin) MOZ_DELETE;
-  void ExitMargin(const nsMargin& aMargin) MOZ_DELETE;
-  void EnterChildFrame(nscoord aChildFrameSize) MOZ_DELETE;
-  void ExitChildFrame(nscoord aChildFrameSize) MOZ_DELETE;
+  void EnterMargin(const nsMargin& aMargin) = delete;
+  void ExitMargin(const nsMargin& aMargin) = delete;
+  void EnterChildFrame(nscoord aChildFrameSize) = delete;
+  void ExitChildFrame(nscoord aChildFrameSize) = delete;
 
   nscoord  mPackingSpaceRemaining;
   uint32_t mNumPackingSpacesRemaining;
   uint8_t  mAlignContent;
 };
 
 // Utility class for managing our position along the cross axis, *within* a
 // single flex line.
--- a/layout/generic/nsFloatManager.h
+++ b/layout/generic/nsFloatManager.h
@@ -376,18 +376,18 @@ private:
   // next page/column.  This means that any 'clear' needs to continue to
   // the next page/column.
   bool mSplitLeftFloatAcrossBreak;
   bool mSplitRightFloatAcrossBreak;
 
   static int32_t sCachedFloatManagerCount;
   static void* sCachedFloatManagers[NS_FLOAT_MANAGER_CACHE_SIZE];
 
-  nsFloatManager(const nsFloatManager&) MOZ_DELETE;
-  void operator=(const nsFloatManager&) MOZ_DELETE;
+  nsFloatManager(const nsFloatManager&) = delete;
+  void operator=(const nsFloatManager&) = delete;
 };
 
 /**
  * A helper class to manage maintenance of the float manager during
  * nsBlockFrame::Reflow. It automatically restores the old float
  * manager in the reflow state when the object goes out of scope.
  */
 class nsAutoFloatManager {
--- a/layout/generic/nsFontInflationData.h
+++ b/layout/generic/nsFontInflationData.h
@@ -35,18 +35,18 @@ public:
   nscoord EffectiveWidth() const {
     return mNCAWidth;
   }
 
 private:
 
   explicit nsFontInflationData(nsIFrame* aBFCFrame);
 
-  nsFontInflationData(const nsFontInflationData&) MOZ_DELETE;
-  void operator=(const nsFontInflationData&) MOZ_DELETE;
+  nsFontInflationData(const nsFontInflationData&) = delete;
+  void operator=(const nsFontInflationData&) = delete;
 
   void UpdateWidth(const nsHTMLReflowState &aReflowState);
   enum SearchDirection { eFromStart, eFromEnd };
   static nsIFrame* FindEdgeInflatableFrameIn(nsIFrame *aFrame,
                                              SearchDirection aDirection);
 
   void MarkTextDirty() { mTextDirty = true; }
   void ScanText();
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -9186,17 +9186,17 @@ struct DR_FrameTypeInfo
       }
    }
 
   nsIAtom*    mType;
   char        mNameAbbrev[16];
   char        mName[32];
   nsTArray<DR_Rule*> mRules;
 private:
-  DR_FrameTypeInfo& operator=(const DR_FrameTypeInfo&) MOZ_DELETE;
+  DR_FrameTypeInfo& operator=(const DR_FrameTypeInfo&) = delete;
 };
 
 DR_FrameTypeInfo::DR_FrameTypeInfo(nsIAtom* aFrameType, 
                                    const char* aFrameNameAbbrev, 
                                    const char* aFrameName)
 {
   mType = aFrameType;
   PL_strncpyz(mNameAbbrev, aFrameNameAbbrev, sizeof(mNameAbbrev));
--- a/layout/generic/nsFrameList.h
+++ b/layout/generic/nsFrameList.h
@@ -443,17 +443,17 @@ public:
     nsIFrame* PrevFrame() const { return mPrev; }
     nsIFrame* NextFrame() const { return mFrame; }
 
   protected:
     nsIFrame* mPrev;
   };
 
 private:
-  void operator delete(void*) MOZ_DELETE;
+  void operator delete(void*) = delete;
 
 #ifdef DEBUG_FRAME_LIST
   void VerifyList() const;
 #else
   void VerifyList() const {}
 #endif
 
 protected:
--- a/layout/generic/nsLineBox.h
+++ b/layout/generic/nsLineBox.h
@@ -204,17 +204,17 @@ class nsLineLink {
 class nsLineBox MOZ_FINAL : public nsLineLink {
 private:
   nsLineBox(nsIFrame* aFrame, int32_t aCount, bool aIsBlock);
   ~nsLineBox();
   
   // Overloaded new operator. Uses an arena (which comes from the presShell)
   // to perform the allocation.
   void* operator new(size_t sz, nsIPresShell* aPresShell) CPP_THROW_NEW;
-  void operator delete(void* aPtr, size_t sz) MOZ_DELETE;
+  void operator delete(void* aPtr, size_t sz) = delete;
 
 public:
   // Use these functions to allocate and destroy line boxes
   friend nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsIFrame* aFrame,
                                   bool aIsBlock);
   friend nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsLineBox* aFromLine,
                                   nsIFrame* aFrame, int32_t aCount);
   void Destroy(nsIPresShell* aPresShell);
--- a/layout/mathml/nsMathMLSelectedFrame.h
+++ b/layout/mathml/nsMathMLSelectedFrame.h
@@ -48,12 +48,12 @@ protected:
   virtual ~nsMathMLSelectedFrame();
   
   virtual nsIFrame* GetSelectedFrame() = 0;
   nsIFrame*       mSelectedFrame;
 
   bool            mInvalidMarkup;
   
 private:
-  void* operator new(size_t, nsIPresShell*) MOZ_MUST_OVERRIDE MOZ_DELETE;
+  void* operator new(size_t, nsIPresShell*) MOZ_MUST_OVERRIDE = delete;
 };
 
 #endif /* nsMathMLSelectedFrame_h___ */
--- a/layout/printing/nsPrintData.h
+++ b/layout/printing/nsPrintData.h
@@ -80,15 +80,15 @@ public:
   float                       mOrigDCScale;
 
   nsCOMPtr<nsIPrintSettings>  mPrintSettings;
   nsPrintPreviewListener*     mPPEventListeners;
 
   char16_t*            mBrandName; //  needed as a substitute name for a document
 
 private:
-  nsPrintData() MOZ_DELETE;
-  nsPrintData& operator=(const nsPrintData& aOther) MOZ_DELETE;
+  nsPrintData() = delete;
+  nsPrintData& operator=(const nsPrintData& aOther) = delete;
 
 };
 
 #endif /* nsPrintData_h___ */
 
--- a/layout/printing/nsPrintEngine.h
+++ b/layout/printing/nsPrintEngine.h
@@ -302,12 +302,12 @@ protected:
   bool DoSetPixelScale();
   void UpdateZoomRatio(nsPrintObject* aPO, bool aSetPixelScale);
   nsresult ReconstructAndReflow(bool aDoSetPixelScale);
   nsresult UpdateSelectionAndShrinkPrintObject(nsPrintObject* aPO,
                                                bool aDocumentIsTopLevel);
   nsresult InitPrintDocConstruction(bool aHandleError);
   void FirePrintPreviewUpdateEvent();
 private:
-  nsPrintEngine& operator=(const nsPrintEngine& aOther) MOZ_DELETE;
+  nsPrintEngine& operator=(const nsPrintEngine& aOther) = delete;
 };
 
 #endif /* nsPrintEngine_h___ */
--- a/layout/printing/nsPrintObject.h
+++ b/layout/printing/nsPrintObject.h
@@ -58,15 +58,15 @@ public:
   bool             mPrintAsIs;
   bool             mInvisible;        // Indicates PO is set to not visible by CSS
   bool             mPrintPreview;
   bool             mDidCreateDocShell;
   float            mShrinkRatio;
   float            mZoomRatio;
 
 private:
-  nsPrintObject& operator=(const nsPrintObject& aOther) MOZ_DELETE;
+  nsPrintObject& operator=(const nsPrintObject& aOther) = delete;
 };
 
 
 
 #endif /* nsPrintObject_h___ */
 
--- a/layout/style/CSS.h
+++ b/layout/style/CSS.h
@@ -16,17 +16,17 @@ namespace mozilla {
 class ErrorResult;
 
 namespace dom {
 
 class GlobalObject;
 
 class CSS {
 private:
-  CSS() MOZ_DELETE;
+  CSS() = delete;
 
 public:
   static bool Supports(const GlobalObject& aGlobal,
                        const nsAString& aProperty,
                        const nsAString& aValue,
                        ErrorResult& aRv);
 
   static bool Supports(const GlobalObject& aGlobal,
--- a/layout/style/CSSStyleSheet.h
+++ b/layout/style/CSSStyleSheet.h
@@ -314,18 +314,18 @@ public:
 
 private:
   CSSStyleSheet(const CSSStyleSheet& aCopy,
                 CSSStyleSheet* aParentToUse,
                 css::ImportRule* aOwnerRuleToUse,
                 nsIDocument* aDocumentToUse,
                 nsINode* aOwningNodeToUse);
 
-  CSSStyleSheet(const CSSStyleSheet& aCopy) MOZ_DELETE;
-  CSSStyleSheet& operator=(const CSSStyleSheet& aCopy) MOZ_DELETE;
+  CSSStyleSheet(const CSSStyleSheet& aCopy) = delete;
+  CSSStyleSheet& operator=(const CSSStyleSheet& aCopy) = delete;
 
 protected:
   virtual ~CSSStyleSheet();
 
   void ClearRuleCascades();
 
   void     WillDirty();
   void     DidDirty();
--- a/layout/style/CounterStyleManager.h
+++ b/layout/style/CounterStyleManager.h
@@ -36,18 +36,18 @@ class CounterStyle
 {
 protected:
   explicit MOZ_CONSTEXPR CounterStyle(int32_t aStyle)
     : mStyle(aStyle)
   {
   }
 
 private:
-  CounterStyle(const CounterStyle& aOther) MOZ_DELETE;
-  void operator=(const CounterStyle& other) MOZ_DELETE;
+  CounterStyle(const CounterStyle& aOther) = delete;
+  void operator=(const CounterStyle& other) = delete;
 
 public:
   int32_t GetStyle() const { return mStyle; }
   bool IsNone() const { return mStyle == NS_STYLE_LIST_STYLE_NONE; }
   bool IsCustomStyle() const { return mStyle == NS_STYLE_LIST_STYLE_CUSTOM; }
   // A style is dependent if it depends on the counter style manager.
   // Custom styles are certainly dependent. In addition, some builtin
   // styles are dependent for fallback.
--- a/layout/style/Declaration.h
+++ b/layout/style/Declaration.h
@@ -272,18 +272,18 @@ public:
     mVariableOrder.Clear();
   }
 
 #ifdef DEBUG
   void List(FILE* out = stdout, int32_t aIndent = 0) const;
 #endif
 
 private:
-  Declaration& operator=(const Declaration& aCopy) MOZ_DELETE;
-  bool operator==(const Declaration& aCopy) const MOZ_DELETE;
+  Declaration& operator=(const Declaration& aCopy) = delete;
+  bool operator==(const Declaration& aCopy) const = delete;
 
   void GetValue(nsCSSProperty aProperty, nsAString& aValue,
                 nsCSSValue::Serialization aValueSerialization) const;
 
   static void AppendImportanceToString(bool aIsImportant, nsAString& aString);
   // return whether there was a value in |aValue| (i.e., it had a non-null unit)
   bool AppendValueToString(nsCSSProperty aProperty, nsAString& aResult) const;
   bool AppendValueToString(nsCSSProperty aProperty, nsAString& aResult,
--- a/layout/style/SVGAttrAnimationRuleProcessor.h
+++ b/layout/style/SVGAttrAnimationRuleProcessor.h
@@ -54,15 +54,15 @@ public:
 
   size_t DOMSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
   // A shortcut for nsStyleSet to call RulesMatching with less setup.
   void ElementRulesMatching(mozilla::dom::Element* aElement,
                             nsRuleWalker* aRuleWalker);
 
 private:
-  SVGAttrAnimationRuleProcessor(const SVGAttrAnimationRuleProcessor& aCopy) MOZ_DELETE;
-  SVGAttrAnimationRuleProcessor& operator=(const SVGAttrAnimationRuleProcessor& aCopy) MOZ_DELETE;
+  SVGAttrAnimationRuleProcessor(const SVGAttrAnimationRuleProcessor& aCopy) = delete;
+  SVGAttrAnimationRuleProcessor& operator=(const SVGAttrAnimationRuleProcessor& aCopy) = delete;
 };
 
 } // namespace mozilla
 
 #endif /* !defined(mozilla_SVGAttrAnimationRuleProcessor_h_) */
--- a/layout/style/StyleRule.h
+++ b/layout/style/StyleRule.h
@@ -39,18 +39,18 @@ public:
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
   nsCOMPtr<nsIAtom> mAtom;
   nsAtomList*       mNext;
 private: 
   nsAtomList* Clone(bool aDeep) const;
 
-  nsAtomList(const nsAtomList& aCopy) MOZ_DELETE;
-  nsAtomList& operator=(const nsAtomList& aCopy) MOZ_DELETE;
+  nsAtomList(const nsAtomList& aCopy) = delete;
+  nsAtomList& operator=(const nsAtomList& aCopy) = delete;
 };
 
 struct nsPseudoClassList {
 public:
   explicit nsPseudoClassList(nsCSSPseudoClasses::Type aType);
   nsPseudoClassList(nsCSSPseudoClasses::Type aType, const char16_t *aString);
   nsPseudoClassList(nsCSSPseudoClasses::Type aType, const int32_t *aIntPair);
   nsPseudoClassList(nsCSSPseudoClasses::Type aType,
@@ -77,18 +77,18 @@ public:
     int32_t*        mNumbers;
     nsCSSSelectorList* mSelectors;
   } u;
   nsCSSPseudoClasses::Type mType;
   nsPseudoClassList* mNext;
 private: 
   nsPseudoClassList* Clone(bool aDeep) const;
 
-  nsPseudoClassList(const nsPseudoClassList& aCopy) MOZ_DELETE;
-  nsPseudoClassList& operator=(const nsPseudoClassList& aCopy) MOZ_DELETE;
+  nsPseudoClassList(const nsPseudoClassList& aCopy) = delete;
+  nsPseudoClassList& operator=(const nsPseudoClassList& aCopy) = delete;
 };
 
 #define NS_ATTR_FUNC_SET        0     // [attr]
 #define NS_ATTR_FUNC_EQUALS     1     // [attr=value]
 #define NS_ATTR_FUNC_INCLUDES   2     // [attr~=value] (space separated)
 #define NS_ATTR_FUNC_DASHMATCH  3     // [attr|=value] ('-' truncated)
 #define NS_ATTR_FUNC_BEGINSMATCH  4   // [attr^=value] (begins with)
 #define NS_ATTR_FUNC_ENDSMATCH  5     // [attr$=value] (ends with)
@@ -113,18 +113,18 @@ public:
   nsCOMPtr<nsIAtom> mCasedAttr;
   int32_t         mNameSpace;
   uint8_t         mFunction;
   bool            mCaseSensitive; // If we are in an HTML document,
                                   // is the value case sensitive?
 private: 
   nsAttrSelector* Clone(bool aDeep) const;
 
-  nsAttrSelector(const nsAttrSelector& aCopy) MOZ_DELETE;
-  nsAttrSelector& operator=(const nsAttrSelector& aCopy) MOZ_DELETE;
+  nsAttrSelector(const nsAttrSelector& aCopy) = delete;
+  nsAttrSelector& operator=(const nsAttrSelector& aCopy) = delete;
 };
 
 struct nsCSSSelector {
 public:
   nsCSSSelector(void);
   ~nsCSSSelector(void);
 
   /** Do a deep clone.  Should be used only on the first in the linked list. */
@@ -206,18 +206,18 @@ public:
   nsCSSSelector*  mNegations;
   nsCSSSelector*  mNext;
   int32_t         mNameSpace;
   char16_t       mOperator;
 private:
   // int16_t to make sure it packs well with mOperator
   int16_t        mPseudoType;
 
-  nsCSSSelector(const nsCSSSelector& aCopy) MOZ_DELETE;
-  nsCSSSelector& operator=(const nsCSSSelector& aCopy) MOZ_DELETE;
+  nsCSSSelector(const nsCSSSelector& aCopy) = delete;
+  nsCSSSelector& operator=(const nsCSSSelector& aCopy) = delete;
 };
 
 /**
  * A selector list is the unit of selectors that each style rule has.
  * For example, "P B, H1 B { ... }" would be a selector list with two
  * items (where each |nsCSSSelectorList| object's |mSelectors| has
  * an |mNext| for the P or H1).  We represent them as linked lists.
  */
@@ -260,18 +260,18 @@ struct nsCSSSelectorList {
   nsCSSSelector*     mSelectors;
   int32_t            mWeight;
   nsCSSSelectorList* mNext;
 protected:
   friend class inDOMUtils;
   nsCSSSelectorList* Clone(bool aDeep) const;
 
 private:
-  nsCSSSelectorList(const nsCSSSelectorList& aCopy) MOZ_DELETE;
-  nsCSSSelectorList& operator=(const nsCSSSelectorList& aCopy) MOZ_DELETE;
+  nsCSSSelectorList(const nsCSSSelectorList& aCopy) = delete;
+  nsCSSSelectorList& operator=(const nsCSSSelectorList& aCopy) = delete;
 };
 
 // 464bab7a-2fce-4f30-ab44-b7a5f3aae57d
 #define NS_CSS_STYLE_RULE_IMPL_CID \
 { 0x464bab7a, 0x2fce, 0x4f30, \
   { 0xab, 0x44, 0xb7, 0xa5, 0xf3, 0xaa, 0xe5, 0x7d } }
 
 namespace mozilla {
@@ -375,17 +375,17 @@ private:
 
 private:
   nsCSSSelectorList*      mSelector; // null for style attribute
   Declaration*            mDeclaration;
   nsRefPtr<ImportantRule> mImportantRule; // initialized by RuleMatched
   nsRefPtr<DOMCSSStyleRule> mDOMRule;
 
 private:
-  StyleRule& operator=(const StyleRule& aCopy) MOZ_DELETE;
+  StyleRule& operator=(const StyleRule& aCopy) = delete;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(StyleRule, NS_CSS_STYLE_RULE_IMPL_CID)
 
 } // namespace css
 } // namespace mozilla
 
 #endif /* mozilla_css_StyleRule_h__ */
--- a/layout/style/nsCSSParser.h
+++ b/layout/style/nsCSSParser.h
@@ -43,18 +43,18 @@ class MOZ_STACK_CLASS nsCSSParser {
 public:
   explicit nsCSSParser(mozilla::css::Loader* aLoader = nullptr,
                        mozilla::CSSStyleSheet* aSheet = nullptr);
   ~nsCSSParser();
 
   static void Shutdown();
 
 private:
-  nsCSSParser(nsCSSParser const&) MOZ_DELETE;
-  nsCSSParser& operator=(nsCSSParser const&) MOZ_DELETE;
+  nsCSSParser(nsCSSParser const&) = delete;
+  nsCSSParser& operator=(nsCSSParser const&) = delete;
 
 public:
   // Set a style sheet for the parser to fill in. The style sheet must
   // implement the CSSStyleSheet interface.  Null can be passed in to clear
   // out an existing stylesheet reference.
   nsresult SetStyleSheet(mozilla::CSSStyleSheet* aSheet);
 
   // Set whether or not to emulate Nav quirks
--- a/layout/style/nsCSSValue.h
+++ b/layout/style/nsCSSValue.h
@@ -113,18 +113,18 @@ public:
   nsCOMPtr<nsIURI> mReferrer;
   nsCOMPtr<nsIPrincipal> mOriginPrincipal;
 
   NS_INLINE_DECL_REFCOUNTING(URLValue)
 
 private:
   mutable bool mURIResolved;
 
-  URLValue(const URLValue& aOther) MOZ_DELETE;
-  URLValue& operator=(const URLValue& aOther) MOZ_DELETE;
+  URLValue(const URLValue& aOther) = delete;
+  URLValue& operator=(const URLValue& aOther) = delete;
 };
 
 struct ImageValue : public URLValue {
   // Not making the constructor and destructor inline because that would
   // force us to include imgIRequest.h, which leads to REQUIRES hell, since
   // this header is included all over.
   // aString must not be null.
   ImageValue(nsIURI* aURI, nsStringBuffer* aString, nsIURI* aReferrer,
@@ -190,19 +190,19 @@ struct GridTemplateAreasValue MOZ_FINAL 
 
 private:
   // Private destructor to make sure this isn't used as a stack variable
   // or member variable.
   ~GridTemplateAreasValue()
   {
   }
 
-  GridTemplateAreasValue(const GridTemplateAreasValue& aOther) MOZ_DELETE;
+  GridTemplateAreasValue(const GridTemplateAreasValue& aOther) = delete;
   GridTemplateAreasValue&
-  operator=(const GridTemplateAreasValue& aOther) MOZ_DELETE;
+  operator=(const GridTemplateAreasValue& aOther) = delete;
 };
 
 class FontFamilyListRefCnt MOZ_FINAL : public FontFamilyList {
 public:
     FontFamilyListRefCnt()
         : FontFamilyList()
     {
         MOZ_COUNT_CTOR(FontFamilyListRefCnt);
@@ -869,18 +869,18 @@ private:
     }
   }
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
 #undef CSSVALUE_LIST_FOR_EXTRA_VALUES
 
 private:
-  Array(const Array& aOther) MOZ_DELETE;
-  Array& operator=(const Array& aOther) MOZ_DELETE;
+  Array(const Array& aOther) = delete;
+  Array& operator=(const Array& aOther) = delete;
 };
 
 // Prefer nsCSSValue::Array for lists of fixed size.
 struct nsCSSValueList {
   nsCSSValueList() : mNext(nullptr) { MOZ_COUNT_CTOR(nsCSSValueList); }
   ~nsCSSValueList();
 
   nsCSSValueList* Clone() const;  // makes a deep copy. Infallible.
@@ -901,18 +901,18 @@ private:
     : mValue(aCopy.mValue), mNext(nullptr)
   {
     MOZ_COUNT_CTOR(nsCSSValueList);
   }
 
   // We don't want operator== or operator!= because they wouldn't be
   // null-safe, which is generally what we need.  Use |Equal| method
   // above instead.
-  bool operator==(nsCSSValueList const& aOther) const MOZ_DELETE;
-  bool operator!=(const nsCSSValueList& aOther) const MOZ_DELETE;
+  bool operator==(nsCSSValueList const& aOther) const = delete;
+  bool operator!=(const nsCSSValueList& aOther) const = delete;
 };
 
 // nsCSSValueList_heap differs from nsCSSValueList only in being
 // refcounted.  It should not be necessary to use this class directly;
 // it's an implementation detail of nsCSSValue.
 struct nsCSSValueList_heap MOZ_FINAL : public nsCSSValueList {
   NS_INLINE_DECL_REFCOUNTING(nsCSSValueList_heap)
 
@@ -1300,18 +1300,18 @@ private:
     : mXValue(aCopy.mXValue), mYValue(aCopy.mYValue), mNext(nullptr)
   {
     MOZ_COUNT_CTOR(nsCSSValuePairList);
   }
 
   // We don't want operator== or operator!= because they wouldn't be
   // null-safe, which is generally what we need.  Use |Equal| method
   // above instead.
-  bool operator==(const nsCSSValuePairList& aOther) const MOZ_DELETE;
-  bool operator!=(const nsCSSValuePairList& aOther) const MOZ_DELETE;
+  bool operator==(const nsCSSValuePairList& aOther) const = delete;
+  bool operator!=(const nsCSSValuePairList& aOther) const = delete;
 };
 
 // nsCSSValuePairList_heap differs from nsCSSValuePairList only in being
 // refcounted.  It should not be necessary to use this class directly;
 // it's an implementation detail of nsCSSValue.
 struct nsCSSValuePairList_heap MOZ_FINAL : public nsCSSValuePairList {
   NS_INLINE_DECL_REFCOUNTING(nsCSSValuePairList_heap)
 
@@ -1469,18 +1469,18 @@ public:
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
 private:
   // Private destructor, to discourage deletion outside of Release():
   ~nsCSSValueGradient()
   {
   }
 
-  nsCSSValueGradient(const nsCSSValueGradient& aOther) MOZ_DELETE;
-  nsCSSValueGradient& operator=(const nsCSSValueGradient& aOther) MOZ_DELETE;
+  nsCSSValueGradient(const nsCSSValueGradient& aOther) = delete;
+  nsCSSValueGradient& operator=(const nsCSSValueGradient& aOther) = delete;
 };
 
 struct nsCSSValueTokenStream MOZ_FINAL {
   nsCSSValueTokenStream();
 
 private:
   // Private destructor, to discourage deletion outside of Release():
   ~nsCSSValueTokenStream();
@@ -1548,18 +1548,18 @@ public:
   // the ImageValue would only exist for the duration of
   // nsRuleNode::WalkRuleTree, in the AutoCSSValueArray.  So instead when
   // we re-parse a token stream and get an ImageValue, we record it in this
   // table so that the Declaration can be the object that keeps holding
   // a reference to it.
   nsTHashtable<nsRefPtrHashKey<mozilla::css::ImageValue> > mImageValues;
 
 private:
-  nsCSSValueTokenStream(const nsCSSValueTokenStream& aOther) MOZ_DELETE;
-  nsCSSValueTokenStream& operator=(const nsCSSValueTokenStream& aOther) MOZ_DELETE;
+  nsCSSValueTokenStream(const nsCSSValueTokenStream& aOther) = delete;
+  nsCSSValueTokenStream& operator=(const nsCSSValueTokenStream& aOther) = delete;
 };
 
 class nsCSSValueFloatColor MOZ_FINAL {
 public:
   nsCSSValueFloatColor(float aComponent1, float aComponent2, float aComponent3,
                        float aAlpha)
     : mComponent1(aComponent1)
     , mComponent2(aComponent2)
@@ -1590,19 +1590,19 @@ public:
 
 private:
   // FIXME: We should not be clamping specified RGB color components.
   float mComponent1;  // 0..1 for RGB, 0..360 for HSL
   float mComponent2;  // 0..1
   float mComponent3;  // 0..1
   float mAlpha;       // 0..1
 
-  nsCSSValueFloatColor(const nsCSSValueFloatColor& aOther) MOZ_DELETE;
+  nsCSSValueFloatColor(const nsCSSValueFloatColor& aOther) = delete;
   nsCSSValueFloatColor& operator=(const nsCSSValueFloatColor& aOther)
-                                                                   MOZ_DELETE;
+                                                                   = delete;
 };
 
 struct nsCSSCornerSizes {
   nsCSSCornerSizes(void);
   nsCSSCornerSizes(const nsCSSCornerSizes& aCopy);
   ~nsCSSCornerSizes();
 
   // argument is a "full corner" constant from nsStyleConsts.h
--- a/layout/style/nsHTMLCSSStyleSheet.h
+++ b/layout/style/nsHTMLCSSStyleSheet.h
@@ -58,16 +58,16 @@ public:
 
   void CacheStyleAttr(const nsAString& aSerialized, MiscContainer* aValue);
   void EvictStyleAttr(const nsAString& aSerialized, MiscContainer* aValue);
   MiscContainer* LookupStyleAttr(const nsAString& aSerialized);
 
 private: 
   ~nsHTMLCSSStyleSheet();
 
-  nsHTMLCSSStyleSheet(const nsHTMLCSSStyleSheet& aCopy) MOZ_DELETE;
-  nsHTMLCSSStyleSheet& operator=(const nsHTMLCSSStyleSheet& aCopy) MOZ_DELETE;
+  nsHTMLCSSStyleSheet(const nsHTMLCSSStyleSheet& aCopy) = delete;
+  nsHTMLCSSStyleSheet& operator=(const nsHTMLCSSStyleSheet& aCopy) = delete;
 
 protected:
   nsDataHashtable<nsStringHashKey, MiscContainer*> mCachedStyleAttrs;
 };
 
 #endif /* !defined(nsHTMLCSSStyleSheet_h_) */
--- a/layout/style/nsHTMLStyleSheet.h
+++ b/layout/style/nsHTMLStyleSheet.h
@@ -61,18 +61,18 @@ public:
   // Mapped Attribute management methods
   already_AddRefed<nsMappedAttributes>
     UniqueMappedAttributes(nsMappedAttributes* aMapped);
   void DropMappedAttributes(nsMappedAttributes* aMapped);
 
   nsIStyleRule* LangRuleFor(const nsString& aLanguage);
 
 private: 
-  nsHTMLStyleSheet(const nsHTMLStyleSheet& aCopy) MOZ_DELETE;
-  nsHTMLStyleSheet& operator=(const nsHTMLStyleSheet& aCopy) MOZ_DELETE;
+  nsHTMLStyleSheet(const nsHTMLStyleSheet& aCopy) = delete;
+  nsHTMLStyleSheet& operator=(const nsHTMLStyleSheet& aCopy) = delete;
 
   ~nsHTMLStyleSheet();
 
   class HTMLColorRule;
   friend class HTMLColorRule;
   class HTMLColorRule MOZ_FINAL : public nsIStyleRule {
   private:
     ~HTMLColorRule() {}
--- a/layout/style/nsStyleCoord.h
+++ b/layout/style/nsStyleCoord.h
@@ -72,19 +72,19 @@ public:
 
   // Reference counted calc() value.  This is the type that is used to store
   // the calc() value in nsStyleCoord.
   struct Calc MOZ_FINAL : public CalcValue {
     NS_INLINE_DECL_REFCOUNTING(Calc)
     Calc() {}
 
   private:
-    Calc(const Calc&) MOZ_DELETE;
+    Calc(const Calc&) = delete;
     ~Calc() {}
-    Calc& operator=(const Calc&) MOZ_DELETE;
+    Calc& operator=(const Calc&) = delete;
   };
 
   explicit nsStyleCoord(nsStyleUnit aUnit = eStyleUnit_Null);
   enum CoordConstructorType { CoordConstructor };
   inline nsStyleCoord(nscoord aValue, CoordConstructorType);
   nsStyleCoord(int32_t aValue, nsStyleUnit aUnit);
   nsStyleCoord(float aValue, nsStyleUnit aUnit);
   inline nsStyleCoord(const nsStyleCoord& aCopy);
--- a/layout/style/nsStyleSet.h
+++ b/layout/style/nsStyleSet.h
@@ -366,18 +366,18 @@ class nsStyleSet
     --mUnusedRuleNodeCount;
   }
 
   mozilla::CSSStyleSheet::EnsureUniqueInnerResult EnsureUniqueInnerOnCSSSheets();
 
   nsIStyleRule* InitialStyleRule();
 
  private:
-  nsStyleSet(const nsStyleSet& aCopy) MOZ_DELETE;
-  nsStyleSet& operator=(const nsStyleSet& aCopy) MOZ_DELETE;
+  nsStyleSet(const nsStyleSet& aCopy) = delete;
+  nsStyleSet& operator=(const nsStyleSet& aCopy) = delete;
 
   // Run mark-and-sweep GC on mRuleTree and mOldRuleTrees, based on mRoots.
   void GCRuleTrees();
 
   // Update the rule processor list after a change to the style sheet list.
   nsresult GatherRuleProcessors(sheetType aType);
 
   void AddImportantRules(nsRuleNode* aCurrLevelNode,
--- a/layout/style/nsStyleStruct.h
+++ b/layout/style/nsStyleStruct.h
@@ -137,18 +137,18 @@ public:
 };
 
 struct nsStyleGradientStop {
   nsStyleCoord mLocation; // percent, coord, calc, none
   nscolor mColor;
   bool mIsInterpolationHint;
 
   // Use ==/!= on nsStyleGradient instead of on the gradient stop.
-  bool operator==(const nsStyleGradientStop&) const MOZ_DELETE;
-  bool operator!=(const nsStyleGradientStop&) const MOZ_DELETE;
+  bool operator==(const nsStyleGradientStop&) const = delete;
+  bool operator!=(const nsStyleGradientStop&) const = delete;
 };
 
 class nsStyleGradient MOZ_FINAL {
 public:
   nsStyleGradient();
   uint8_t mShape;  // NS_STYLE_GRADIENT_SHAPE_*
   uint8_t mSize;   // NS_STYLE_GRADIENT_SIZE_*;
                    // not used (must be FARTHEST_CORNER) for linear shape
@@ -175,18 +175,18 @@ public:
   uint32_t Hash(PLDHashNumber aHash);
 
   NS_INLINE_DECL_REFCOUNTING(nsStyleGradient)
 
 private:
   // Private destructor, to discourage deletion outside of Release():
   ~nsStyleGradient() {}
 
-  nsStyleGradient(const nsStyleGradient& aOther) MOZ_DELETE;
-  nsStyleGradient& operator=(const nsStyleGradient& aOther) MOZ_DELETE;
+  nsStyleGradient(const nsStyleGradient& aOther) = delete;
+  nsStyleGradient& operator=(const nsStyleGradient& aOther) = delete;
 };
 
 enum nsStyleImageType {
   eStyleImageType_Null,
   eStyleImageType_Image,
   eStyleImageType_Gradient,
   eStyleImageType_Element
 };
@@ -1036,17 +1036,17 @@ protected:
   nsMargin      mBorder;
 
   uint8_t       mBorderStyle[4];  // [reset] See nsStyleConsts.h
   nscolor       mBorderColor[4];  // [reset] the colors to use for a simple
                                   // border.  not used for -moz-border-colors
 private:
   nscoord       mTwipsPerPixel;
 
-  nsStyleBorder& operator=(const nsStyleBorder& aOther) MOZ_DELETE;
+  nsStyleBorder& operator=(const nsStyleBorder& aOther) = delete;
 };
 
 
 struct nsStyleOutline {
   explicit nsStyleOutline(nsPresContext* aPresContext);
   nsStyleOutline(const nsStyleOutline& aOutline);
   ~nsStyleOutline(void) {
     MOZ_COUNT_DTOR(nsStyleOutline);
@@ -1198,17 +1198,17 @@ struct nsStyleList {
                      CounterStyleManager()->BuildCounterStyle(aType));
   }
 
   uint8_t   mListStylePosition;         // [inherited]
 private:
   nsString  mListStyleType;             // [inherited]
   nsRefPtr<mozilla::CounterStyle> mCounterStyle; // [inherited]
   nsRefPtr<imgRequestProxy> mListStyleImage; // [inherited]
-  nsStyleList& operator=(const nsStyleList& aOther) MOZ_DELETE;
+  nsStyleList& operator=(const nsStyleList& aOther) = delete;
 public:
   nsRect        mImageRegion;           // [inherited] the rect to use within an image
 };
 
 // Computed value of the grid-template-columns or grid-columns-rows property
 // (but *not* grid-template-areas.)
 // http://dev.w3.org/csswg/css-grid/#track-sizing
 //
@@ -2969,17 +2969,17 @@ struct nsStyleClipPath
   void SetBasicShape(nsStyleBasicShape* mBasicShape,
                      uint8_t aSizingBox = NS_STYLE_CLIP_SHAPE_SIZING_NOBOX);
 
   uint8_t GetSizingBox() const { return mSizingBox; }
   void SetSizingBox(uint8_t aSizingBox);
 
 private:
   void ReleaseRef();
-  void* operator new(size_t) MOZ_DELETE;
+  void* operator new(size_t) = delete;
 
   int32_t mType; // see NS_STYLE_CLIP_PATH_* constants in nsStyleConsts.h
   union {
     nsStyleBasicShape* mBasicShape;
     nsIURI* mURL;
   };
   uint8_t mSizingBox; // see NS_STYLE_CLIP_SHAPE_SIZING_* constants in nsStyleConsts.h
 };
--- a/media/mtransport/m_cpp_utils.h
+++ b/media/mtransport/m_cpp_utils.h
@@ -9,20 +9,20 @@
 #ifndef m_cpp_utils_h__
 #define m_cpp_utils_h__
 
 #include "mozilla/Attributes.h"
 
 namespace mozilla {
 
 #define DISALLOW_ASSIGNMENT(T) \
-  void operator=(const T& other) MOZ_DELETE
+  void operator=(const T& other) = delete
 
 #define DISALLOW_COPY(T) \
-  T(const T& other) MOZ_DELETE
+  T(const T& other) = delete
 
 
 #define DISALLOW_COPY_ASSIGN(T) \
   DISALLOW_COPY(T); \
   DISALLOW_ASSIGNMENT(T)
 
 }  // close namespace
 #endif
--- a/media/webrtc/signaling/src/common/NullTransport.h
+++ b/media/webrtc/signaling/src/common/NullTransport.h
@@ -30,15 +30,15 @@ public:
     return len;
   }
 
   NullTransport() {}
 
   virtual ~NullTransport() {}
 
 private:
-  NullTransport(const NullTransport& other) MOZ_DELETE;
-  void operator=(const NullTransport& other) MOZ_DELETE;
+  NullTransport(const NullTransport& other) = delete;
+  void operator=(const NullTransport& other) = delete;
 };
 
 } // end namespace
 
 #endif
--- a/media/webrtc/signaling/src/media-conduit/AudioConduit.h
+++ b/media/webrtc/signaling/src/media-conduit/AudioConduit.h
@@ -207,18 +207,18 @@ public:
                              uint64_t* bytesReceived,
                              uint32_t *cumulativeLost,
                              int32_t* rttMs) MOZ_OVERRIDE;
   bool GetRTCPSenderReport(DOMHighResTimeStamp* timestamp,
                            unsigned int* packetsSent,
                            uint64_t* bytesSent) MOZ_OVERRIDE;
 
 private:
-  WebrtcAudioConduit(const WebrtcAudioConduit& other) MOZ_DELETE;
-  void operator=(const WebrtcAudioConduit& other) MOZ_DELETE;
+  WebrtcAudioConduit(const WebrtcAudioConduit& other) = delete;
+  void operator=(const WebrtcAudioConduit& other) = delete;
 
   //Local database of currently applied receive codecs
   typedef std::vector<AudioCodecConfig* > RecvCodecList;
 
   //Function to convert between WebRTC and Conduit codec structures
   bool CodecConfigToWebRTCCodec(const AudioCodecConfig* codecInfo,
                                 webrtc::CodecInst& cinst);
 
--- a/media/webrtc/signaling/src/media-conduit/VideoConduit.h
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.h
@@ -256,18 +256,18 @@ public:
                              int32_t* rttMs) MOZ_OVERRIDE;
   bool GetRTCPSenderReport(DOMHighResTimeStamp* timestamp,
                            unsigned int* packetsSent,
                            uint64_t* bytesSent) MOZ_OVERRIDE;
   uint64_t MozVideoLatencyAvg();
 
 private:
 
-  WebrtcVideoConduit(const WebrtcVideoConduit& other) MOZ_DELETE;
-  void operator=(const WebrtcVideoConduit& other) MOZ_DELETE;
+  WebrtcVideoConduit(const WebrtcVideoConduit& other) = delete;
+  void operator=(const WebrtcVideoConduit& other) = delete;
 
   //Local database of currently applied receive codecs
   typedef std::vector<VideoCodecConfig* > RecvCodecList;
 
   //Function to convert between WebRTC and Conduit codec structures
   void CodecConfigToWebRTCCodec(const VideoCodecConfig* codecInfo,
                                 webrtc::VideoCodec& cinst);
 
--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.h
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.h
@@ -57,18 +57,18 @@ class PeerConnectionCtx {
 #endif
 
  private:
   // We could make these available only via accessors but it's too much trouble.
   std::map<const std::string, PeerConnectionImpl *> mPeerConnections;
 
   PeerConnectionCtx() :  mGMPReady(false) {}
   // This is a singleton, so don't copy construct it, etc.
-  PeerConnectionCtx(const PeerConnectionCtx& other) MOZ_DELETE;
-  void operator=(const PeerConnectionCtx& other) MOZ_DELETE;
+  PeerConnectionCtx(const PeerConnectionCtx& other) = delete;
+  void operator=(const PeerConnectionCtx& other) = delete;
   virtual ~PeerConnectionCtx();
 
   nsresult Initialize();
   nsresult Cleanup();
 
   void initGMP();
 
   static void
--- a/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.h
+++ b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.h
@@ -34,19 +34,19 @@ public:
   static int32_t DebugLevel(const GlobalObject& aGlobal);
 
   static void SetAecDebug(const GlobalObject& aGlobal, bool aEnable);
   static bool AecDebug(const GlobalObject& aGlobal);
 
   static void StoreLongTermICEStatistics(PeerConnectionImpl& aPc);
 
 private:
-  WebrtcGlobalInformation() MOZ_DELETE;
-  WebrtcGlobalInformation(const WebrtcGlobalInformation& aOrig) MOZ_DELETE;
+  WebrtcGlobalInformation() = delete;
+  WebrtcGlobalInformation(const WebrtcGlobalInformation& aOrig) = delete;
   WebrtcGlobalInformation& operator=(
-    const WebrtcGlobalInformation& aRhs) MOZ_DELETE;
+    const WebrtcGlobalInformation& aRhs) = delete;
 };
 
 } // namespace dom
 } // namespace mozilla
 
 #endif  // _WEBRTC_GLOBAL_INFORMATION_H_
 
--- a/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.h
+++ b/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.h
@@ -120,15 +120,15 @@ private:
   void WarnAboutMisplacedAttribute(SdpAttribute::AttributeType type,
                                    uint32_t lineNumber,
                                    SdpErrorHolder& errorHolder);
 
   const SipccSdpAttributeList* mSessionLevel;
 
   SdpAttribute* mAttributes[kNumAttributeTypes];
 
-  SipccSdpAttributeList(const SipccSdpAttributeList& orig) MOZ_DELETE;
-  SipccSdpAttributeList& operator=(const SipccSdpAttributeList& rhs) MOZ_DELETE;
+  SipccSdpAttributeList(const SipccSdpAttributeList& orig) = delete;
+  SipccSdpAttributeList& operator=(const SipccSdpAttributeList& rhs) = delete;
 };
 
 } // namespace mozilla
 
 #endif
--- a/memory/mozalloc/VolatileBuffer.h
+++ b/memory/mozalloc/VolatileBuffer.h
@@ -146,14 +146,14 @@ public:
   {
     MOZ_ASSERT(this != &aOther, "Self-moves are prohibited");
     Set(aOther.mVBuf);
     aOther.Set(nullptr);
     return *this;
   }
 
 private:
-  VolatileBufferPtr(VolatileBufferPtr const& vbufptr) MOZ_DELETE;
+  VolatileBufferPtr(VolatileBufferPtr const& vbufptr) = delete;
 };
 
 }; /* namespace mozilla */
 
 #endif /* mozalloc_VolatileBuffer_h */
--- a/mfbt/AlreadyAddRefed.h
+++ b/mfbt/AlreadyAddRefed.h
@@ -63,17 +63,17 @@ struct already_AddRefed
   // The return and argument types here are arbitrarily selected so no
   // corresponding member function exists.
   typedef void (already_AddRefed::* MatchNullptr)(double, float);
   MOZ_IMPLICIT already_AddRefed(MatchNullptr aRawPtr) : mRawPtr(nullptr) {}
 
   explicit already_AddRefed(T* aRawPtr) : mRawPtr(aRawPtr) {}
 
   // Disallowed. Use move semantics instead.
-  already_AddRefed(const already_AddRefed<T>& aOther) MOZ_DELETE;
+  already_AddRefed(const already_AddRefed<T>& aOther) = delete;
 
   already_AddRefed(already_AddRefed<T>&& aOther) : mRawPtr(aOther.take()) {}
 
   ~already_AddRefed() { MOZ_ASSERT(!mRawPtr); }
 
   // Specialize the unused operator<< for already_AddRefed, to allow
   // nsCOMPtr<nsIFoo> foo;
   // unused << foo.forget();
--- a/mfbt/Atomics.h
+++ b/mfbt/Atomics.h
@@ -957,17 +957,17 @@ public:
    */
   bool compareExchange(T aOldValue, T aNewValue)
   {
     return Intrinsics::compareExchange(mValue, aOldValue, aNewValue);
   }
 
 private:
   template<MemoryOrdering AnyOrder>
-  AtomicBase(const AtomicBase<T, AnyOrder>& aCopy) MOZ_DELETE;
+  AtomicBase(const AtomicBase<T, AnyOrder>& aCopy) = delete;
 };
 
 template<typename T, MemoryOrdering Order>
 class AtomicBaseIncDec : public AtomicBase<T, Order>
 {
   typedef typename detail::AtomicBase<T, Order> Base;
 
 public:
@@ -979,17 +979,17 @@ public:
   operator T() const { return Base::Intrinsics::load(Base::mValue); }
   T operator++(int) { return Base::Intrinsics::inc(Base::mValue); }
   T operator--(int) { return Base::Intrinsics::dec(Base::mValue); }
   T operator++() { return Base::Intrinsics::inc(Base::mValue) + 1; }
   T operator--() { return Base::Intrinsics::dec(Base::mValue) - 1; }
 
 private:
   template<MemoryOrdering AnyOrder>
-  AtomicBaseIncDec(const AtomicBaseIncDec<T, AnyOrder>& aCopy) MOZ_DELETE;
+  AtomicBaseIncDec(const AtomicBaseIncDec<T, AnyOrder>& aCopy) = delete;
 };
 
 } // namespace detail
 
 /**
  * A wrapper for a type that enforces that all memory accesses are atomic.
  *
  * In general, where a variable |T foo| exists, |Atomic<T> foo| can be used in
@@ -1053,17 +1053,17 @@ public:
   }
 
   T operator&=(T aVal)
   {
     return Base::Intrinsics::and_(Base::mValue, aVal) & aVal;
   }
 
 private:
-  Atomic(Atomic<T, Order>& aOther) MOZ_DELETE;
+  Atomic(Atomic<T, Order>& aOther) = delete;
 };
 
 /**
  * Atomic<T> implementation for pointer types.
  *
  * An atomic compare-and-swap primitive for pointer variables is provided, as
  * are atomic increment and decement operators.  Also provided are the compound
  * assignment operators for addition and subtraction. Atomic swap (via
@@ -1086,17 +1086,17 @@ public:
   }
 
   T* operator-=(ptrdiff_t aDelta)
   {
     return Base::Intrinsics::sub(Base::mValue, aDelta) - aDelta;
   }
 
 private:
-  Atomic(Atomic<T*, Order>& aOther) MOZ_DELETE;
+  Atomic(Atomic<T*, Order>& aOther) = delete;
 };
 
 /**
  * Atomic<T> implementation for enum types.
  *
  * The atomic store and load operations and the atomic swap method is provided.
  */
 template<typename T, MemoryOrdering Order>
@@ -1109,17 +1109,17 @@ public:
   MOZ_CONSTEXPR Atomic() : Base() {}
   explicit MOZ_CONSTEXPR Atomic(T aInit) : Base(aInit) {}
 
   operator T() const { return Base::Intrinsics::load(Base::mValue); }
 
   using Base::operator=;
 
 private:
-  Atomic(Atomic<T, Order>& aOther) MOZ_DELETE;
+  Atomic(Atomic<T, Order>& aOther) = delete;
 };
 
 /**
  * Atomic<T> implementation for boolean types.
  *
  * The atomic store and load operations and the atomic swap method is provided.
  *
  * Note:
@@ -1160,14 +1160,14 @@ public:
   }
 
   bool compareExchange(bool aOldValue, bool aNewValue)
   {
     return Base::compareExchange(aOldValue, aNewValue);
   }
 
 private:
-  Atomic(Atomic<bool, Order>& aOther) MOZ_DELETE;
+  Atomic(Atomic<bool, Order>& aOther) = delete;
 };
 
 } // namespace mozilla
 
 #endif /* mozilla_Atomics_h */
--- a/mfbt/CheckedInt.h
+++ b/mfbt/CheckedInt.h
@@ -663,21 +663,21 @@ public:
     return tmp;
   }
 
 private:
   /**
    * The !=, <, <=, >, >= operators are disabled:
    * see the comment on operator==.
    */
-  template<typename U> bool operator !=(U aOther) const MOZ_DELETE;
-  template<typename U> bool operator < (U aOther) const MOZ_DELETE;
-  template<typename U> bool operator <=(U aOther) const MOZ_DELETE;
-  template<typename U> bool operator > (U aOther) const MOZ_DELETE;
-  template<typename U> bool operator >=(U aOther) const MOZ_DELETE;
+  template<typename U> bool operator !=(U aOther) const = delete;
+  template<typename U> bool operator < (U aOther) const = delete;
+  template<typename U> bool operator <=(U aOther) const = delete;
+  template<typename U> bool operator > (U aOther) const = delete;
+  template<typename U> bool operator >=(U aOther) const = delete;
 };
 
 #define MOZ_CHECKEDINT_BASIC_BINARY_OPERATOR(NAME, OP)                        \
   template<typename T>                                                        \
   inline CheckedInt<T>                                                        \
   operator OP(const CheckedInt<T>& aLhs, const CheckedInt<T>& aRhs)           \
   {                                                                           \
     if (!detail::Is##NAME##Valid(aLhs.mValue, aRhs.mValue)) {                 \
--- a/mfbt/Endian.h
+++ b/mfbt/Endian.h
@@ -610,19 +610,19 @@ private:
    */
   template<typename T>
   static void write(void* aPtr, T aValue)
   {
     T tmp = maybeSwap<MOZ_NATIVE_ENDIANNESS, ThisEndian>(aValue);
     memcpy(aPtr, &tmp, sizeof(T));
   }
 
-  Endian() MOZ_DELETE;
-  Endian(const Endian& aTther) MOZ_DELETE;
-  void operator=(const Endian& aOther) MOZ_DELETE;
+  Endian() = delete;
+  Endian(const Endian& aTther) = delete;
+  void operator=(const Endian& aOther) = delete;
 };
 
 template<Endianness ThisEndian>
 class EndianReadWrite : public Endian<ThisEndian>
 {
 private:
   typedef Endian<ThisEndian> super;
 
--- a/mfbt/LinkedList.h
+++ b/mfbt/LinkedList.h
@@ -280,18 +280,18 @@ private:
 
     listElem->mNext = this;
     listElem->mPrev = this->mPrev;
     this->mPrev->mNext = listElem;
     this->mPrev = listElem;
   }
 
 private:
-  LinkedListElement& operator=(const LinkedListElement<T>& aOther) MOZ_DELETE;
-  LinkedListElement(const LinkedListElement<T>& aOther) MOZ_DELETE;
+  LinkedListElement& operator=(const LinkedListElement<T>& aOther) = delete;
+  LinkedListElement(const LinkedListElement<T>& aOther) = delete;
 };
 
 template<typename T>
 class LinkedList
 {
 private:
   LinkedListElement<T> sentinel;
 
@@ -470,17 +470,17 @@ private:
       if (elem == aValue) {
         return;
       }
     }
     MOZ_CRASH("element wasn't found in this list!");
 #endif
   }
 
-  LinkedList& operator=(const LinkedList<T>& aOther) MOZ_DELETE;
-  LinkedList(const LinkedList<T>& aOther) MOZ_DELETE;
+  LinkedList& operator=(const LinkedList<T>& aOther) = delete;
+  LinkedList(const LinkedList<T>& aOther) = delete;
 };
 
 } /* namespace mozilla */
 
 #endif /* __cplusplus */
 
 #endif /* mozilla_LinkedList_h */
--- a/mfbt/MathAlgorithms.h
+++ b/mfbt/MathAlgorithms.h
@@ -276,22 +276,22 @@ CountLeadingZeroes64(uint64_t aValue)
 inline uint_fast8_t
 CountTrailingZeroes64(uint64_t aValue)
 {
   return __builtin_ctzll(aValue);
 }
 
 #else
 #  error "Implement these!"
-inline uint_fast8_t CountLeadingZeroes32(uint32_t aValue) MOZ_DELETE;
-inline uint_fast8_t CountTrailingZeroes32(uint32_t aValue) MOZ_DELETE;
-inline uint_fast8_t CountPopulation32(uint32_t aValue) MOZ_DELETE;
-inline uint_fast8_t CountPopulation64(uint64_t aValue) MOZ_DELETE;
-inline uint_fast8_t CountLeadingZeroes64(uint64_t aValue) MOZ_DELETE;
-inline uint_fast8_t CountTrailingZeroes64(uint64_t aValue) MOZ_DELETE;
+inline uint_fast8_t CountLeadingZeroes32(uint32_t aValue) = delete;
+inline uint_fast8_t CountTrailingZeroes32(uint32_t aValue) = delete;
+inline uint_fast8_t CountPopulation32(uint32_t aValue) = delete;
+inline uint_fast8_t CountPopulation64(uint64_t aValue) = delete;
+inline uint_fast8_t CountLeadingZeroes64(uint64_t aValue) = delete;
+inline uint_fast8_t CountTrailingZeroes64(uint64_t aValue) = delete;
 #endif
 
 } // namespace detail
 
 /**
  * Compute the number of high-order zero bits in the NON-ZERO number |aValue|.
  * That is, looking at the bitwise representation of the number, with the
  * highest- valued bits at the start, return the number of zeroes before the
--- a/mfbt/MaybeOneOf.h
+++ b/mfbt/MaybeOneOf.h
@@ -114,18 +114,18 @@ public:
   void destroyIfConstructed()
   {
     if (!empty()) {
       destroy();
     }
   }
 
 private:
-  MaybeOneOf(const MaybeOneOf& aOther) MOZ_DELETE;
-  const MaybeOneOf& operator=(const MaybeOneOf& aOther) MOZ_DELETE;
+  MaybeOneOf(const MaybeOneOf& aOther) = delete;
+  const MaybeOneOf& operator=(const MaybeOneOf& aOther) = delete;
 };
 
 template <class T1, class T2>
 template <class Ignored>
 struct MaybeOneOf<T1, T2>::Type2State<T1, Ignored>
 {
   typedef MaybeOneOf<T1, T2> Enclosing;
   static const typename Enclosing::State result = Enclosing::SomeT1;
--- a/mfbt/NullPtr.h
+++ b/mfbt/NullPtr.h
@@ -50,17 +50,17 @@ namespace mozilla {
  *            typename EnableIf<IsNullPointer<N>::value, int>::Type dummy = 0)
  *   { }
  *
  *   // foo(T*) *exactly* and foo(decltype(nullptr)), nothing else
  *   void foo(T*) { }
  *   template<typename U>
  *   void foo(U,
  *            typename EnableIf<!IsNullPointer<U>::value, int>::Type dummy = 0)
- *   MOZ_DELETE;
+ *   = delete;
  *
  * The exact details of how set up the SFINAE bits vary on a case-by-case basis.
  * If you need help with this (and unless you've internalized way more sadmaking
  * nullptr-emulation knowledge than you should have, you do), feel free to poke
  * the person with blame on this comment with questions.   :-)
  *
  * Ideally this would be in TypeTraits.h, but C++11 omitted std::is_null_pointer
  * (fixed in C++1y), so in the interests of easing a switch to <type_traits>,
--- a/mfbt/Pair.h
+++ b/mfbt/Pair.h
@@ -164,17 +164,17 @@ public:
   using Base::first;
   /** The B instance. */
   using Base::second;
 
   /** Swap this pair with another pair. */
   void swap(Pair& aOther) { Base::swap(aOther); }
 
 private:
-  Pair(const Pair&) MOZ_DELETE;
+  Pair(const Pair&) = delete;
 };
 
 template<typename A, class B>
 void
 Swap(Pair<A, B>& aX, Pair<A, B>& aY)
 {
   aX.swap(aY);
 }
--- a/mfbt/PodOperations.h
+++ b/mfbt/PodOperations.h
@@ -50,19 +50,19 @@ PodZero(T* aT, size_t aNElem)
 /*
  * Arrays implicitly convert to pointers to their first element, which is
  * dangerous when combined with the above PodZero definitions.  Adding an
  * overload for arrays is ambiguous, so we need another identifier.  The
  * ambiguous overload is left to catch mistaken uses of PodZero; if you get a
  * compile error involving PodZero and array types, use PodArrayZero instead.
  */
 template<typename T, size_t N>
-static void PodZero(T (&aT)[N]) MOZ_DELETE;
+static void PodZero(T (&aT)[N]) = delete;
 template<typename T, size_t N>
-static void PodZero(T (&aT)[N], size_t aNElem) MOZ_DELETE;
+static void PodZero(T (&aT)[N], size_t aNElem) = delete;
 
 /** Set the contents of the array |aT| to zero. */
 template <class T, size_t N>
 static MOZ_ALWAYS_INLINE void
 PodArrayZero(T (&aT)[N])
 {
   memset(aT, 0, N * sizeof(T));
 }
--- a/mfbt/RangedPtr.h
+++ b/mfbt/RangedPtr.h
@@ -270,15 +270,15 @@ public:
 
   size_t operator-(const RangedPtr<T>& aOther) const
   {
     MOZ_ASSERT(mPtr >= aOther.mPtr);
     return PointerRangeSize(aOther.mPtr, mPtr);
   }
 
 private:
-  RangedPtr() MOZ_DELETE;
-  T* operator&() MOZ_DELETE;
+  RangedPtr() = delete;
+  T* operator&() = delete;
 };
 
 } /* namespace mozilla */
 
 #endif /* mozilla_RangedPtr_h */
--- a/mfbt/ReentrancyGuard.h
+++ b/mfbt/ReentrancyGuard.h
@@ -43,15 +43,15 @@ public:
   ~ReentrancyGuard()
   {
 #ifdef DEBUG
     mEntered = false;
 #endif
   }
 
 private:
-  ReentrancyGuard(const ReentrancyGuard&) MOZ_DELETE;
-  void operator=(const ReentrancyGuard&) MOZ_DELETE;
+  ReentrancyGuard(const ReentrancyGuard&) = delete;
+  void operator=(const ReentrancyGuard&) = delete;
 };
 
 } // namespace mozilla
 
 #endif /* mozilla_ReentrancyGuard_h */
--- a/mfbt/RefPtr.h
+++ b/mfbt/RefPtr.h
@@ -335,18 +335,18 @@ public:
     return tmp;
   }
 
 private:
   TemporaryRef(T* aVal, const DontRef&) : mPtr(aVal) {}
 
   mutable T* MOZ_OWNING_REF mPtr;
 
-  TemporaryRef() MOZ_DELETE;
-  void operator=(const TemporaryRef&) MOZ_DELETE;
+  TemporaryRef() = delete;
+  void operator=(const TemporaryRef&) = delete;
 };
 
 /**
  * OutParamRef is a wrapper that tracks a refcounted pointer passed as
  * an outparam argument to a function.  OutParamRef implements COM T**
  * outparam semantics: this requires the callee to AddRef() the T*
  * returned through the T** outparam on behalf of the caller.  This
  * means the caller (through OutParamRef) must Release() the old
@@ -373,18 +373,18 @@ public:
   operator T**() { return &mTmp; }
 
 private:
   explicit OutParamRef(RefPtr<T>& p) : mRefPtr(p), mTmp(p.get()) {}
 
   RefPtr<T>& mRefPtr;
   T* mTmp;
 
-  OutParamRef() MOZ_DELETE;
-  OutParamRef& operator=(const OutParamRef&) MOZ_DELETE;
+  OutParamRef() = delete;
+  OutParamRef& operator=(const OutParamRef&) = delete;
 };
 
 /**
  * byRef cooperates with OutParamRef to implement COM outparam semantics.
  */
 template<typename T>
 OutParamRef<T>
 byRef(RefPtr<T>& aPtr)
--- a/mfbt/Scoped.h
+++ b/mfbt/Scoped.h
@@ -165,18 +165,18 @@ public:
   {
     MOZ_ASSERT(&aRhs != this, "self-move-assignment not allowed");
     this->~Scoped();
     new(this) Scoped(Move(aRhs));
     return *this;
   }
 
 private:
-  explicit Scoped(const Scoped& aValue) MOZ_DELETE;
-  Scoped& operator=(const Scoped& aValue) MOZ_DELETE;
+  explicit Scoped(const Scoped& aValue) = delete;
+  Scoped& operator=(const Scoped& aValue) = delete;
 
 private:
   Resource mValue;
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
 /*
  * SCOPED_TEMPLATE defines a templated class derived from Scoped
@@ -211,18 +211,18 @@ struct name : public mozilla::Scoped<Tra
             MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT)                        \
   {}                                                                          \
   explicit name(name&& aRhs                                                   \
                 MOZ_GUARD_OBJECT_NOTIFIER_PARAM)                              \
     : Super(Move(aRhs)                                                        \
             MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT)                        \
   {}                                                                          \
 private:                                                                      \
-  explicit name(name&) MOZ_DELETE;                                            \
-  name& operator=(name&) MOZ_DELETE;                                          \
+  explicit name(name&) = delete;                                              \
+  name& operator=(name&) = delete;                                            \
 };
 
 /*
  * ScopedFreePtr is a RAII wrapper for pointers that need to be free()d.
  *
  *   struct S { ... };
  *   ScopedFreePtr<S> foo = malloc(sizeof(S));
  *   ScopedFreePtr<char> bar = strdup(str);
--- a/mfbt/SplayTree.h
+++ b/mfbt/SplayTree.h
@@ -287,15 +287,15 @@ private:
     }
     if (aNode->mRight) {
       MOZ_RELEASE_ASSERT(aNode->mRight->mParent == aNode);
       return checkCoherency(aNode->mRight, aNode);
     }
     return aNode;
   }
 
-  SplayTree(const SplayTree&) MOZ_DELETE;
-  void operator=(const SplayTree&) MOZ_DELETE;
+  SplayTree(const SplayTree&) = delete;
+  void operator=(const SplayTree&) = delete;
 };
 
 }  /* namespace mozilla */
 
 #endif /* mozilla_SplayTree_h */
--- a/mfbt/TypedEnum.h
+++ b/mfbt/TypedEnum.h
@@ -166,69 +166,69 @@
        MOZ_CONSTEXPR operator Enum() const { return mEnum; } \
        explicit MOZ_CONSTEXPR Name(const mozilla::CastableTypedEnumResult<Name>& aOther) \
          : mEnum(aOther.get()) \
        {} \
      private: \
        Enum mEnum; \
      };
 #  define MOZ_FINISH_NESTED_ENUM_CLASS(Name) \
-     inline int operator+(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator+(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int operator-(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator-(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int operator*(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator*(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int operator/(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator/(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int operator%(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator%(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int operator+(const Name::Enum&) MOZ_DELETE; \
-     inline int operator-(const Name::Enum&) MOZ_DELETE; \
-     inline int& operator++(Name::Enum&) MOZ_DELETE; \
-     inline int operator++(Name::Enum&, int) MOZ_DELETE; \
-     inline int& operator--(Name::Enum&) MOZ_DELETE; \
-     inline int operator--(Name::Enum&, int) MOZ_DELETE; \
-     inline bool operator==(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline bool operator==(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline bool operator!=(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline bool operator!=(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline bool operator>(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline bool operator>(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline bool operator<(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline bool operator<(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline bool operator>=(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline bool operator>=(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline bool operator<=(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline bool operator<=(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline bool operator!(const Name::Enum&) MOZ_DELETE; \
-     inline bool operator&&(const bool&, const Name::Enum&) MOZ_DELETE; \
-     inline bool operator&&(const Name::Enum&, const bool&) MOZ_DELETE; \
-     inline bool operator||(const bool&, const Name::Enum&) MOZ_DELETE; \
-     inline bool operator||(const Name::Enum&, const bool&) MOZ_DELETE; \
-     inline int operator&(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator&(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int operator|(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator|(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int operator^(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator^(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int operator<<(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator<<(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int operator>>(const int&, const Name::Enum&) MOZ_DELETE; \
-     inline int operator>>(const Name::Enum&, const int&) MOZ_DELETE; \
-     inline int& operator+=(int&, const Name::Enum&) MOZ_DELETE; \
-     inline int& operator-=(int&, const Name::Enum&) MOZ_DELETE; \
-     inline int& operator*=(int&, const Name::Enum&) MOZ_DELETE; \
-     inline int& operator/=(int&, const Name::Enum&) MOZ_DELETE; \
-     inline int& operator%=(int&, const Name::Enum&) MOZ_DELETE; \
-     inline int& operator&=(int&, const Name::Enum&) MOZ_DELETE; \
-     inline int& operator|=(int&, const Name::Enum&) MOZ_DELETE; \
-     inline int& operator^=(int&, const Name::Enum&) MOZ_DELETE; \
-     inline int& operator<<=(int&, const Name::Enum&) MOZ_DELETE; \
-     inline int& operator>>=(int&, const Name::Enum&) MOZ_DELETE;
+     inline int operator+(const int&, const Name::Enum&) = delete; \
+     inline int operator+(const Name::Enum&, const int&) = delete; \
+     inline int operator-(const int&, const Name::Enum&) = delete; \
+     inline int operator-(const Name::Enum&, const int&) = delete; \
+     inline int operator*(const int&, const Name::Enum&) = delete; \
+     inline int operator*(const Name::Enum&, const int&) = delete; \
+     inline int operator/(const int&, const Name::Enum&) = delete; \
+     inline int operator/(const Name::Enum&, const int&) = delete; \
+     inline int operator%(const int&, const Name::Enum&) = delete; \
+     inline int operator%(const Name::Enum&, const int&) = delete; \
+     inline int operator+(const Name::Enum&) = delete; \
+     inline int operator-(const Name::Enum&) = delete; \
+     inline int& operator++(Name::Enum&) = delete; \
+     inline int operator++(Name::Enum&, int) = delete; \
+     inline int& operator--(Name::Enum&) = delete; \
+     inline int operator--(Name::Enum&, int) = delete; \
+     inline bool operator==(const int&, const Name::Enum&) = delete; \
+     inline bool operator==(const Name::Enum&, const int&) = delete; \
+     inline bool operator!=(const int&, const Name::Enum&) = delete; \
+     inline bool operator!=(const Name::Enum&, const int&) = delete; \
+     inline bool operator>(const int&, const Name::Enum&) = delete; \
+     inline bool operator>(const Name::Enum&, const int&) = delete; \
+     inline bool operator<(const int&, const Name::Enum&) = delete; \
+     inline bool operator<(const Name::Enum&, const int&) = delete; \
+     inline bool operator>=(const int&, const Name::Enum&) = delete; \
+     inline bool operator>=(const Name::Enum&, const int&) = delete; \
+     inline bool operator<=(const int&, const Name::Enum&) = delete; \
+     inline bool operator<=(const Name::Enum&, const int&) = delete; \
+     inline bool operator!(const Name::Enum&) = delete; \
+     inline bool operator&&(const bool&, const Name::Enum&) = delete; \
+     inline bool operator&&(const Name::Enum&, const bool&) = delete; \
+     inline bool operator||(const bool&, const Name::Enum&) = delete; \
+     inline bool operator||(const Name::Enum&, const bool&) = delete; \
+     inline int operator&(const int&, const Name::Enum&) = delete; \
+     inline int operator&(const Name::Enum&, const int&) = delete; \
+     inline int operator|(const int&, const Name::Enum&) = delete; \
+     inline int operator|(const Name::Enum&, const int&) = delete; \
+     inline int operator^(const int&, const Name::Enum&) = delete; \
+     inline int operator^(const Name::Enum&, const int&) = delete; \
+     inline int operator<<(const int&, const Name::Enum&) = delete; \
+     inline int operator<<(const Name::Enum&, const int&) = delete; \
+     inline int operator>>(const int&, const Name::Enum&) = delete; \
+     inline int operator>>(const Name::Enum&, const int&) = delete; \
+     inline int& operator+=(int&, const Name::Enum&) = delete; \
+     inline int& operator-=(int&, const Name::Enum&) = delete; \
+     inline int& operator*=(int&, const Name::Enum&) = delete; \
+     inline int& operator/=(int&, const Name::Enum&) = delete; \
+     inline int& operator%=(int&, const Name::Enum&) = delete; \
+     inline int& operator&=(int&, const Name::Enum&) = delete; \
+     inline int& operator|=(int&, const Name::Enum&) = delete; \
+     inline int& operator^=(int&, const Name::Enum&) = delete; \
+     inline int& operator<<=(int&, const Name::Enum&) = delete; \
+     inline int& operator>>=(int&, const Name::Enum&) = delete;
 
   /*
    * MOZ_ENUM_CLASS_ENUM_TYPE allows using enum classes
    * as template parameter types. For that, we need integer types.
    * In the present case, the integer type is the Enum nested type.
    */
 #  define MOZ_ENUM_CLASS_ENUM_TYPE(Name) Name::Enum
   /*
--- a/mfbt/UniquePtr.h
+++ b/mfbt/UniquePtr.h
@@ -321,18 +321,18 @@ public:
   }
 
   void swap(UniquePtr& aOther)
   {
     mTuple.swap(aOther.mTuple);
   }
 
 private:
-  UniquePtr(const UniquePtr& aOther) MOZ_DELETE; // construct using Move()!
-  void operator=(const UniquePtr& aOther) MOZ_DELETE; // assign using Move()!
+  UniquePtr(const UniquePtr& aOther) = delete; // construct using Move()!
+  void operator=(const UniquePtr& aOther) = delete; // assign using Move()!
 };
 
 // In case you didn't read the comment by the main definition (you should!): the
 // UniquePtr<T[]> specialization exists to manage array pointers.  It deletes
 // such pointers using delete[], it will reject construction and modification
 // attempts using U* or U[].  Otherwise it works like the normal UniquePtr.
 template<typename T, class D>
 class UniquePtr<T[], D>
@@ -372,17 +372,17 @@ private:
   // fields and base classes of each element requiring destruction, and so on.
   // So forbid all overloads which would end up invoking delete[] on a pointer
   // of the wrong type.
   template<typename U>
   UniquePtr(U&& aU,
             typename EnableIf<IsPointer<U>::value &&
                               IsConvertible<U, Pointer>::value,
                               int>::Type aDummy = 0)
-  MOZ_DELETE;
+  = delete;
 
 public:
   UniquePtr(Pointer aPtr,
             typename Conditional<IsReference<D>::value,
                                  D,
                                  const D&>::Type aD1)
     : mTuple(aPtr, aD1)
   {}
@@ -401,17 +401,17 @@ public:
 
 private:
   // Forbidden for the same reasons as stated above.
   template<typename U, typename V>
   UniquePtr(U&& aU, V&& aV,
             typename EnableIf<IsPointer<U>::value &&
                               IsConvertible<U, Pointer>::value,
                               int>::Type aDummy = 0)
-  MOZ_DELETE;
+  = delete;
 
 public:
   UniquePtr(UniquePtr&& aOther)
     : mTuple(aOther.release(), Forward<DeleterType>(aOther.getDeleter()))
   {}
 
   template<typename N>
   UniquePtr(N,
@@ -476,24 +476,24 @@ private:
   template<typename U>
   void reset(U,
              typename EnableIf<!IsNullPointer<U>::value &&
                                !IsSame<U,
                                        Conditional<(sizeof(int) == sizeof(void*)),
                                                    int,
                                                    long>::Type>::value,
                                int>::Type aDummy = 0)
-  MOZ_DELETE;
+  = delete;
 
 public:
   void swap(UniquePtr& aOther) { mTuple.swap(aOther.mTuple); }
 
 private:
-  UniquePtr(const UniquePtr& aOther) MOZ_DELETE; // construct using Move()!
-  void operator=(const UniquePtr& aOther) MOZ_DELETE; // assign using Move()!
+  UniquePtr(const UniquePtr& aOther) = delete; // construct using Move()!
+  void operator=(const UniquePtr& aOther) = delete; // assign using Move()!
 };
 
 /** A default deletion policy using plain old operator delete. */
 template<typename T>
 class DefaultDelete
 {
 public:
   MOZ_CONSTEXPR DefaultDelete() {}
@@ -521,17 +521,17 @@ public:
   void operator()(T* aPtr) const
   {
     static_assert(sizeof(T) > 0, "T must be complete");
     delete[] aPtr;
   }
 
 private:
   template<typename U>
-  void operator()(U* aPtr) const MOZ_DELETE;
+  void operator()(U* aPtr) const = delete;
 };
 
 template<typename T, class D>
 void
 Swap(UniquePtr<T, D>& aX, UniquePtr<T, D>& aY)
 {
   aX.swap(aY);
 }
@@ -754,52 +754,52 @@ typename detail::UniqueSelector<T>::Unkn
 MakeUnique(decltype(sizeof(int)) aN)
 {
   typedef typename RemoveExtent<T>::Type ArrayType;
   return UniquePtr<T>(new ArrayType[aN]());
 }
 
 template<typename T>
 typename detail::UniqueSelector<T>::KnownBound
-MakeUnique() MOZ_DELETE;
+MakeUnique() = delete;
 
 template<typename T, typename A1>
 typename detail::UniqueSelector<T>::KnownBound
-MakeUnique(A1&& aA1) MOZ_DELETE;
+MakeUnique(A1&& aA1) = delete;
 
 template<typename T, typename A1, typename A2>
 typename detail::UniqueSelector<T>::KnownBound
-MakeUnique(A1&& aA1, A2&& aA2) MOZ_DELETE;
+MakeUnique(A1&& aA1, A2&& aA2) = delete;
 
 template<typename T, typename A1, typename A2, typename A3>
 typename detail::UniqueSelector<T>::KnownBound
-MakeUnique(A1&& aA1, A2&& aA2, A3&& aA3) MOZ_DELETE;
+MakeUnique(A1&& aA1, A2&& aA2, A3&& aA3) = delete;
 
 template<typename T, typename A1, typename A2, typename A3, typename A4>
 typename detail::UniqueSelector<T>::KnownBound
-MakeUnique(A1&& aA1, A2&& aA2, A3&& aA3, A4&& aA4) MOZ_DELETE;
+MakeUnique(A1&& aA1, A2&& aA2, A3&& aA3, A4&& aA4) = delete;
 
 template<typename T, typename A1, typename A2, typename A3, typename A4,
          typename A5>
 typename detail::UniqueSelector<T>::KnownBound
-MakeUnique(A1&& aA1, A2&& aA2, A3&& aA3, A4&& aA4, A5&& aA5) MOZ_DELETE;
+MakeUnique(A1&& aA1, A2&& aA2, A3&& aA3, A4&& aA4, A5&& aA5) = delete;
 
 template<typename T, typename A1, typename A2, typename A3, typename A4,
          typename A5, typename A6>
 typename detail::UniqueSelector<T>::KnownBound
 MakeUnique(A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5,
-           A6&& a6) MOZ_DELETE;
+           A6&& a6) = delete;
 
 template<typename T, typename A1, typename A2, typename A3, typename A4,
          typename A5, typename A6, typename A7>
 typename detail::UniqueSelector<T>::KnownBound
 MakeUnique(A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6,
-           A7&& a7) MOZ_DELETE;
+           A7&& a7) = delete;
 
 template<typename T, typename A1, typename A2, typename A3, typename A4,
          typename A5, typename A6, typename A7, typename A8>
 typename detail::UniqueSelector<T>::KnownBound
 MakeUnique(A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6,
-           A7&& a7, A8&& a8) MOZ_DELETE;
+           A7&& a7, A8&& a8) = delete;
 
 } // namespace mozilla
 
 #endif /* mozilla_UniquePtr_h */
--- a/mfbt/Vector.h
+++ b/mfbt/Vector.h
@@ -609,22 +609,22 @@ public:
    * Like sizeOfExcludingThis, but also measures the size of the vector
    * object (which must be heap-allocated) itself.
    */
   size_t sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
 
   void swap(ThisVector& aOther);
 
 private:
-  VectorBase(const VectorBase&) MOZ_DELETE;
-  void operator=(const VectorBase&) MOZ_DELETE;
+  VectorBase(const VectorBase&) = delete;
+  void operator=(const VectorBase&) = delete;
 
   /* Move-construct/assign only from our derived class, ThisVector. */
-  VectorBase(VectorBase&&) MOZ_DELETE;
-  void operator=(VectorBase&&) MOZ_DELETE;
+  VectorBase(VectorBase&&) = delete;
+  void operator=(VectorBase&&) = delete;
 };
 
 /* This does the re-entrancy check plus several other sanity checks. */
 #define MOZ_REENTRANCY_GUARD_ET_AL \
   ReentrancyGuard g(*this); \
   MOZ_ASSERT_IF(usingInlineStorage(), mCapacity == kInlineCapacity); \
   MOZ_ASSERT(reserved() <= mCapacity); \
   MOZ_ASSERT(mLength <= reserved()); \
--- a/mfbt/tests/TestMaybe.cpp
+++ b/mfbt/tests/TestMaybe.cpp
@@ -160,18 +160,18 @@ struct UncopyableValue
     mStatus = eWasMoveAssigned;
     aOther.mStatus = eWasMovedFrom;
     return *this;
   }
 
   Status GetStatus() { return mStatus; }
 
 private:
-  UncopyableValue(const UncopyableValue& aOther) MOZ_DELETE;
-  UncopyableValue& operator=(const UncopyableValue& aOther) MOZ_DELETE;
+  UncopyableValue(const UncopyableValue& aOther) = delete;
+  UncopyableValue& operator=(const UncopyableValue& aOther) = delete;
 
   Status mStatus;
 };
 
 struct UnmovableValue
 {
   UnmovableValue()
     : mStatus(eWasDefaultConstructed)
@@ -191,18 +191,18 @@ struct UnmovableValue
   {
     mStatus = eWasCopyAssigned;
     return *this;
   }
 
   Status GetStatus() { return mStatus; }
 
 private:
-  UnmovableValue(UnmovableValue&& aOther) MOZ_DELETE;
-  UnmovableValue& operator=(UnmovableValue&& aOther) MOZ_DELETE;
+  UnmovableValue(UnmovableValue&& aOther) = delete;
+  UnmovableValue& operator=(UnmovableValue&& aOther) = delete;
 
   Status mStatus;
 };
 
 struct UncopyableUnmovableValue
 {
   UncopyableUnmovableValue()
     : mStatus(eWasDefaultConstructed)
@@ -216,20 +216,20 @@ struct UncopyableUnmovableValue
     ++sUndestroyedObjects;
   }
 
   ~UncopyableUnmovableValue() { --sUndestroyedObjects; }
 
   Status GetStatus() { return mStatus; }
 
 private:
-  UncopyableUnmovableValue(const UncopyableUnmovableValue& aOther) MOZ_DELETE;
-  UncopyableUnmovableValue& operator=(const UncopyableUnmovableValue& aOther) MOZ_DELETE;
-  UncopyableUnmovableValue(UncopyableUnmovableValue&& aOther) MOZ_DELETE;
-  UncopyableUnmovableValue& operator=(UncopyableUnmovableValue&& aOther) MOZ_DELETE;
+  UncopyableUnmovableValue(const UncopyableUnmovableValue& aOther) = delete;
+  UncopyableUnmovableValue& operator=(const UncopyableUnmovableValue& aOther) = delete;
+  UncopyableUnmovableValue(UncopyableUnmovableValue&& aOther) = delete;
+  UncopyableUnmovableValue& operator=(UncopyableUnmovableValue&& aOther) = delete;
 
   Status mStatus;
 };
 
 static bool
 TestBasicFeatures()
 {
   // Check that a Maybe<T> is initialized to Nothing.
--- a/mfbt/tests/TestTypeTraits.cpp
+++ b/mfbt/tests/TestTypeTraits.cpp
@@ -224,17 +224,17 @@ static_assert(!IsUnsigned<long double>::
 
 static_assert(IsSigned<const volatile long double>::value,
               "const volatile long double should be signed");
 static_assert(!IsUnsigned<const volatile long double>::value,
               "const volatile long double shouldn't be unsigned");
 
 class NotIntConstructible
 {
-  NotIntConstructible(int) MOZ_DELETE;
+  NotIntConstructible(int) = delete;
 };
 
 static_assert(!IsSigned<NotIntConstructible>::value,
               "non-arithmetic types are not signed");
 static_assert(!IsUnsigned<NotIntConstructible>::value,
               "non-arithmetic types are not unsigned");
 
 namespace CPlusPlus11IsBaseOf {
--- a/modules/libjar/nsZipArchive.h
+++ b/modules/libjar/nsZipArchive.h
@@ -228,18 +228,18 @@ private:
   nsCString mURI;
 
 private:
   //--- private methods ---
   nsZipItem*        CreateZipItem();
   nsresult          BuildFileList(PRFileDesc *aFd = nullptr);
   nsresult          BuildSynthetics();
 
-  nsZipArchive& operator=(const nsZipArchive& rhs) MOZ_DELETE;
-  nsZipArchive(const nsZipArchive& rhs) MOZ_DELETE;
+  nsZipArchive& operator=(const nsZipArchive& rhs) = delete;
+  nsZipArchive(const nsZipArchive& rhs) = delete;
 };
 
 /** 
  * nsZipFind 
  *
  * a helper class for nsZipArchive, representing a search
  */
 class nsZipFind
@@ -252,18 +252,18 @@ public:
 
 private:
   nsRefPtr<nsZipArchive> mArchive;
   char*         mPattern;
   nsZipItem*    mItem;
   uint16_t      mSlot;
   bool          mRegExp;
 
-  nsZipFind& operator=(const nsZipFind& rhs) MOZ_DELETE;
-  nsZipFind(const nsZipFind& rhs) MOZ_DELETE;
+  nsZipFind& operator=(const nsZipFind& rhs) = delete;
+  nsZipFind(const nsZipFind& rhs) = delete;
 };
 
 /** 
  * nsZipCursor -- a low-level class for reading the individual items in a zip.
  */
 class nsZipCursor {
 public:
   /**
--- a/netwerk/base/src/AutoClose.h
+++ b/netwerk/base/src/AutoClose.h
@@ -59,17 +59,17 @@ public:
 private:
   void Close()
   {
     if (mPtr) {
       mPtr->Close();
     }
   }
 
-  void operator=(const AutoClose<T> &) MOZ_DELETE;
-  AutoClose(const AutoClose<T> &) MOZ_DELETE;
+  void operator=(const AutoClose<T> &) = delete;
+  AutoClose(const AutoClose<T> &) = delete;
 
   nsCOMPtr<T> mPtr;
 };
 
 } } // namespace mozilla::net
 
 #endif // mozilla_net_AutoClose_h
--- a/netwerk/cache2/CacheStorage.h
+++ b/netwerk/cache2/CacheStorage.h
@@ -36,17 +36,17 @@ public:
 
   explicit CacheEntryTable(EType aType) : mType(aType) { }
   EType Type() const
   {
     return mType;
   }
 private:
   EType const mType;
-  CacheEntryTable() MOZ_DELETE;
+  CacheEntryTable() = delete;
 };
 
 class CacheStorage : public nsICacheStorage
 {
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSICACHESTORAGE
 
 public:
--- a/netwerk/cache2/CacheStorageService.h
+++ b/netwerk/cache2/CacheStorageService.h
@@ -39,17 +39,17 @@ class CacheEntryTable;
 class CacheMemoryConsumer
 {
 private:
   friend class CacheStorageService;
   uint32_t mReportedMemoryConsumption : 30;
   uint32_t mFlags : 2;
 
 private:
-  CacheMemoryConsumer() MOZ_DELETE;
+  CacheMemoryConsumer() = delete;
 
 protected:
   enum {
     // No special treatment, reports always to the disk-entries pool.
     NORMAL = 0,
     // This consumer is belonging to a memory-only cache entry, used to decide
     // which of the two disk and memory pools count this consumption at.
     MEMORY_ONLY = 1 << 0,
@@ -315,17 +315,17 @@ private:
      */
     void PurgeOverMemoryLimit();
     void PurgeExpired();
     void PurgeByFrecency(bool &aFrecencyNeedsSort, uint32_t aWhat);
     void PurgeAll(uint32_t aWhat);
 
   private:
     uint32_t const Limit() const;
-    MemoryPool() MOZ_DELETE;
+    MemoryPool() = delete;
   };
 
   MemoryPool mDiskPool;
   MemoryPool mMemoryPool;
   MemoryPool& Pool(bool aUsingDisk)
   {
     return aUsingDisk ? mDiskPool : mMemoryPool;
   }
--- a/netwerk/cache2/OldWrappers.h
+++ b/netwerk/cache2/OldWrappers.h
@@ -137,17 +137,17 @@ public:
   NS_IMETHOD VisitMetaData(nsICacheEntryMetaDataVisitor*) MOZ_OVERRIDE;
 
   explicit _OldCacheEntryWrapper(nsICacheEntryDescriptor* desc);
   explicit _OldCacheEntryWrapper(nsICacheEntryInfo* info);
 
 private:
   virtual ~_OldCacheEntryWrapper();
 
-  _OldCacheEntryWrapper() MOZ_DELETE;
+  _OldCacheEntryWrapper() = delete;
   nsICacheEntryDescriptor* mOldDesc; // ref holded in mOldInfo
   nsCOMPtr<nsICacheEntryInfo> mOldInfo;
 };
 
 
 class _OldCacheLoad : public nsRunnable
                     , public nsICacheListener
 {
--- a/netwerk/cookie/nsCookieService.cpp
+++ b/netwerk/cookie/nsCookieService.cpp
@@ -3990,17 +3990,17 @@ namespace {
  * It will contain the app id and onlyBrowserElement flag information as input
  * and will contain the array of matching cookies as output.
  */
 struct GetCookiesForAppStruct {
   uint32_t              appId;
   bool                  onlyBrowserElement;
   nsCOMArray<nsICookie> cookies;
 
-  GetCookiesForAppStruct() MOZ_DELETE;
+  GetCookiesForAppStruct() = delete;
   GetCookiesForAppStruct(uint32_t aAppId, bool aOnlyBrowserElement)
     : appId(aAppId)
     , onlyBrowserElement(aOnlyBrowserElement)
   {}
 };
 
 } // anonymous namespace
 
--- a/security/manager/ssl/src/nsNSSCertificate.h
+++ b/security/manager/ssl/src/nsNSSCertificate.h
@@ -105,18 +105,18 @@ public:
                                      proofOfLock);
 private:
    virtual ~nsNSSCertList();
    virtual void virtualDestroyNSSReference() MOZ_OVERRIDE;
    void destructorSafeDestroyNSSReference();
 
    mozilla::ScopedCERTCertList mCertList;
 
-   nsNSSCertList(const nsNSSCertList&) MOZ_DELETE;
-   void operator=(const nsNSSCertList&) MOZ_DELETE;
+   nsNSSCertList(const nsNSSCertList&) = delete;
+   void operator=(const nsNSSCertList&) = delete;
 };
 
 class nsNSSCertListEnumerator: public nsISimpleEnumerator,
                                public nsNSSShutDownObject
 {
 public:
    NS_DECL_THREADSAFE_ISUPPORTS
    NS_DECL_NSISIMPLEENUMERATOR
@@ -125,18 +125,18 @@ public:
                            const nsNSSShutDownPreventionLock& proofOfLock);
 private:
    virtual ~nsNSSCertListEnumerator();
    virtual void virtualDestroyNSSReference() MOZ_OVERRIDE;
    void destructorSafeDestroyNSSReference();
 
    mozilla::ScopedCERTCertList mCertList;
 
-   nsNSSCertListEnumerator(const nsNSSCertListEnumerator&) MOZ_DELETE;
-   void operator=(const nsNSSCertListEnumerator&) MOZ_DELETE;
+   nsNSSCertListEnumerator(const nsNSSCertListEnumerator&) = delete;
+   void operator=(const nsNSSCertListEnumerator&) = delete;
 };
 
 
 #define NS_NSS_LONG 4
 #define NS_NSS_GET_LONG(x) ((((unsigned long)((x)[0])) << 24) | \
                             (((unsigned long)((x)[1])) << 16) | \
                             (((unsigned long)((x)[2])) <<  8) | \
                              ((unsigned long)((x)[3])) )
--- a/toolkit/components/filewatcher/NativeFileWatcherNotSupported.h
+++ b/toolkit/components/filewatcher/NativeFileWatcherNotSupported.h
@@ -36,17 +36,17 @@ public:
                            nsINativeFileWatcherErrorCallback* aOnError,
                            nsINativeFileWatcherSuccessCallback* aOnSuccess) MOZ_OVERRIDE
   {
     return NS_ERROR_NOT_IMPLEMENTED;
   };
 
 private:
   ~NativeFileWatcherService() { };
-  NativeFileWatcherService(const NativeFileWatcherService& other) MOZ_DELETE;
-  void operator=(const NativeFileWatcherService& other) MOZ_DELETE;
+  NativeFileWatcherService(const NativeFileWatcherService& other) = delete;
+  void operator=(const NativeFileWatcherService& other) = delete;
 };
 
 NS_IMPL_ISUPPORTS(NativeFileWatcherService, nsINativeFileWatcherService);
 
 } // namespace mozilla
 
 #endif // mozilla_nativefilewatcher_h__
--- a/toolkit/components/filewatcher/NativeFileWatcherWin.h
+++ b/toolkit/components/filewatcher/NativeFileWatcherWin.h
@@ -36,15 +36,15 @@ private:
   // The instance of the runnable dealing with the I/O.
   nsCOMPtr<nsIRunnable> mWorkerIORunnable;
 
   nsresult Uninit();
   void WakeUpWorkerThread();
 
   // Make the dtor private to make this object only deleted via its ::Release() method.
   ~NativeFileWatcherService();
-  NativeFileWatcherService(const NativeFileWatcherService& other) MOZ_DELETE;
-  void operator=(const NativeFileWatcherService& other) MOZ_DELETE;
+  NativeFileWatcherService(const NativeFileWatcherService& other) = delete;
+  void operator=(const NativeFileWatcherService& other) = delete;
 };
 
 } // namespace mozilla
 
 #endif // mozilla_nativefilewatcher_h__
--- a/toolkit/components/finalizationwitness/FinalizationWitnessService.h
+++ b/toolkit/components/finalizationwitness/FinalizationWitnessService.h
@@ -14,14 +14,14 @@ namespace mozilla {
  */
 class FinalizationWitnessService MOZ_FINAL : public nsIFinalizationWitnessService
 {
  public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIFINALIZATIONWITNESSSERVICE
  private:
   ~FinalizationWitnessService() {}
-  void operator=(const FinalizationWitnessService* other) MOZ_DELETE;
+  void operator=(const FinalizationWitnessService* other) = delete;
 };
 
 } // namespace mozilla
 
 #endif // mozilla_finalizationwitnessservice_h__
--- a/toolkit/components/osfile/NativeOSFileInternals.cpp
+++ b/toolkit/components/osfile/NativeOSFileInternals.cpp
@@ -118,18 +118,18 @@ struct ScopedArrayBufferContents: public
     if (ptr) {
       value.data = (uint8_t *) ptr;
       value.nbytes = length;
       return true;
     }
     return false;
   }
 private:
-  explicit ScopedArrayBufferContents(ScopedArrayBufferContents& source) MOZ_DELETE;
-  ScopedArrayBufferContents& operator=(ScopedArrayBufferContents& source) MOZ_DELETE;
+  explicit ScopedArrayBufferContents(ScopedArrayBufferContents& source) = delete;
+  ScopedArrayBufferContents& operator=(ScopedArrayBufferContents& source) = delete;
 };
 
 ///////// Cross-platform issues
 
 // Platform specific constants. As OS.File always uses OS-level
 // errors, we need to map a few high-level errors to OS-level
 // constants.
 #if defined(XP_UNIX)
--- a/toolkit/components/osfile/NativeOSFileInternals.h
+++ b/toolkit/components/osfile/NativeOSFileInternals.h
@@ -12,14 +12,14 @@ namespace mozilla {
 
 class NativeOSFileInternalsService MOZ_FINAL : public nsINativeOSFileInternalsService {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSINATIVEOSFILEINTERNALSSERVICE
 private:
   ~NativeOSFileInternalsService() {}
   // Avoid accidental use of built-in operator=
-  void operator=(const NativeOSFileInternalsService& other) MOZ_DELETE;
+  void operator=(const NativeOSFileInternalsService& other) = delete;
 };
 
 } // namespace mozilla
 
 #endif // mozilla_finalizationwitnessservice_h__
--- a/toolkit/components/telemetry/Telemetry.cpp
+++ b/toolkit/components/telemetry/Telemetry.cpp
@@ -249,18 +249,18 @@ public:
       mAnnotations = Move(aOther.mAnnotations);
       return *this;
     }
     uint32_t mHangIndex;
     UniquePtr<HangAnnotations> mAnnotations;
 
   private:
     // Force move constructor
-    AnnotationInfo(const AnnotationInfo& aOther) MOZ_DELETE;
-    void operator=(const AnnotationInfo& aOther) MOZ_DELETE;
+    AnnotationInfo(const AnnotationInfo& aOther) = delete;
+    void operator=(const AnnotationInfo& aOther) = delete;
   };
   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
   void AddHang(const Telemetry::ProcessedStack& aStack, uint32_t aDuration,
                int32_t aSystemUptime, int32_t aFirefoxUptime,
                UniquePtr<HangAnnotations> aAnnotations);
   uint32_t GetDuration(unsigned aIndex) const;
   int32_t GetSystemUptime(unsigned aIndex) const;
   int32_t GetFirefoxUptime(unsigned aIndex) const;
--- a/toolkit/identity/IdentityCryptoService.cpp
+++ b/toolkit/identity/IdentityCryptoService.cpp
@@ -99,18 +99,18 @@ private:
     mPrivateKey = nullptr;
     SECKEY_DestroyPublicKey(mPublicKey);
     mPublicKey = nullptr;
   }
 
   SECKEYPrivateKey * mPrivateKey;
   SECKEYPublicKey * mPublicKey;
 
-  KeyPair(const KeyPair &) MOZ_DELETE;
-  void operator=(const KeyPair &) MOZ_DELETE;
+  KeyPair(const KeyPair &) = delete;
+  void operator=(const KeyPair &) = delete;
 };
 
 NS_IMPL_ISUPPORTS(KeyPair, nsIIdentityKeyPair)
 
 class KeyGenRunnable : public nsRunnable, public nsNSSShutDownObject
 {
 public:
   NS_DECL_NSIRUNNABLE
@@ -137,18 +137,18 @@ private:
   {
   }
 
   const KeyType mKeyType; // in
   nsMainThreadPtrHandle<nsIIdentityKeyGenCallback> mCallback; // in
   nsresult mRv; // out
   nsCOMPtr<nsIIdentityKeyPair> mKeyPair; // out
 
-  KeyGenRunnable(const KeyGenRunnable &) MOZ_DELETE;
-  void operator=(const KeyGenRunnable &) MOZ_DELETE;
+  KeyGenRunnable(const KeyGenRunnable &) = delete;
+  void operator=(const KeyGenRunnable &) = delete;
 };
 
 class SignRunnable : public nsRunnable, public nsNSSShutDownObject
 {
 public:
   NS_DECL_NSIRUNNABLE
 
   SignRunnable(const nsACString & textToSign, SECKEYPrivateKey * privateKey,
@@ -178,18 +178,18 @@ private:
 
   const nsCString mTextToSign; // in
   SECKEYPrivateKey* mPrivateKey; // in
   nsMainThreadPtrHandle<nsIIdentitySignCallback> mCallback; // in
   nsresult mRv; // out
   nsCString mSignature; // out
 
 private:
-  SignRunnable(const SignRunnable &) MOZ_DELETE;
-  void operator=(const SignRunnable &) MOZ_DELETE;
+  SignRunnable(const SignRunnable &) = delete;
+  void operator=(const SignRunnable &) = delete;
 };
 
 class IdentityCryptoService MOZ_FINAL : public nsIIdentityCryptoService
 {
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIIDENTITYCRYPTOSERVICE
 
@@ -201,18 +201,18 @@ public:
       = do_GetService("@mozilla.org/psm;1", &rv);
     NS_ENSURE_SUCCESS(rv, rv);
 
     return NS_OK;
   }
 
 private:
   ~IdentityCryptoService() { }
-  IdentityCryptoService(const KeyPair &) MOZ_DELETE;
-  void operator=(const IdentityCryptoService &) MOZ_DELETE;
+  IdentityCryptoService(const KeyPair &) = delete;
+  void operator=(const IdentityCryptoService &) = delete;
 };
 
 NS_IMPL_ISUPPORTS(IdentityCryptoService, nsIIdentityCryptoService)
 
 NS_IMETHODIMP
 IdentityCryptoService::GenerateKeyPair(
   const nsACString & keyTypeString, nsIIdentityKeyGenCallback * callback)
 {
--- a/tools/profiler/EHABIStackWalk.cpp
+++ b/tools/profiler/EHABIStackWalk.cpp
@@ -57,26 +57,26 @@ struct PRel31 {
   uint32_t mBits;
   bool topBit() const { return mBits & 0x80000000; }
   uint32_t value() const { return mBits & 0x7fffffff; }
   int32_t offset() const { return (static_cast<int32_t>(mBits) << 1) >> 1; }
   const void *compute() const {
     return reinterpret_cast<const char *>(this) + offset();
   }
 private:
-  PRel31(const PRel31 &copied) MOZ_DELETE;
-  PRel31() MOZ_DELETE;
+  PRel31(const PRel31 &copied) = delete;
+  PRel31() = delete;
 };
 
 struct EHEntry {
   PRel31 startPC;
   PRel31 exidx;
 private:
-  EHEntry(const EHEntry &copied) MOZ_DELETE;
-  EHEntry() MOZ_DELETE;
+  EHEntry(const EHEntry &copied) = delete;
+  EHEntry() = delete;
 };
 
 class EHState {
   // Note that any core register can be used as a "frame pointer" to
   // influence the unwinding process, so this must track all of them.
   uint32_t mRegs[16];
 public:
   bool unwind(const EHEntry *aEntry, const void *stackBase);
--- a/tools/profiler/PseudoStack.h
+++ b/tools/profiler/PseudoStack.h
@@ -441,18 +441,18 @@ public:
       // The label macros keep a non ref counted reference to the
       // stack to avoid a TLS. If these are not all cleared we will
       // get a use-after-free so better to crash now.
       abort();
     }
   }
 
   // No copying.
-  PseudoStack(const PseudoStack&) MOZ_DELETE;
-  void operator=(const PseudoStack&) MOZ_DELETE;
+  PseudoStack(const PseudoStack&) = delete;
+  void operator=(const PseudoStack&) = delete;
 
   // Keep a list of pending markers that must be moved
   // to the circular buffer
   PendingMarkers mPendingMarkers;
   // List of LinkedUWTBuffers that must be processed on the next tick
   PendingUWTBuffers mPendingUWTBuffers;
   // This may exceed the length of mStack, so instead use the stackSize() method
   // to determine the number of valid samples in mStack
--- a/tools/profiler/TracedTaskCommon.h
+++ b/tools/profiler/TracedTaskCommon.h
@@ -79,19 +79,19 @@ public:
 
   FakeTracedTask(int* aVptr);
   void BeginFakeTracedTask();
   void EndFakeTracedTask();
 private:
   virtual ~FakeTracedTask() {}
 
   // No copy allowed.
-  FakeTracedTask() MOZ_DELETE;
-  FakeTracedTask(const FakeTracedTask& aTask) MOZ_DELETE;
-  FakeTracedTask& operator=(const FakeTracedTask& aTask) MOZ_DELETE;
+  FakeTracedTask() = delete;
+  FakeTracedTask(const FakeTracedTask& aTask) = delete;
+  FakeTracedTask& operator=(const FakeTracedTask& aTask) = delete;
 };
 
 class AutoRunFakeTracedTask
 {
 public:
   AutoRunFakeTracedTask(FakeTracedTask* aFakeTracedTask);
   ~AutoRunFakeTracedTask();
 private:
--- a/xpcom/base/nsAutoRef.h
+++ b/xpcom/base/nsAutoRef.h
@@ -611,17 +611,17 @@ protected:
     }
     explicit LocalSimpleRef(RawRef aRawRef)
       : SimpleRef(aRawRef)
     {
     }
   };
 
 private:
-  ThisClass& operator=(const ThisClass& aSmartRef) MOZ_DELETE;
+  ThisClass& operator=(const ThisClass& aSmartRef) = delete;
 
 public:
   RawRef operator->() const
   {
     return this->get();
   }
 
   // Transfer ownership to a raw reference.
--- a/xpcom/ds/TimeStamp.h
+++ b/xpcom/ds/TimeStamp.h
@@ -174,17 +174,17 @@ public:
     }
 
     return FromTicks(ticks);
   }
 
 private:
   // Block double multiplier (slower, imprecise if long duration) - Bug 853398.
   // If required, use MultDouble explicitly and with care.
-  BaseTimeDuration operator*(const double aMultiplier) const MOZ_DELETE;
+  BaseTimeDuration operator*(const double aMultiplier) const = delete;
 
 public:
   BaseTimeDuration MultDouble(double aMultiplier) const
   {
     return FromTicks(ValueCalculator::Multiply(mValue, aMultiplier));
   }
   BaseTimeDuration operator*(const int32_t aMultiplier) const
   {
--- a/xpcom/glue/DeadlockDetector.h
+++ b/xpcom/glue/DeadlockDetector.h
@@ -367,18 +367,18 @@ public:
   /**
    * Protects contentious methods.
    * Nb: can't use mozilla::Mutex since we are used as its deadlock
    * detector.
    */
   PRLock* mLock;
 
 private:
-  DeadlockDetector(const DeadlockDetector& aDD) MOZ_DELETE;
-  DeadlockDetector& operator=(const DeadlockDetector& aDD) MOZ_DELETE;
+  DeadlockDetector(const DeadlockDetector& aDD) = delete;
+  DeadlockDetector& operator=(const DeadlockDetector& aDD) = delete;
 };
 
 
 template<typename T>
 // FIXME bug 456272: tune based on average workload
 const uint32_t DeadlockDetector<T>::kDefaultNumBuckets = 32;
 
 
--- a/xpcom/glue/nsCOMArray.h
+++ b/xpcom/glue/nsCOMArray.h
@@ -174,17 +174,17 @@ public:
     mozilla::MallocSizeOf aMallocSizeOf, void* aData = nullptr) const;
 
 private:
 
   // the actual storage
   nsTArray<nsISupports*> mArray;
 
   // don't implement these, defaults will muck with refcounts!
-  nsCOMArray_base& operator=(const nsCOMArray_base& aOther) MOZ_DELETE;
+  nsCOMArray_base& operator=(const nsCOMArray_base& aOther) = delete;
 };
 
 inline void
 ImplCycleCollectionUnlink(nsCOMArray_base& aField)
 {
   aField.Clear();
 }
 
@@ -445,17 +445,17 @@ public:
   uint32_t Forget(T*** aElements)
   {
     return nsCOMArray_base::Forget(reinterpret_cast<nsISupports***>(aElements));
   }
 
 private:
 
   // don't implement these!
-  nsCOMArray<T>& operator=(const nsCOMArray<T>& aOther) MOZ_DELETE;
+  nsCOMArray<T>& operator=(const nsCOMArray<T>& aOther) = delete;
 };
 
 template<typename T>
 inline void
 ImplCycleCollectionUnlink(nsCOMArray<T>& aField)
 {
   aField.Clear();
 }
--- a/xpcom/glue/nsISupportsImpl.h
+++ b/xpcom/glue/nsISupportsImpl.h
@@ -334,18 +334,18 @@ public:
   nsrefcnt operator--() { return --mValue; }
 
   nsrefcnt operator=(nsrefcnt aValue) { return (mValue = aValue); }
   operator nsrefcnt() const { return mValue; }
   nsrefcnt get() const { return mValue; }
 
   static const bool isThreadSafe = false;
 private:
-  nsrefcnt operator++(int) MOZ_DELETE;
-  nsrefcnt operator--(int) MOZ_DELETE;
+  nsrefcnt operator++(int) = delete;
+  nsrefcnt operator--(int) = delete;
   nsrefcnt mValue;
 };
 
 #ifndef XPCOM_GLUE
 namespace mozilla {
 class ThreadSafeAutoRefCnt
 {
 public:
@@ -360,18 +360,18 @@ public:
   {
     return (mValue = aValue);
   }
   MOZ_ALWAYS_INLINE operator nsrefcnt() const { return mValue; }
   MOZ_ALWAYS_INLINE nsrefcnt get() const { return mValue; }
 
   static const bool isThreadSafe = true;
 private:
-  nsrefcnt operator++(int) MOZ_DELETE;
-  nsrefcnt operator--(int) MOZ_DELETE;
+  nsrefcnt operator++(int) = delete;
+  nsrefcnt operator--(int) = delete;
   // In theory, RelaseAcquire consistency (but no weaker) is sufficient for
   // the counter. Making it weaker could speed up builds on ARM (but not x86),
   // but could break pre-existing code that assumes sequential consistency.
   Atomic<nsrefcnt> mValue;
 };
 }
 #endif
 
--- a/xpcom/glue/nsStringAPI.h
+++ b/xpcom/glue/nsStringAPI.h
@@ -1102,17 +1102,17 @@ public:
   void Rebind(const char_type* aData, size_type aLength = UINT32_MAX)
   {
     NS_StringContainerFinish(*this);
     NS_StringContainerInit2(*this, aData, aLength,
                             NS_STRING_CONTAINER_INIT_DEPEND);
   }
 
 private:
-  self_type& operator=(const self_type& aString) MOZ_DELETE;
+  self_type& operator=(const self_type& aString) = delete;
 };
 
 class nsDependentCString : public nsCString
 {
 public:
   typedef nsDependentCString        self_type;
 
   nsDependentCString() {}
@@ -1126,17 +1126,17 @@ public:
   void Rebind(const char_type* aData, size_type aLength = UINT32_MAX)
   {
     NS_CStringContainerFinish(*this);
     NS_CStringContainerInit2(*this, aData, aLength,
                              NS_CSTRING_CONTAINER_INIT_DEPEND);
   }
 
 private:
-  self_type& operator=(const self_type& aString) MOZ_DELETE;
+  self_type& operator=(const self_type& aString) = delete;
 };
 
 
 /**
  * conversion classes
  */
 
 inline void
@@ -1179,17 +1179,17 @@ public:
   explicit NS_ConvertASCIItoUTF16(const char* aData,
                                   uint32_t aLength = UINT32_MAX)
   {
     NS_CStringToUTF16(nsDependentCString(aData, aLength),
                       NS_CSTRING_ENCODING_ASCII, *this);
   }
 
 private:
-  self_type& operator=(const self_type& aString) MOZ_DELETE;
+  self_type& operator=(const self_type& aString) = delete;
 };
 
 class NS_ConvertUTF8toUTF16 : public nsString
 {
 public:
   typedef NS_ConvertUTF8toUTF16    self_type;
 
   explicit NS_ConvertUTF8toUTF16(const nsACString& aStr)
@@ -1200,17 +1200,17 @@ public:
   explicit NS_ConvertUTF8toUTF16(const char* aData,
                                  uint32_t aLength = UINT32_MAX)
   {
     NS_CStringToUTF16(nsDependentCString(aData, aLength),
                       NS_CSTRING_ENCODING_UTF8, *this);
   }
 
 private:
-  self_type& operator=(const self_type& aString) MOZ_DELETE;
+  self_type& operator=(const self_type& aString) = delete;
 };
 
 class NS_ConvertUTF16toUTF8 : public nsCString
 {
 public:
   typedef NS_ConvertUTF16toUTF8    self_type;
 
   explicit NS_ConvertUTF16toUTF8(const nsAString& aStr)
@@ -1221,17 +1221,17 @@ public:
   explicit NS_ConvertUTF16toUTF8(const char16_t* aData,
                                  uint32_t aLength = UINT32_MAX)
   {
     NS_UTF16ToCString(nsDependentString(aData, aLength),
                       NS_CSTRING_ENCODING_UTF8, *this);
   }
 
 private:
-  self_type& operator=(const self_type& aString) MOZ_DELETE;
+  self_type& operator=(const self_type& aString) = delete;
 };
 
 class NS_LossyConvertUTF16toASCII : public nsCString
 {
 public:
   typedef NS_LossyConvertUTF16toASCII    self_type;
 
   explicit NS_LossyConvertUTF16toASCII(const nsAString& aStr)
@@ -1242,17 +1242,17 @@ public:
   explicit NS_LossyConvertUTF16toASCII(const char16_t* aData,
                                        uint32_t aLength = UINT32_MAX)
   {
     NS_UTF16ToCString(nsDependentString(aData, aLength),
                       NS_CSTRING_ENCODING_ASCII, *this);
   }
 
 private:
-  self_type& operator=(const self_type& aString) MOZ_DELETE;
+  self_type& operator=(const self_type& aString) = delete;
 };
 
 
 /**
  * literal strings
  */
 static_assert(sizeof(char16_t) == 2, "size of char16_t must be 2");
 static_assert(char16_t(-1) > char16_t(0), "char16_t must be unsigned");
@@ -1384,17 +1384,17 @@ public:
   {
     NS_StringContainerFinish(*this);
     NS_StringContainerInit2(*this, aStart, aLength,
                             NS_STRING_CONTAINER_INIT_DEPEND |
                             NS_STRING_CONTAINER_INIT_SUBSTRING);
   }
 
 private:
-  self_type& operator=(const self_type& aString) MOZ_DELETE;
+  self_type& operator=(const self_type& aString) = delete;
 };
 
 class nsDependentCSubstring : public nsCStringContainer
 {
 public:
   typedef nsDependentCSubstring self_type;
   typedef nsACString            abstract_string_type;
 
@@ -1417,17 +1417,17 @@ public:
   {
     NS_CStringContainerFinish(*this);
     NS_CStringContainerInit2(*this, aStart, aLength,
                              NS_CSTRING_CONTAINER_INIT_DEPEND |
                              NS_CSTRING_CONTAINER_INIT_SUBSTRING);
   }
 
 private:
-  self_type& operator=(const self_type& aString) MOZ_DELETE;
+  self_type& operator=(const self_type& aString) = delete;
 };
 
 
 /**
  * Various nsDependentC?Substring constructor functions
  */
 
 // char16_t
--- a/xpcom/glue/nsTHashtable.h
+++ b/xpcom/glue/nsTHashtable.h
@@ -352,34 +352,34 @@ protected:
     void* userArg;
   };
 
   static size_t s_SizeOfStub(PLDHashEntryHdr* aEntry,
                              mozilla::MallocSizeOf aMallocSizeOf, void* aArg);
 
 private:
   // copy constructor, not implemented
-  nsTHashtable(nsTHashtable<EntryType>& aToCopy) MOZ_DELETE;
+  nsTHashtable(nsTHashtable<EntryType>& aToCopy) = delete;
 
   /**
    * Initialize the table.
    * @param aInitLength the initial number of buckets in the hashtable
    */
   void Init(uint32_t aInitLength);
 
   /**
    * An implementation of SizeOfEntryExcludingThisFun that calls SizeOfExcludingThis()
    * on each entry.
    */
   static size_t BasicSizeOfEntryExcludingThisFun(EntryType* aEntry,
                                                  mozilla::MallocSizeOf aMallocSizeOf,
                                                  void*);
 
   // assignment operator, not implemented
-  nsTHashtable<EntryType>& operator=(nsTHashtable<EntryType>& aToEqual) MOZ_DELETE;
+  nsTHashtable<EntryType>& operator=(nsTHashtable<EntryType>& aToEqual) = delete;
 };
 
 //
 // template definitions
 //
 
 template<class EntryType>
 nsTHashtable<EntryType>::nsTHashtable(nsTHashtable<EntryType>&& aOther)
--- a/xpcom/glue/nsThreadUtils.h
+++ b/xpcom/glue/nsThreadUtils.h
@@ -532,18 +532,18 @@ public:
    * is null) then the name is synchronously set on the current thread.
    */
   void SetThreadPoolName(const nsACString& aPoolName,
                          nsIThread* aThread = nullptr);
 
 private:
   volatile uint32_t mCounter;
 
-  nsThreadPoolNaming(const nsThreadPoolNaming&) MOZ_DELETE;
-  void operator=(const nsThreadPoolNaming&) MOZ_DELETE;
+  nsThreadPoolNaming(const nsThreadPoolNaming&) = delete;
+  void operator=(const nsThreadPoolNaming&) = delete;
 };
 
 /**
  * Thread priority in most operating systems affect scheduling, not IO.  This
  * helper is used to set the current thread to low IO priority for the lifetime
  * of the created object.  You can only use this low priority IO setting within
  * the context of the current thread.
  */
--- a/xpcom/string/nsString.h
+++ b/xpcom/string/nsString.h
@@ -79,17 +79,17 @@ public:
 
   explicit NS_LossyConvertUTF16toASCII(const nsAString& aString)
   {
     LossyAppendUTF16toASCII(aString, *this);
   }
 
 private:
   // NOT TO BE IMPLEMENTED
-  NS_LossyConvertUTF16toASCII(char) MOZ_DELETE;
+  NS_LossyConvertUTF16toASCII(char) = delete;
 };
 
 
 class NS_ConvertASCIItoUTF16 : public nsAutoString
 {
 public:
   explicit NS_ConvertASCIItoUTF16(const char* aCString)
   {
@@ -103,17 +103,17 @@ public:
 
   explicit NS_ConvertASCIItoUTF16(const nsACString& aCString)
   {
     AppendASCIItoUTF16(aCString, *this);
   }
 
 private:
   // NOT TO BE IMPLEMENTED
-  NS_ConvertASCIItoUTF16(char16_t) MOZ_DELETE;
+  NS_ConvertASCIItoUTF16(char16_t) = delete;
 };
 
 
 /**
  * A helper class that converts a UTF-16 string to UTF-8
  */
 class NS_ConvertUTF16toUTF8 : public nsAutoCString
 {
@@ -142,17 +142,17 @@ public:
 
   explicit NS_ConvertUTF16toUTF8(const nsAString& aString)
   {
     AppendUTF16toUTF8(aString, *this);
   }
 
 private:
   // NOT TO BE IMPLEMENTED
-  NS_ConvertUTF16toUTF8(char) MOZ_DELETE;
+  NS_ConvertUTF16toUTF8(char) = delete;
 };
 
 
 class NS_ConvertUTF8toUTF16 : public nsAutoString
 {
 public:
   explicit NS_ConvertUTF8toUTF16(const char* aCString)
   {
@@ -166,17 +166,17 @@ public:
 
   explicit NS_ConvertUTF8toUTF16(const nsACString& aCString)
   {
     AppendUTF8toUTF16(aCString, *this);
   }
 
 private:
   // NOT TO BE IMPLEMENTED
-  NS_ConvertUTF8toUTF16(char16_t) MOZ_DELETE;
+  NS_ConvertUTF8toUTF16(char16_t) = delete;
 };
 
 
 #ifdef MOZ_USE_CHAR16_WRAPPER
 
 inline char16_t*
 wwc(wchar_t* aStr)
 {
--- a/xpcom/string/nsTDependentString.h
+++ b/xpcom/string/nsTDependentString.h
@@ -97,10 +97,10 @@ public:
     Rebind(aStart, uint32_t(aEnd - aStart));
   }
 
   void Rebind(const string_type&, uint32_t aStartPos);
 
 private:
 
   // NOT USED
-  nsTDependentString_CharT(const substring_tuple_type&) MOZ_DELETE;
+  nsTDependentString_CharT(const substring_tuple_type&) = delete;
 };
--- a/xpcom/string/nsTLiteralString.h
+++ b/xpcom/string/nsTLiteralString.h
@@ -32,10 +32,10 @@ public:
     : string_type(const_cast<char_type*>(aStr), N - 1, F_TERMINATED | F_LITERAL)
   {
   }
 
 private:
 
   // NOT TO BE IMPLEMENTED
   template<size_type N>
-  nsTLiteralString_CharT(char_type (&aStr)[N]) MOZ_DELETE;
+  nsTLiteralString_CharT(char_type (&aStr)[N]) = delete;
 };
--- a/xpcom/string/nsTPromiseFlatString.h
+++ b/xpcom/string/nsTPromiseFlatString.h
@@ -70,23 +70,23 @@ public:
 
   typedef nsTPromiseFlatString_CharT self_type;
 
 private:
 
   void Init(const substring_type&);
 
   // NOT TO BE IMPLEMENTED
-  void operator=(const self_type&) MOZ_DELETE;
+  void operator=(const self_type&) = delete;
 
   // NOT TO BE IMPLEMENTED
-  nsTPromiseFlatString_CharT() MOZ_DELETE;
+  nsTPromiseFlatString_CharT() = delete;
 
   // NOT TO BE IMPLEMENTED
-  nsTPromiseFlatString_CharT(const string_type& aStr) MOZ_DELETE;
+  nsTPromiseFlatString_CharT(const string_type& aStr) = delete;
 
 public:
 
   explicit
   nsTPromiseFlatString_CharT(const substring_type& aStr)
     : string_type()
   {
     Init(aStr);
--- a/xpcom/string/nsTString.h
+++ b/xpcom/string/nsTString.h
@@ -864,12 +864,12 @@ public:
   }
 
   // Adopt(), if possible, when assigning to a self_type&. Note
   // that this violates the constness of aStr, aStr is always
   // truncated when this operator is called.
   self_type& operator=(const self_type& aStr);
 
 private:
-  self_type& operator=(const char_type* aData) MOZ_DELETE;
-  self_type& operator=(char_type* aData) MOZ_DELETE;
+  self_type& operator=(const char_type* aData) = delete;
+  self_type& operator=(char_type* aData) = delete;
 };