--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -4528,17 +4528,17 @@ nsDocShell::GetWindow()
 NS_IMETHODIMP
 nsDocShell::SetDeviceSizeIsPageSize(bool aValue)
 {
   if (mDeviceSizeIsPageSize != aValue) {
     mDeviceSizeIsPageSize = aValue;
     RefPtr<nsPresContext> presContext;
     GetPresContext(getter_AddRefs(presContext));
     if (presContext) {
-      presContext->MediaFeatureValuesChanged(nsRestyleHint(0));
+      presContext->MediaFeatureValuesChanged(nsRestyleHint::None);
     }
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDocShell::GetDeviceSizeIsPageSize(bool* aValue)
 {

--- a/dom/animation/EffectCompositor.cpp
+++ b/dom/animation/EffectCompositor.cpp
@@ -966,39 +966,39 @@ EffectCompositor::ClearBaseStyles(dom::E
 
 NS_IMPL_ISUPPORTS(EffectCompositor::AnimationStyleRuleProcessor,
                   nsIStyleRuleProcessor)
 
 nsRestyleHint
 EffectCompositor::AnimationStyleRuleProcessor::HasStateDependentStyle(
   StateRuleProcessorData* aData)
 {
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 nsRestyleHint
 EffectCompositor::AnimationStyleRuleProcessor::HasStateDependentStyle(
   PseudoElementStateRuleProcessorData* aData)
 {
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 bool
 EffectCompositor::AnimationStyleRuleProcessor::HasDocumentStateDependentStyle(
   StateRuleProcessorData* aData)
 {
   return false;
 }
 
 nsRestyleHint
 EffectCompositor::AnimationStyleRuleProcessor::HasAttributeDependentStyle(
                         AttributeRuleProcessorData* aData,
                         RestyleHintData& aRestyleHintDataResult)
 {
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 bool
 EffectCompositor::AnimationStyleRuleProcessor::MediumFeaturesChanged(
   nsPresContext* aPresContext)
 {
   return false;
 }

--- a/dom/svg/SVGSVGElement.cpp
+++ b/dom/svg/SVGSVGElement.cpp
@@ -706,17 +706,17 @@ SVGSVGElement::ChildrenOnlyTransformChan
 
   // If we're not reconstructing the frame tree, then we only call
   // PostRestyleEvent if we're not being called under reflow to avoid recursing
   // to death. See bug 767056 comments 10 and 12. Since our nsSVGOuterSVGFrame
   // is being reflowed we're going to invalidate and repaint its entire area
   // anyway (which will include our children).
   if ((changeHint & nsChangeHint::ReconstructFrame) ||
       !(aFlags & eDuringReflow)) {
-    nsLayoutUtils::PostRestyleEvent(this, nsRestyleHint(0), changeHint);
+    nsLayoutUtils::PostRestyleEvent(this, nsRestyleHint::None, changeHint);
   }
 }
 
 nsresult
 SVGSVGElement::BindToTree(nsIDocument* aDocument,
                           nsIContent* aParent,
                           nsIContent* aBindingParent,
                           bool aCompileEventHandlers)

--- a/dom/svg/SVGSwitchElement.cpp
+++ b/dom/svg/SVGSwitchElement.cpp
@@ -59,17 +59,17 @@ SVGSwitchElement::MaybeInvalidate()
 
   if (newActiveChild == mActiveChild) {
     return;
   }
 
   nsIFrame *frame = GetPrimaryFrame();
   if (frame) {
     nsLayoutUtils::PostRestyleEvent(
-      this, nsRestyleHint(0),
+      this, nsRestyleHint::None,
       nsChangeHint::InvalidateRenderingObservers);
     nsSVGUtils::ScheduleReflowSVG(frame);
   }
 
   mActiveChild = newActiveChild;
 }
 
 //----------------------------------------------------------------------

--- a/dom/svg/nsSVGElement.cpp
+++ b/dom/svg/nsSVGElement.cpp
@@ -2393,17 +2393,17 @@ nsSVGElement::DidAnimateTransformList(in
     // SVGTransformableElement::GetAttributeChangeHint will be called and an
     // appropriate change event posted to update our frame's overflow rects.
     // The SetAttrAndNotify doesn't happen for transform changes caused by
     // 'animateTransform' though (and sending out the mutation events that
     // nsNodeUtills::AttributeChanged dispatches would be inappropriate
     // anyway), so we need to post the change event ourself.
     nsChangeHint changeHint = GetAttributeChangeHint(transformAttr, aModType);
     if (bool(changeHint)) {
-      nsLayoutUtils::PostRestyleEvent(this, nsRestyleHint(0), changeHint);
+      nsLayoutUtils::PostRestyleEvent(this, nsRestyleHint::None, changeHint);
     }
   }
 }
 
 nsSVGElement::StringAttributesInfo
 nsSVGElement::GetStringInfo()
 {
   return StringAttributesInfo(nullptr, nullptr, 0);

--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -2913,17 +2913,17 @@ PresShell::RecreateFramesFor(nsIContent*
 
   return rv;
 }
 
 void
 nsIPresShell::PostRecreateFramesFor(Element* aElement)
 {
   mPresContext->RestyleManager()->
-    PostRestyleEvent(aElement, nsRestyleHint(0),
+    PostRestyleEvent(aElement, nsRestyleHint::None,
                      nsChangeHint::ReconstructFrame);
 }
 
 void
 nsIPresShell::RestyleForAnimation(Element* aElement, nsRestyleHint aHint)
 {
   // Now that we no longer have separate non-animation and animation
   // restyles, this method having a distinct identity is less important,

--- a/layout/base/RestyleManager.cpp
+++ b/layout/base/RestyleManager.cpp
@@ -84,17 +84,17 @@ ElementTagToString(dom::Element* aElemen
 
 RestyleManager::RestyleManager(nsPresContext* aPresContext)
   : RestyleManagerBase(aPresContext)
   , mDoRebuildAllStyleData(false)
   , mInRebuildAllStyleData(false)
   , mSkipAnimationRules(false)
   , mHavePendingNonAnimationRestyles(false)
   , mRebuildAllExtraHint(nsChangeHint::None)
-  , mRebuildAllRestyleHint(nsRestyleHint(0))
+  , mRebuildAllRestyleHint(nsRestyleHint::None)
   , mAnimationGeneration(0)
   , mReframingStyleContexts(nullptr)
   , mAnimationsWithDestroyedFrame(nullptr)
   , mPendingRestyles(ELEMENT_HAS_PENDING_RESTYLE |
                      ELEMENT_IS_POTENTIAL_RESTYLE_ROOT |
                      ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR)
   , mIsProcessingRestyles(false)
 #ifdef RESTYLE_LOGGING
@@ -728,17 +728,17 @@ RestyleManager::StartRebuildAllStyleData
   nsresult rv = StyleSet()->BeginReconstruct();
   if (NS_FAILED(rv)) {
     MOZ_CRASH("unable to rebuild style data");
   }
 
   nsRestyleHint restyleHint = mRebuildAllRestyleHint;
   nsChangeHint changeHint = mRebuildAllExtraHint;
   mRebuildAllExtraHint = nsChangeHint::None;
-  mRebuildAllRestyleHint = nsRestyleHint(0);
+  mRebuildAllRestyleHint = nsRestyleHint::None;
 
   restyleHint |= nsRestyleHint::ForceDescendants;
 
   if (!(restyleHint & nsRestyleHint::Subtree) &&
       (restyleHint & ~(nsRestyleHint::Force | nsRestyleHint::ForceDescendants))) {
     // We want this hint to apply to the root node's primary frame
     // rather than the root frame, since it's the primary frame that has
     // the styles for the root element (rather than the ancestors of the
@@ -747,17 +747,17 @@ RestyleManager::StartRebuildAllStyleData
     // ancestors that we hit first, then we'll fail to do the restyling
     // we need to do.
     Element* root = PresContext()->Document()->GetRootElement();
     if (root) {
       // If the root element is gone, dropping the hint on the floor
       // should be fine.
       aRestyleTracker.AddPendingRestyle(root, restyleHint, nsChangeHint::None);
     }
-    restyleHint = nsRestyleHint(0);
+    restyleHint = nsRestyleHint::None;
   }
 
   // Recalculate all of the style contexts for the document, from the
   // root frame.  We can't do this with a change hint, since we can't
   // post a change hint for the root frame.
   // Note that we can ignore the return value of ComputeStyleChangeFor
   // because we never need to reframe the root frame.
   // XXX Does it matter that we're passing aExtraHint to the real root
@@ -2074,17 +2074,17 @@ ElementRestyler::Restyle(nsRestyleHint a
   AutoSelectorArrayTruncater asat(mSelectorsForDescendants);
 
   // List of descendant elements of mContent we know we will eventually need to
   // restyle.  Before we return from this function, we call
   // RestyleTracker::AddRestyleRootsIfAwaitingRestyle to ensure they get
   // restyled in RestyleTracker::DoProcessRestyles.
   nsTArray<RefPtr<Element>> descendants;
 
-  nsRestyleHint hintToRestore = nsRestyleHint(0);
+  nsRestyleHint hintToRestore = nsRestyleHint::None;
   RestyleHintData hintDataToRestore;
   if (mContent && mContent->IsElement() &&
       // If we're resolving from the root of the frame tree (which
       // we do when mDoRebuildAllStyleData), we need to avoid getting the
       // root's restyle data until we get to its primary frame, since
       // it's the primary frame that has the styles for the root element
       // (rather than the ancestors of the primary frame whose mContent
       // is the root node but which have different styles).  If we use
@@ -2108,17 +2108,17 @@ ElementRestyler::Restyle(nsRestyleHint a
       hintToRestore = restyleData->mRestyleHint;
       hintDataToRestore = Move(restyleData->mRestyleHintData);
       aRestyleHint = nsRestyleHint(aRestyleHint | restyleData->mRestyleHint);
       descendants.SwapElements(restyleData->mDescendants);
     }
   }
 
   // If we are restyling this frame with nsRestyleHint::Self or weaker hints,
-  // we restyle children with nsRestyleHint(0).  But we pass the
+  // we restyle children with nsRestyleHint::None.  But we pass the
   // nsRestyleHint::ForceDescendants flag down too.
   nsRestyleHint childRestyleHint =
     aRestyleHint & (nsRestyleHint::SomeDescendants |
                     nsRestyleHint::Subtree |
                     nsRestyleHint::ForceDescendants);
 
   RefPtr<nsStyleContext> oldContext = mFrame->StyleContext();
 
@@ -3158,17 +3158,17 @@ ElementRestyler::RestyleSelf(nsIFrame* a
           PseudoElementForStyleContext(aSelf, extraPseudoType);
         MOZ_ASSERT(!element || element != pseudoElement,
                    "pseudo-element for selector matching should be "
                    "the anonymous content node that we create, "
                    "not the real element");
         newExtraContext =
           styleSet->ResolveStyleWithReplacement(element, pseudoElement,
                                                 newContext, oldExtraContext,
-                                                nsRestyleHint(0));
+                                                nsRestyleHint::None);
       }
     } else if (extraPseudoType == CSSPseudoElementType::AnonBox) {
       newExtraContext = styleSet->ResolveAnonymousBoxStyle(extraPseudoTag,
                                                            newContext);
     } else {
       // Don't expect XUL tree stuff here, since it needs a comparator and
       // all.
       NS_ASSERTION(extraPseudoType < CSSPseudoElementType::Count,
@@ -3274,17 +3274,17 @@ ElementRestyler::RestyleChildrenOfDispla
   RestyleTracker&        aRestyleTracker,
   nsRestyleHint          aRestyleHint,
   const RestyleHintData& aRestyleHintData)
 {
   MOZ_ASSERT(!(mHintsHandled & nsChangeHint::ReconstructFrame),
              "why call me?");
 
   const bool mightReframePseudos = !!(aRestyleHint & nsRestyleHint::Subtree);
-  DoRestyleUndisplayedDescendants(nsRestyleHint(0), mContent, aNewContext);
+  DoRestyleUndisplayedDescendants(nsRestyleHint::None, mContent, aNewContext);
   if (!(mHintsHandled & nsChangeHint::ReconstructFrame) &&
       mightReframePseudos) {
     MaybeReframeForPseudo(CSSPseudoElementType::before,
                           aParentFrame, nullptr, mContent, aNewContext);
   }
   if (!(mHintsHandled & nsChangeHint::ReconstructFrame) &&
       mightReframePseudos) {
     MaybeReframeForPseudo(CSSPseudoElementType::after,

--- a/layout/base/RestyleManager.h
+++ b/layout/base/RestyleManager.h
@@ -360,17 +360,17 @@ public:
   void UpdateOnlyAnimationStyles();
 
   // Rebuilds all style data by throwing out the old rule tree and
   // building a new one, and additionally applying aExtraHint (which
   // must not contain nsChangeHint_ReconstructFrame) to the root frame.
   //
   // aRestyleHint says which restyle hint to use for the computation;
   // the only sensible values to use are eRestyle_Subtree (which says
-  // that the rebuild must run selector matching) and nsRestyleHint(0)
+  // that the rebuild must run selector matching) and nsRestyleHint::None
   // (which says that rerunning selector matching is not required.  (The
   // method adds eRestyle_ForceDescendants internally, and including it
   // in the restyle hint is harmless; some callers (e.g.,
   // nsPresContext::MediaFeatureValuesChanged) might do this for their
   // own reasons.)
   void RebuildAllStyleData(nsChangeHint aExtraHint,
                            nsRestyleHint aRestyleHint);
 
@@ -582,17 +582,17 @@ public:
                   nsTArray<RefPtr<nsStyleContext>>& aSwappedStructOwners);
 
   /**
    * Restyle our frame's element and its subtree.
    *
    * Use eRestyle_Self for the aRestyleHint argument to mean
    * "reresolve our style context but not kids", use eRestyle_Subtree
    * to mean "reresolve our style context and kids", and use
-   * nsRestyleHint(0) to mean recompute a new style context for our
+   * nsRestyleHint::None to mean recompute a new style context for our
    * current parent and existing rulenode, and the same for kids.
    */
   void Restyle(nsRestyleHint aRestyleHint);
 
   /**
    * mHintsHandled changes over time; it starts off as the hints that
    * have been handled by ancestors, and by the end of Restyle it
    * represents the hints that have been handled for this frame.  This

--- a/layout/base/RestyleManagerBase.cpp
+++ b/layout/base/RestyleManagerBase.cpp
@@ -82,17 +82,17 @@ RestyleManagerBase::ContentStateChangedI
                pseudoType)) {
     // If aElement is a pseudo-element, we want to check to see whether there
     // are any state-dependent rules applying to that pseudo.
     Element* ancestor =
       ElementForStyleContext(nullptr, primaryFrame, pseudoType);
     *aOutRestyleHint = styleSet->HasStateDependentStyle(ancestor, pseudoType,
                                                         aElement, aStateMask);
   } else {
-    *aOutRestyleHint = nsRestyleHint(0);
+    *aOutRestyleHint = nsRestyleHint::None;
   }
 
   if (aStateMask.HasState(NS_EVENT_STATE_HOVER) && bool(*aOutRestyleHint)) {
     IncrementHoverGeneration();
   }
 
   if (aStateMask.HasState(NS_EVENT_STATE_VISITED)) {
     // Exposing information to the page about whether the link is
@@ -127,17 +127,17 @@ RestyleManagerBase::RestyleHintToString(
   }
   if (rest) {
     if (any) {
       result.AppendLiteral(" | ");
     }
     result.AppendPrintf("0x%0x", rest);
   } else {
     if (!any) {
-      result.AppendLiteral("0");
+      result.AppendLiteral("nsRestyleHint::None");
     }
   }
   return result;
 }
 
 #ifdef DEBUG
 /* static */ nsCString
 RestyleManagerBase::ChangeHintToString(nsChangeHint aHint)

--- a/layout/base/RestyleTracker.h
+++ b/layout/base/RestyleTracker.h
@@ -105,17 +105,17 @@ public:
   struct Hints {
     nsRestyleHint mRestyleHint;        // What we want to restyle
     nsChangeHint mChangeHint;          // The minimal change hint for "self"
     RestyleHintData mRestyleHintData;  // Data associated with mRestyleHint
   };
 
   struct RestyleData : Hints {
     RestyleData() {
-      mRestyleHint = nsRestyleHint(0);
+      mRestyleHint = nsRestyleHint::None;
       mChangeHint = nsChangeHint::None;
     }
 
     RestyleData(nsRestyleHint aRestyleHint, nsChangeHint aChangeHint,
                 const RestyleHintData* aRestyleHintData) {
       mRestyleHint = aRestyleHint;
       mChangeHint = aChangeHint;
       if (aRestyleHintData) {

--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -9734,17 +9734,17 @@ nsCSSFrameConstructor::RecreateFramesFor
     }
     if (reconstruct && !didReconstruct) {
       // Now, recreate the frames associated with this content object. If
       // ContentRemoved triggered reconstruction, then we don't need to do this
       // because the frames will already have been built.
       if (aAsyncInsert) {
         // XXXmats doesn't frame state need to be restored in this case too?
         RestyleManager()->PostRestyleEvent(
-          aContent->AsElement(), nsRestyleHint(0),
+          aContent->AsElement(), nsRestyleHint::None,
           nsChangeHint::ReconstructFrame);
       } else {
         rv = ContentInserted(container, aContent, mTempFrameTreeState, false);
       }
     }
   }
 
   return rv;

--- a/layout/base/nsChangeHint.h
+++ b/layout/base/nsChangeHint.h
@@ -343,17 +343,17 @@ inline nsChangeHint NS_HintsNotHandledFo
              "something is inconsistent");
 
   return result;
 }
 
 /**
  * |nsRestyleHint| is a bitfield for the result of
  * |HasStateDependentStyle| and |HasAttributeDependentStyle|.  When no
- * restyling is necessary, use |nsRestyleHint(0)|.
+ * restyling is necessary, use |nsRestyleHint::None|.
  *
  * Without nsRestyleHint::Force or nsRestyleHint::ForceDescendants, the
  * restyling process can stop processing at a frame when it detects no style
  * changes and it is known that the styles of the subtree beneath it will not
  * change, leaving the old style context on the frame.
  * nsRestyleHint::Force can be used to skip this optimization on a frame, and
  * to force its new style context to be used.
  *
@@ -361,16 +361,18 @@ inline nsChangeHint NS_HintsNotHandledFo
  * its descendants to be traversed and for the new style contexts that are
  * created to be set on the frames.
  *
  * NOTE: When adding new restyle hints, please also add them to
  * RestyleManager::RestyleHintToString.
  */
 typedef uint32_t nsRestyleHintTypeBase;
 enum class nsRestyleHint : nsRestyleHintTypeBase {
+  None = 0,
+
   // Rerun selector matching on the element.  If a new style context
   // results, update the style contexts of descendants.  (Irrelevant if
   // |Subtree| is also set, since that implies a superset of the
   // work.)
   Self = 1 << 0,
 
   // Rerun selector matching on descendants of the element that match
   // a given selector.

--- a/layout/base/nsPresContext.cpp
+++ b/layout/base/nsPresContext.cpp
@@ -997,17 +997,17 @@ nsPresContext::DetachShell()
   }
 }
 
 void
 nsPresContext::DoChangeCharSet(const nsCString& aCharSet)
 {
   UpdateCharSet(aCharSet);
   mDeviceContext->FlushFontCache();
-  RebuildAllStyleData(nsChangeHint::ReflowHints, nsRestyleHint(0));
+  RebuildAllStyleData(nsChangeHint::ReflowHints, nsRestyleHint::None);
 }
 
 void
 nsPresContext::UpdateCharSet(const nsCString& aCharSet)
 {
   if (mLangService) {
     mLanguage = mLangService->LookupCharSet(aCharSet);
     // this will be a language group (or script) code rather than a true language code
@@ -1302,17 +1302,17 @@ nsPresContext::SetFullZoom(float aZoom)
 }
 
 void
 nsPresContext::SetOverrideDPPX(float aDPPX)
 {
   mOverrideDPPX = aDPPX;
 
   if (HasCachedStyleData()) {
-    MediaFeatureValuesChanged(nsRestyleHint(0), nsChangeHint::None);
+    MediaFeatureValuesChanged(nsRestyleHint::None, nsChangeHint::None);
   }
 }
 
 gfxSize
 nsPresContext::ScreenSizeInchesForFontInflation(bool* aChanged)
 {
   if (aChanged) {
     *aChanged = false;
@@ -1683,17 +1683,17 @@ nsPresContext::SysColorChangedInternal()
   }
 
   // Reset default background and foreground colors for the document since
   // they may be using system colors
   GetDocumentColorPreferences();
 
   // The system color values are computed to colors in the style data,
   // so normal style data comparison is sufficient here.
-  RebuildAllStyleData(nsChangeHint::None, nsRestyleHint(0));
+  RebuildAllStyleData(nsChangeHint::None, nsRestyleHint::None);
 }
 
 void
 nsPresContext::UIResolutionChanged()
 {
   if (!mPendingUIResolutionChanged) {
     nsCOMPtr<nsIRunnable> ev =
       NewRunnableMethod(this, &nsPresContext::UIResolutionChangedInternal);
@@ -1779,26 +1779,26 @@ nsPresContext::EmulateMedium(const nsASt
   nsIAtom* previousMedium = Medium();
   mIsEmulatingMedia = true;
 
   nsAutoString mediaType;
   nsContentUtils::ASCIIToLower(aMediaType, mediaType);
 
   mMediaEmulated = NS_Atomize(mediaType);
   if (mMediaEmulated != previousMedium && mShell) {
-    MediaFeatureValuesChanged(nsRestyleHint(0), nsChangeHint::None);
+    MediaFeatureValuesChanged(nsRestyleHint::None, nsChangeHint::None);
   }
 }
 
 void nsPresContext::StopEmulatingMedium()
 {
   nsIAtom* previousMedium = Medium();
   mIsEmulatingMedia = false;
   if (Medium() != previousMedium) {
-    MediaFeatureValuesChanged(nsRestyleHint(0), nsChangeHint::None);
+    MediaFeatureValuesChanged(nsRestyleHint::None, nsChangeHint::None);
   }
 }
 
 void
 nsPresContext::RebuildAllStyleData(nsChangeHint aExtraHint,
                                    nsRestyleHint aRestyleHint)
 {
   if (!mShell) {
@@ -1955,17 +1955,17 @@ nsPresContext::PostMediaFeatureValuesCha
 }
 
 void
 nsPresContext::HandleMediaFeatureValuesChangedEvent()
 {
   // Null-check mShell in case the shell has been destroyed (and the
   // event is the only thing holding the pres context alive).
   if (mPendingMediaFeatureValuesChanged && mShell) {
-    MediaFeatureValuesChanged(nsRestyleHint(0));
+    MediaFeatureValuesChanged(nsRestyleHint::None);
   }
 }
 
 static bool
 NotifyTabSizeModeChanged(TabParent* aTab, void* aArg)
 {
   nsSizeMode* sizeMode = static_cast<nsSizeMode*>(aArg);
   aTab->SizeModeChanged(*sizeMode);
@@ -1974,17 +1974,17 @@ NotifyTabSizeModeChanged(TabParent* aTab
 
 void
 nsPresContext::SizeModeChanged(nsSizeMode aSizeMode)
 {
   if (HasCachedStyleData()) {
     nsContentUtils::CallOnAllRemoteChildren(mDocument->GetWindow(),
                                             NotifyTabSizeModeChanged,
                                             &aSizeMode);
-    MediaFeatureValuesChangedAllDocuments(nsRestyleHint(0));
+    MediaFeatureValuesChangedAllDocuments(nsRestyleHint::None);
   }
 }
 
 nsCompatibility
 nsPresContext::CompatibilityMode() const
 {
   return Document()->GetCompatibilityMode();
 }

--- a/layout/base/nsPresContext.h
+++ b/layout/base/nsPresContext.h
@@ -268,47 +268,47 @@ public:
   void PostRebuildAllStyleDataEvent(nsChangeHint aExtraHint,
                                     nsRestyleHint aRestyleHint);
 
   /**
    * Handle changes in the values of media features (used in media
    * queries).
    *
    * There are three sensible values to use for aRestyleHint:
-   *  * nsRestyleHint(0) to rebuild style data, with rerunning of
+   *  * nsRestyleHint::None to rebuild style data, with rerunning of
    *    selector matching, only if media features have changed
    *  * nsRestyleHint::ForceDescendants to force rebuilding of style data (but
    *    still only rerun selector matching if media query results have
    *    changed).  (RebuildAllStyleData always adds
    *    nsRestyleHint::ForceDescendants internally, so here we're only using
-   *    it to distinguish from nsRestyleHint(0) whether we need to call
+   *    it to distinguish from nsRestyleHint::None whether we need to call
    *    RebuildAllStyleData at all.)
    *  * nsRestyleHint::Subtree to force rebuilding of style data with
    *    rerunning of selector matching
    *
    * For aChangeHint, see RestyleManager::RebuildAllStyleData.  (Passing
    * a nonzero aChangeHint forces rebuilding style data even if
-   * nsRestyleHint(0) is passed.)
+   * nsRestyleHint::None is passed.)
    */
   void MediaFeatureValuesChanged(nsRestyleHint aRestyleHint,
                                  nsChangeHint aChangeHint = nsChangeHint::None);
   /**
    * Calls MediaFeatureValuesChanged for this pres context and all descendant
    * subdocuments that have a pres context. This should be used for media
    * features that must be updated in all subdocuments e.g. display-mode.
    */
   void MediaFeatureValuesChangedAllDocuments(nsRestyleHint aRestyleHint,
                                              nsChangeHint aChangeHint =
                                                nsChangeHint::None);
 
   void PostMediaFeatureValuesChangedEvent();
   void HandleMediaFeatureValuesChangedEvent();
   void FlushPendingMediaFeatureValuesChanged() {
     if (mPendingMediaFeatureValuesChanged)
-      MediaFeatureValuesChanged(nsRestyleHint(0));
+      MediaFeatureValuesChanged(nsRestyleHint::None);
   }
 
   /**
    * Updates the size mode on all remote children and recursively notifies this
    * document and all subdocuments (including remote children) that a media
    * feature value has changed.
    */
   void SizeModeChanged(nsSizeMode aSizeMode);

--- a/layout/style/SVGAttrAnimationRuleProcessor.cpp
+++ b/layout/style/SVGAttrAnimationRuleProcessor.cpp
@@ -41,37 +41,37 @@ SVGAttrAnimationRuleProcessor::ElementRu
     static_cast<nsSVGElement*>(aElement)->
       WalkAnimatedContentStyleRules(aRuleWalker);
   }
 }
 
 /* virtual */ nsRestyleHint
 SVGAttrAnimationRuleProcessor::HasStateDependentStyle(StateRuleProcessorData* aData)
 {
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 /* virtual */ nsRestyleHint
 SVGAttrAnimationRuleProcessor::HasStateDependentStyle(PseudoElementStateRuleProcessorData* aData)
 {
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 /* virtual */ bool
 SVGAttrAnimationRuleProcessor::HasDocumentStateDependentStyle(StateRuleProcessorData* aData)
 {
   return false;
 }
 
 /* virtual */ nsRestyleHint
 SVGAttrAnimationRuleProcessor::HasAttributeDependentStyle(
     AttributeRuleProcessorData* aData,
     RestyleHintData& aRestyleHintDataResult)
 {
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 /* virtual */ bool
 SVGAttrAnimationRuleProcessor::MediumFeaturesChanged(nsPresContext* aPresContext)
 {
   return false;
 }
 

--- a/layout/style/ServoStyleSet.cpp
+++ b/layout/style/ServoStyleSet.cpp
@@ -429,27 +429,27 @@ ServoStyleSet::ProbePseudoElementStyle(E
   return ProbePseudoElementStyle(aParentElement, aType, aParentContext);
 }
 
 nsRestyleHint
 ServoStyleSet::HasStateDependentStyle(dom::Element* aElement,
                                       EventStates aStateMask)
 {
   NS_WARNING("stylo: HasStateDependentStyle always returns zero!");
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 nsRestyleHint
 ServoStyleSet::HasStateDependentStyle(dom::Element* aElement,
                                       CSSPseudoElementType aPseudoType,
                                      dom::Element* aPseudoElement,
                                      EventStates aStateMask)
 {
   NS_WARNING("stylo: HasStateDependentStyle always returns zero!");
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 void
 ServoStyleSet::StyleDocument()
 {
   // Restyle the document from the root element and each of the document level
   // NAC subtree roots.
   DocumentStyleRootIterator iter(mPresContext->Document());

--- a/layout/style/nsCSSRuleProcessor.cpp
+++ b/layout/style/nsCSSRuleProcessor.cpp
@@ -2644,17 +2644,17 @@ nsCSSRuleProcessor::HasStateDependentSty
   // Look up the content node in the state rule list, which points to
   // any (CSS2 definition) simple selector (whether or not it is the
   // subject) that has a state pseudo-class on it.  This means that this
   // code will be matching selectors that aren't real selectors in any
   // stylesheet (e.g., if there is a selector "body > p:hover > a", then
   // "body > p:hover" will be in |cascade->mStateSelectors|).  Note that
   // |ComputeSelectorStateDependence| below determines which selectors are in
   // |cascade->mStateSelectors|.
-  nsRestyleHint hint = nsRestyleHint(0);
+  nsRestyleHint hint = nsRestyleHint::None;
   if (cascade) {
     StateSelector *iter = cascade->mStateSelectors.Elements(),
                   *end = iter + cascade->mStateSelectors.Length();
     NodeMatchContext nodeContext(aStateMask, false);
     for(; iter != end; ++iter) {
       nsCSSSelector* selector = iter->mSelector;
       EventStates states = iter->mStates;
 
@@ -2740,17 +2740,17 @@ nsCSSRuleProcessor::HasDocumentStateDepe
   RuleCascadeData* cascade = GetRuleCascade(aData->mPresContext);
 
   return cascade && cascade->mSelectorDocumentStates.HasAtLeastOneOfStates(aData->mStateMask);
 }
 
 struct AttributeEnumData {
   AttributeEnumData(AttributeRuleProcessorData *aData,
                     RestyleHintData& aRestyleHintData)
-    : data(aData), change(nsRestyleHint(0)), hintData(aRestyleHintData) {}
+    : data(aData), change(nsRestyleHint::None), hintData(aRestyleHintData) {}
 
   AttributeRuleProcessorData *data;
   nsRestyleHint change;
   RestyleHintData& hintData;
 };
 
 
 static inline nsRestyleHint

--- a/layout/style/nsHTMLCSSStyleSheet.cpp
+++ b/layout/style/nsHTMLCSSStyleSheet.cpp
@@ -126,23 +126,23 @@ nsHTMLCSSStyleSheet::RulesMatching(XULTr
 {
 }
 #endif
 
 // Test if style is dependent on content state
 /* virtual */ nsRestyleHint
 nsHTMLCSSStyleSheet::HasStateDependentStyle(StateRuleProcessorData* aData)
 {
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 /* virtual */ nsRestyleHint
 nsHTMLCSSStyleSheet::HasStateDependentStyle(PseudoElementStateRuleProcessorData* aData)
 {
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 /* virtual */ bool
 nsHTMLCSSStyleSheet::HasDocumentStateDependentStyle(StateRuleProcessorData* aData)
 {
   return false;
 }
 
@@ -153,17 +153,17 @@ nsHTMLCSSStyleSheet::HasAttributeDepende
     RestyleHintData& aRestyleHintDataResult)
 {
   // Perhaps should check that it's XUL, SVG, (or HTML) namespace, but
   // it doesn't really matter.
   if (aData->mAttrHasChanged && aData->mAttribute == nsGkAtoms::style) {
     return nsRestyleHint::StyleAttribute;
   }
 
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 /* virtual */ bool
 nsHTMLCSSStyleSheet::MediumFeaturesChanged(nsPresContext* aPresContext)
 {
   return false;
 }
 

--- a/layout/style/nsHTMLStyleSheet.cpp
+++ b/layout/style/nsHTMLStyleSheet.cpp
@@ -368,40 +368,40 @@ nsHTMLStyleSheet::HasStateDependentStyle
 {
   if (aData->mElement->IsHTMLElement(nsGkAtoms::a) &&
       nsCSSRuleProcessor::IsLink(aData->mElement) &&
       ((mActiveRule && aData->mStateMask.HasState(NS_EVENT_STATE_ACTIVE)) ||
        (mLinkRule && aData->mStateMask.HasState(NS_EVENT_STATE_VISITED)) ||
        (mVisitedRule && aData->mStateMask.HasState(NS_EVENT_STATE_VISITED)))) {
     return nsRestyleHint::Self;
   }
-  
-  return nsRestyleHint(0);
+
+  return nsRestyleHint::None;
 }
 
 /* virtual */ nsRestyleHint
 nsHTMLStyleSheet::HasStateDependentStyle(PseudoElementStateRuleProcessorData* aData)
 {
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 /* virtual */ bool
 nsHTMLStyleSheet::HasDocumentStateDependentStyle(StateRuleProcessorData* aData)
 {
   return false;
 }
 
 /* virtual */ nsRestyleHint
 nsHTMLStyleSheet::HasAttributeDependentStyle(
     AttributeRuleProcessorData* aData,
     RestyleHintData& aRestyleHintDataResult)
 {
   // Do nothing on before-change checks
   if (!aData->mAttrHasChanged) {
-    return nsRestyleHint(0);
+    return nsRestyleHint::None;
   }
 
   // Note: no need to worry about whether some states changed with this
   // attribute here, because we handle that under HasStateDependentStyle() as
   // needed.
 
   // Result is true for |href| changes on HTML links if we have link rules.
   Element *element = aData->mElement;
@@ -420,17 +420,17 @@ nsHTMLStyleSheet::HasAttributeDependentS
     // the cells in the table
     if (aData->mAttribute == nsGkAtoms::cellpadding &&
         element->IsHTMLElement(nsGkAtoms::table)) {
       return nsRestyleHint::Subtree;
     }
     return nsRestyleHint::Self;
   }
 
-  return nsRestyleHint(0);
+  return nsRestyleHint::None;
 }
 
 /* virtual */ bool
 nsHTMLStyleSheet::MediumFeaturesChanged(nsPresContext* aPresContext)
 {
   return false;
 }
 

--- a/layout/style/nsStyleSet.cpp
+++ b/layout/style/nsStyleSet.cpp
@@ -1470,33 +1470,33 @@ struct RuleNodeInfo {
 struct CascadeLevel {
   SheetType mLevel;
   bool mIsImportant;
   bool mCheckForImportantRules;
   nsRestyleHint mLevelReplacementHint;
 };
 
 static const CascadeLevel gCascadeLevels[] = {
-  { SheetType::Agent,            false, false, nsRestyleHint(0) },
-  { SheetType::User,             false, false, nsRestyleHint(0) },
-  { SheetType::PresHint,         false, false, nsRestyleHint(0) },
+  { SheetType::Agent,            false, false, nsRestyleHint::None },
+  { SheetType::User,             false, false, nsRestyleHint::None },
+  { SheetType::PresHint,         false, false, nsRestyleHint::None },
   { SheetType::SVGAttrAnimation, false, false, nsRestyleHint::SVGAttrAnimations },
-  { SheetType::Doc,              false, false, nsRestyleHint(0) },
-  { SheetType::ScopedDoc,        false, false, nsRestyleHint(0) },
+  { SheetType::Doc,              false, false, nsRestyleHint::None },
+  { SheetType::ScopedDoc,        false, false, nsRestyleHint::None },
   { SheetType::StyleAttr,        false, true,  nsRestyleHint::StyleAttribute |
                                                nsRestyleHint::StyleAttribute_Animations },
-  { SheetType::Override,         false, false, nsRestyleHint(0) },
+  { SheetType::Override,         false, false, nsRestyleHint::None },
   { SheetType::Animation,        false, false, nsRestyleHint::CSSAnimations },
-  { SheetType::ScopedDoc,        true,  false, nsRestyleHint(0) },
-  { SheetType::Doc,              true,  false, nsRestyleHint(0) },
+  { SheetType::ScopedDoc,        true,  false, nsRestyleHint::None },
+  { SheetType::Doc,              true,  false, nsRestyleHint::None },
   { SheetType::StyleAttr,        true,  false, nsRestyleHint::StyleAttribute |
                                                nsRestyleHint::StyleAttribute_Animations },
-  { SheetType::Override,         true,  false, nsRestyleHint(0) },
-  { SheetType::User,             true,  false, nsRestyleHint(0) },
-  { SheetType::Agent,            true,  false, nsRestyleHint(0) },
+  { SheetType::Override,         true,  false, nsRestyleHint::None },
+  { SheetType::User,             true,  false, nsRestyleHint::None },
+  { SheetType::Agent,            true,  false, nsRestyleHint::None },
   { SheetType::Transition,       false, false, nsRestyleHint::CSSTransitions },
 };
 
 nsRuleNode*
 nsStyleSet::RuleNodeWithReplacement(Element* aElement,
                                     Element* aPseudoElement,
                                     nsRuleNode* aOldRuleNode,
                                     CSSPseudoElementType aPseudoType,
@@ -2290,29 +2290,29 @@ nsStyleSet::ReparentStyleContext(nsStyle
                     aElement, flags);
 }
 
 struct MOZ_STACK_CLASS StatefulData : public StateRuleProcessorData {
   StatefulData(nsPresContext* aPresContext, Element* aElement,
                EventStates aStateMask, TreeMatchContext& aTreeMatchContext)
     : StateRuleProcessorData(aPresContext, aElement, aStateMask,
                              aTreeMatchContext),
-      mHint(nsRestyleHint(0))
+      mHint(nsRestyleHint::None)
   {}
   nsRestyleHint   mHint;
 };
 
 struct MOZ_STACK_CLASS StatefulPseudoElementData : public PseudoElementStateRuleProcessorData {
   StatefulPseudoElementData(nsPresContext* aPresContext, Element* aElement,
                EventStates aStateMask, CSSPseudoElementType aPseudoType,
                TreeMatchContext& aTreeMatchContext, Element* aPseudoElement)
     : PseudoElementStateRuleProcessorData(aPresContext, aElement, aStateMask,
                                           aPseudoType, aTreeMatchContext,
                                           aPseudoElement),
-      mHint(nsRestyleHint(0))
+      mHint(nsRestyleHint::None)
   {}
   nsRestyleHint   mHint;
 };
 
 static bool SheetHasDocumentStateStyle(nsIStyleRuleProcessor* aProcessor,
                                          void *aData)
 {
   StatefulData* data = (StatefulData*)aData;
@@ -2389,17 +2389,17 @@ nsStyleSet::HasStateDependentStyle(Eleme
 struct MOZ_STACK_CLASS AttributeData : public AttributeRuleProcessorData {
   AttributeData(nsPresContext* aPresContext, Element* aElement,
                 int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType,
                 bool aAttrHasChanged, const nsAttrValue* aOtherValue,
                 TreeMatchContext& aTreeMatchContext)
     : AttributeRuleProcessorData(aPresContext, aElement, aNameSpaceID,
                                  aAttribute, aModType, aAttrHasChanged,
                                  aOtherValue, aTreeMatchContext),
-      mHint(nsRestyleHint(0))
+      mHint(nsRestyleHint::None)
   {}
   nsRestyleHint mHint;
   RestyleHintData mHintData;
 };
 
 static bool
 SheetHasAttributeStyle(nsIStyleRuleProcessor* aProcessor, void *aData)
 {

--- a/layout/svg/SVGGeometryFrame.cpp
+++ b/layout/svg/SVGGeometryFrame.cpp
@@ -168,17 +168,17 @@ SVGGeometryFrame::AttributeChanged(int32
   // Also note that SVGTransformableElement::GetAttributeChangeHint will
   // return nsChangeHint_UpdateOverflow for "transform" attribute changes
   // and cause DoApplyRenderingChangeToTree to make the SchedulePaint call.
 
   if (aNameSpaceID == kNameSpaceID_None &&
       (static_cast<SVGGeometryElement*>
                   (mContent)->AttributeDefinesGeometry(aAttribute))) {
     nsLayoutUtils::PostRestyleEvent(
-      mContent->AsElement(), nsRestyleHint(0),
+      mContent->AsElement(), nsRestyleHint::None,
       nsChangeHint::InvalidateRenderingObservers);
     nsSVGUtils::ScheduleReflowSVG(this);
   }
   return NS_OK;
 }
 
 /* virtual */ void
 SVGGeometryFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)

--- a/layout/svg/SVGTextFrame.cpp
+++ b/layout/svg/SVGTextFrame.cpp
@@ -3257,17 +3257,17 @@ SVGTextFrame::ReflowSVGNonDisplayText()
   // time it is painted, we reflow the anonymous block frame.
   AddStateBits(NS_FRAME_IS_DIRTY);
 
   // We also need to call InvalidateRenderingObservers, so that if the <text>
   // element is within a <mask>, say, the element referencing the <mask> will
   // be updated, which will then cause this SVGTextFrame to be painted and
   // in doing so cause the anonymous block frame to be reflowed.
   nsLayoutUtils::PostRestyleEvent(
-    mContent->AsElement(), nsRestyleHint(0),
+    mContent->AsElement(), nsRestyleHint::None,
     nsChangeHint::InvalidateRenderingObservers);
 
   // Finally, we need to actually reflow the anonymous block frame and update
   // mPositions, in case we are being reflowed immediately after a DOM
   // mutation that needs frame reconstruction.
   MaybeReflowAnonymousBlockChild();
   UpdateGlyphPositioning();
 }
@@ -5227,17 +5227,17 @@ SVGTextFrame::ScheduleReflowSVG()
   }
 }
 
 void
 SVGTextFrame::NotifyGlyphMetricsChange()
 {
   AddStateBits(NS_STATE_SVG_POSITIONING_DIRTY);
   nsLayoutUtils::PostRestyleEvent(
-    mContent->AsElement(), nsRestyleHint(0),
+    mContent->AsElement(), nsRestyleHint::None,
     nsChangeHint::InvalidateRenderingObservers);
   ScheduleReflowSVG();
 }
 
 void
 SVGTextFrame::UpdateGlyphPositioning()
 {
   nsIFrame* kid = PrincipalChildList().FirstChild();

--- a/layout/svg/nsSVGContainerFrame.cpp
+++ b/layout/svg/nsSVGContainerFrame.cpp
@@ -202,17 +202,17 @@ nsSVGDisplayContainerFrame::RemoveFrame(
 {
   nsSVGEffects::InvalidateRenderingObservers(aOldFrame);
 
   // nsSVGContainerFrame::RemoveFrame doesn't call down into
   // nsContainerFrame::RemoveFrame, so it doesn't call FrameNeedsReflow. We
   // need to schedule a repaint and schedule an update to our overflow rects.
   SchedulePaint();
   PresContext()->RestyleManager()->PostRestyleEvent(
-    mContent->AsElement(), nsRestyleHint(0),
+    mContent->AsElement(), nsRestyleHint::None,
     nsChangeHint::UpdateOverflow);
 
   nsSVGContainerFrame::RemoveFrame(aListID, aOldFrame);
 
   if (!(GetStateBits() & (NS_FRAME_IS_NONDISPLAY | NS_STATE_IS_OUTER_SVG))) {
     nsSVGUtils::NotifyAncestorsOfFilterRegionChange(this);
   }
 }

--- a/layout/svg/nsSVGEffects.cpp
+++ b/layout/svg/nsSVGEffects.cpp
@@ -226,17 +226,17 @@ nsSVGRenderingObserverProperty::DoUpdate
 {
   nsSVGIDRenderingObserver::DoUpdate();
 
   nsIFrame* frame = mFrameReference.Get();
   if (frame && frame->IsFrameOfType(nsIFrame::eSVG)) {
     // Changes should propagate out to things that might be observing
     // the referencing frame or its ancestors.
     nsLayoutUtils::PostRestyleEvent(
-      frame->GetContent()->AsElement(), nsRestyleHint(0),
+      frame->GetContent()->AsElement(), nsRestyleHint::None,
       nsChangeHint::InvalidateRenderingObservers);
   }
 }
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsSVGFilterReference)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsSVGFilterReference)
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(nsSVGFilterReference)
@@ -353,17 +353,17 @@ nsSVGFilterProperty::DoUpdate()
     changeHint |= nsChangeHint::InvalidateRenderingObservers;
   }
 
   // Don't need to request UpdateOverflow if we're being reflowed.
   if (!(frame->GetStateBits() & NS_FRAME_IN_REFLOW)) {
     changeHint |= nsChangeHint::UpdateOverflow;
   }
   frame->PresContext()->RestyleManager()->PostRestyleEvent(
-    frame->GetContent()->AsElement(), nsRestyleHint(0), changeHint);
+    frame->GetContent()->AsElement(), nsRestyleHint::None, changeHint);
 }
 
 void
 nsSVGMarkerProperty::DoUpdate()
 {
   nsSVGRenderingObserverProperty::DoUpdate();
 
   nsIFrame* frame = mFrameReference.Get();
@@ -379,17 +379,17 @@ nsSVGMarkerProperty::DoUpdate()
   if (!(frame->GetStateBits() & NS_FRAME_IN_REFLOW)) {
     changeHint |= nsChangeHint::InvalidateRenderingObservers;
     // XXXjwatt: We need to unify SVG into standard reflow so we can just use
     // nsChangeHint_NeedReflow | nsChangeHint_NeedDirtyReflow here.
     // XXXSDL KILL THIS!!!
     nsSVGUtils::ScheduleReflowSVG(frame);
   }
   frame->PresContext()->RestyleManager()->PostRestyleEvent(
-    frame->GetContent()->AsElement(), nsRestyleHint(0), changeHint);
+    frame->GetContent()->AsElement(), nsRestyleHint::None, changeHint);
 }
 
 NS_IMPL_ISUPPORTS(nsSVGMaskProperty, nsISupports)
 
 nsSVGMaskProperty::nsSVGMaskProperty(nsIFrame* aFrame)
 {
   const nsStyleSVGReset *svgReset = aFrame->StyleSVGReset();
 
@@ -436,17 +436,17 @@ nsSVGTextPathProperty::DoUpdate()
     return;
   }
   mValid = nowValid;
 
   // Repaint asynchronously in case the path frame is being torn down
   nsChangeHint changeHint = nsChangeHint::RepaintFrame |
                             nsChangeHint::UpdateTextPath;
   frame->PresContext()->RestyleManager()->PostRestyleEvent(
-    frame->GetContent()->AsElement(), nsRestyleHint(0), changeHint);
+    frame->GetContent()->AsElement(), nsRestyleHint::None, changeHint);
 }
 
 static void
 InvalidateAllContinuations(nsIFrame* aFrame)
 {
   for (nsIFrame* f = aFrame; f;
        f = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(f)) {
     f->InvalidateFrame();
@@ -459,17 +459,17 @@ nsSVGPaintingProperty::DoUpdate()
   nsSVGRenderingObserverProperty::DoUpdate();
 
   nsIFrame* frame = mFrameReference.Get();
   if (!frame)
     return;
 
   if (frame->GetStateBits() & NS_FRAME_SVG_LAYOUT) {
     nsLayoutUtils::PostRestyleEvent(
-      frame->GetContent()->AsElement(), nsRestyleHint(0),
+      frame->GetContent()->AsElement(), nsRestyleHint::None,
       nsChangeHint::InvalidateRenderingObservers);
     frame->InvalidateFrameSubtree();
   } else {
     InvalidateAllContinuations(frame);
   }
 }
 
 static nsSVGFilterProperty*

--- a/layout/svg/nsSVGForeignObjectFrame.cpp
+++ b/layout/svg/nsSVGForeignObjectFrame.cpp
@@ -90,39 +90,39 @@ nsresult
 nsSVGForeignObjectFrame::AttributeChanged(int32_t  aNameSpaceID,
                                           nsIAtom *aAttribute,
                                           int32_t  aModType)
 {
   if (aNameSpaceID == kNameSpaceID_None) {
     if (aAttribute == nsGkAtoms::width ||
         aAttribute == nsGkAtoms::height) {
       nsLayoutUtils::PostRestyleEvent(
-        mContent->AsElement(), nsRestyleHint(0),
+        mContent->AsElement(), nsRestyleHint::None,
         nsChangeHint::InvalidateRenderingObservers);
       nsSVGUtils::ScheduleReflowSVG(this);
       // XXXjwatt: why mark intrinsic widths dirty? can't we just use eResize?
       RequestReflow(nsIPresShell::eStyleChange);
     } else if (aAttribute == nsGkAtoms::x ||
                aAttribute == nsGkAtoms::y) {
       // make sure our cached transform matrix gets (lazily) updated
       mCanvasTM = nullptr;
       nsLayoutUtils::PostRestyleEvent(
-        mContent->AsElement(), nsRestyleHint(0),
+        mContent->AsElement(), nsRestyleHint::None,
         nsChangeHint::InvalidateRenderingObservers);
       nsSVGUtils::ScheduleReflowSVG(this);
     } else if (aAttribute == nsGkAtoms::transform) {
       // We don't invalidate for transform changes (the layers code does that).
       // Also note that SVGTransformableElement::GetAttributeChangeHint will
       // return nsChangeHint_UpdateOverflow for "transform" attribute changes
       // and cause DoApplyRenderingChangeToTree to make the SchedulePaint call.
       mCanvasTM = nullptr;
     } else if (aAttribute == nsGkAtoms::viewBox ||
                aAttribute == nsGkAtoms::preserveAspectRatio) {
       nsLayoutUtils::PostRestyleEvent(
-        mContent->AsElement(), nsRestyleHint(0),
+        mContent->AsElement(), nsRestyleHint::None,
         nsChangeHint::InvalidateRenderingObservers);
     }
   }
 
   return NS_OK;
 }
 
 void

--- a/layout/svg/nsSVGImageFrame.cpp
+++ b/layout/svg/nsSVGImageFrame.cpp
@@ -206,17 +206,17 @@ nsSVGImageFrame::AttributeChanged(int32_
                                   int32_t         aModType)
 {
   if (aNameSpaceID == kNameSpaceID_None) {
     if (aAttribute == nsGkAtoms::x ||
         aAttribute == nsGkAtoms::y ||
         aAttribute == nsGkAtoms::width ||
         aAttribute == nsGkAtoms::height) {
       nsLayoutUtils::PostRestyleEvent(
-        mContent->AsElement(), nsRestyleHint(0),
+        mContent->AsElement(), nsRestyleHint::None,
         nsChangeHint::InvalidateRenderingObservers);
       nsSVGUtils::ScheduleReflowSVG(this);
       return NS_OK;
     }
     else if (aAttribute == nsGkAtoms::preserveAspectRatio) {
       // We don't paint the content of the image using display lists, therefore
       // we have to invalidate for this children-only transform changes since
       // there is no layer tree to notice that the transform changed and
@@ -633,35 +633,35 @@ NS_IMETHODIMP
 nsSVGImageListener::Notify(imgIRequest *aRequest, int32_t aType, const nsIntRect* aData)
 {
   if (!mFrame)
     return NS_ERROR_FAILURE;
 
   if (aType == imgINotificationObserver::LOAD_COMPLETE) {
     mFrame->InvalidateFrame();
     nsLayoutUtils::PostRestyleEvent(
-      mFrame->GetContent()->AsElement(), nsRestyleHint(0),
+      mFrame->GetContent()->AsElement(), nsRestyleHint::None,
       nsChangeHint::InvalidateRenderingObservers);
     nsSVGUtils::ScheduleReflowSVG(mFrame);
   }
 
   if (aType == imgINotificationObserver::FRAME_UPDATE) {
     // No new dimensions, so we don't need to call
     // nsSVGUtils::InvalidateAndScheduleBoundsUpdate.
     nsLayoutUtils::PostRestyleEvent(
-      mFrame->GetContent()->AsElement(), nsRestyleHint(0),
+      mFrame->GetContent()->AsElement(), nsRestyleHint::None,
       nsChangeHint::InvalidateRenderingObservers);
     mFrame->InvalidateFrame();
   }
 
   if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
     // Called once the resource's dimensions have been obtained.
     aRequest->GetImage(getter_AddRefs(mFrame->mImageContainer));
     mFrame->InvalidateFrame();
     nsLayoutUtils::PostRestyleEvent(
-      mFrame->GetContent()->AsElement(), nsRestyleHint(0),
+      mFrame->GetContent()->AsElement(), nsRestyleHint::None,
       nsChangeHint::InvalidateRenderingObservers);
     nsSVGUtils::ScheduleReflowSVG(mFrame);
   }
 
   return NS_OK;
 }
 

--- a/layout/svg/nsSVGInnerSVGFrame.cpp
+++ b/layout/svg/nsSVGInnerSVGFrame.cpp
@@ -193,17 +193,17 @@ nsSVGInnerSVGFrame::AttributeChanged(int
   if (aNameSpaceID == kNameSpaceID_None &&
       !(GetStateBits() & NS_FRAME_IS_NONDISPLAY)) {
 
     SVGSVGElement* content = static_cast<SVGSVGElement*>(mContent);
 
     if (aAttribute == nsGkAtoms::width ||
         aAttribute == nsGkAtoms::height) {
       nsLayoutUtils::PostRestyleEvent(
-        mContent->AsElement(), nsRestyleHint(0),
+        mContent->AsElement(), nsRestyleHint::None,
         nsChangeHint::InvalidateRenderingObservers);
       nsSVGUtils::ScheduleReflowSVG(this);
 
       if (content->HasViewBoxOrSyntheticViewBox()) {
         // make sure our cached transform matrix gets (lazily) updated
         mCanvasTM = nullptr;
         content->ChildrenOnlyTransformChanged();
         nsSVGUtils::NotifyChildrenOfSVGChange(this, TRANSFORM_CHANGED);
@@ -230,17 +230,17 @@ nsSVGInnerSVGFrame::AttributeChanged(int
 
       // We don't invalidate for transform changes (the layers code does that).
       // Also note that SVGTransformableElement::GetAttributeChangeHint will
       // return nsChangeHint_UpdateOverflow for "transform" attribute changes
       // and cause DoApplyRenderingChangeToTree to make the SchedulePaint call.
 
       if (aAttribute == nsGkAtoms::x || aAttribute == nsGkAtoms::y) {
         nsLayoutUtils::PostRestyleEvent(
-          mContent->AsElement(), nsRestyleHint(0),
+          mContent->AsElement(), nsRestyleHint::None,
           nsChangeHint::InvalidateRenderingObservers);
         nsSVGUtils::ScheduleReflowSVG(this);
       } else if (aAttribute == nsGkAtoms::viewBox ||
                  (aAttribute == nsGkAtoms::preserveAspectRatio &&
                   content->HasViewBoxOrSyntheticViewBox())) {
         content->ChildrenOnlyTransformChanged();
         // SchedulePaint sets a global state flag so we only need to call it once
         // (on ourself is fine), not once on each child (despite bug 828240).

--- a/layout/svg/nsSVGUseFrame.cpp
+++ b/layout/svg/nsSVGUseFrame.cpp
@@ -116,46 +116,46 @@ nsSVGUseFrame::AttributeChanged(int32_t 
 {
   SVGUseElement *useElement = static_cast<SVGUseElement*>(mContent);
 
   if (aNameSpaceID == kNameSpaceID_None) {
     if (aAttribute == nsGkAtoms::x || aAttribute == nsGkAtoms::y) {
       // make sure our cached transform matrix gets (lazily) updated
       mCanvasTM = nullptr;
       nsLayoutUtils::PostRestyleEvent(
-        useElement, nsRestyleHint(0),
+        useElement, nsRestyleHint::None,
         nsChangeHint::InvalidateRenderingObservers);
       nsSVGUtils::ScheduleReflowSVG(this);
       nsSVGUtils::NotifyChildrenOfSVGChange(this, TRANSFORM_CHANGED);
     } else if (aAttribute == nsGkAtoms::width ||
                aAttribute == nsGkAtoms::height) {
       bool invalidate = false;
       if (mHasValidDimensions != useElement->HasValidDimensions()) {
         mHasValidDimensions = !mHasValidDimensions;
         invalidate = true;
       }
       if (useElement->OurWidthAndHeightAreUsed()) {
         invalidate = true;
         useElement->SyncWidthOrHeight(aAttribute);
       }
       if (invalidate) {
         nsLayoutUtils::PostRestyleEvent(
-          useElement, nsRestyleHint(0),
+          useElement, nsRestyleHint::None,
           nsChangeHint::InvalidateRenderingObservers);
         nsSVGUtils::ScheduleReflowSVG(this);
       }
     }
   }
 
   if ((aNameSpaceID == kNameSpaceID_XLink ||
        aNameSpaceID == kNameSpaceID_None) &&
       aAttribute == nsGkAtoms::href) {
     // we're changing our nature, clear out the clone information
     nsLayoutUtils::PostRestyleEvent(
-      useElement, nsRestyleHint(0),
+      useElement, nsRestyleHint::None,
       nsChangeHint::InvalidateRenderingObservers);
     nsSVGUtils::ScheduleReflowSVG(this);
     useElement->mOriginal = nullptr;
     useElement->UnlinkSource();
     useElement->TriggerReclone();
   }
 
   return nsSVGGFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
@@ -234,17 +234,17 @@ nsSVGUseFrame::NotifySVGChanged(uint32_t
 
 nsresult
 nsSVGUseFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)
 {
   SVGUseElement *use = static_cast<SVGUseElement*>(mContent);
 
   nsIContent* clone = use->CreateAnonymousContent();
   nsLayoutUtils::PostRestyleEvent(
-    use, nsRestyleHint(0),
+    use, nsRestyleHint::None,
     nsChangeHint::InvalidateRenderingObservers);
   if (!clone)
     return NS_ERROR_FAILURE;
   if (!aElements.AppendElement(clone))
     return NS_ERROR_OUT_OF_MEMORY;
   return NS_OK;
 }