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 222858 86924ac6a94a
parent 222857 9838f371e098
child 222859 02de139764d9
push id28074
push usercbook@mozilla.com
push dateFri, 09 Jan 2015 13:00:21 +0000
treeherdermozilla-central@ed280f6c7b39 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersWaldo
bugs1118486
milestone37.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 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;
 };