Bug 1523969 part 14 - Move method definition inline comments to new line in 'layout/'. r=dholbert
authorRyan Hunt <rhunt@eqrion.net>
Mon, 25 Feb 2019 16:09:24 -0600
changeset 461895 e0fb4657355d4d8052bff3f1e8baac265b5efef7
parent 461894 f99b937e9e7ce91e7d648a37251d4af8d1d6da68
child 461896 e338646fe5515d51f46b856b5815ff9dd5af7baa
push id35631
push userrgurzau@mozilla.com
push dateFri, 01 Mar 2019 13:06:03 +0000
treeherdermozilla-central@d4e19870e27f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdholbert
bugs1523969
milestone67.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 1523969 part 14 - Move method definition inline comments to new line in 'layout/'. r=dholbert Differential Revision: https://phabricator.services.mozilla.com/D21115
layout/base/AccessibleCaret.cpp
layout/base/AccessibleCaretEventHub.cpp
layout/base/PresShell.cpp
layout/base/RestyleManager.cpp
layout/base/ShapeUtils.cpp
layout/base/TouchManager.cpp
layout/base/nsBidiPresUtils.cpp
layout/base/nsCaret.cpp
layout/base/nsDocumentViewer.cpp
layout/base/nsGenConList.cpp
layout/base/nsLayoutUtils.cpp
layout/base/nsPresContext.cpp
layout/base/nsRefreshDriver.cpp
layout/build/nsContentDLF.cpp
layout/forms/nsCheckboxRadioFrame.cpp
layout/forms/nsNumberControlFrame.cpp
layout/generic/BRFrame.cpp
layout/generic/ColumnSetWrapperFrame.cpp
layout/generic/ReflowInput.cpp
layout/generic/RubyUtils.cpp
layout/generic/TextOverflow.cpp
layout/generic/ViewportFrame.cpp
layout/generic/nsBackdropFrame.cpp
layout/generic/nsBlockFrame.cpp
layout/generic/nsBulletFrame.cpp
layout/generic/nsCanvasFrame.cpp
layout/generic/nsColumnSetFrame.cpp
layout/generic/nsContainerFrame.cpp
layout/generic/nsFirstLetterFrame.cpp
layout/generic/nsFlexContainerFrame.cpp
layout/generic/nsFloatManager.cpp
layout/generic/nsFontInflationData.cpp
layout/generic/nsFrame.cpp
layout/generic/nsFrameList.cpp
layout/generic/nsGfxScrollFrame.cpp
layout/generic/nsHTMLCanvasFrame.cpp
layout/generic/nsImageFrame.cpp
layout/generic/nsInlineFrame.cpp
layout/generic/nsLeafFrame.cpp
layout/generic/nsLineBox.cpp
layout/generic/nsLineLayout.cpp
layout/generic/nsPlaceholderFrame.cpp
layout/generic/nsPluginFrame.cpp
layout/generic/nsRubyBaseContainerFrame.cpp
layout/generic/nsRubyContentFrame.cpp
layout/generic/nsRubyFrame.cpp
layout/generic/nsRubyTextContainerFrame.cpp
layout/generic/nsRubyTextFrame.cpp
layout/generic/nsSubDocumentFrame.cpp
layout/generic/nsTextFrame.cpp
layout/generic/nsTextFrameUtils.cpp
layout/inspector/InspectorUtils.cpp
layout/ipc/VsyncParent.cpp
layout/mathml/nsMathMLContainerFrame.cpp
layout/mathml/nsMathMLFrame.cpp
layout/mathml/nsMathMLOperators.cpp
layout/mathml/nsMathMLSelectedFrame.cpp
layout/mathml/nsMathMLTokenFrame.cpp
layout/mathml/nsMathMLmencloseFrame.cpp
layout/mathml/nsMathMLmfencedFrame.cpp
layout/mathml/nsMathMLmfracFrame.cpp
layout/mathml/nsMathMLmmultiscriptsFrame.cpp
layout/mathml/nsMathMLmoFrame.cpp
layout/mathml/nsMathMLmpaddedFrame.cpp
layout/mathml/nsMathMLmrootFrame.cpp
layout/mathml/nsMathMLmrowFrame.cpp
layout/mathml/nsMathMLmspaceFrame.cpp
layout/mathml/nsMathMLmtableFrame.cpp
layout/mathml/nsMathMLmunderoverFrame.cpp
layout/painting/ActiveLayerTracker.cpp
layout/painting/DisplayItemClipChain.cpp
layout/painting/FrameLayerBuilder.cpp
layout/painting/nsCSSRendering.cpp
layout/painting/nsCSSRenderingBorders.cpp
layout/painting/nsDisplayList.cpp
layout/painting/nsImageRenderer.cpp
layout/style/BindingStyleRule.cpp
layout/style/CSS.cpp
layout/style/CSSCounterStyleRule.cpp
layout/style/CSSFontFaceRule.cpp
layout/style/CSSFontFeatureValuesRule.cpp
layout/style/CSSImportRule.cpp
layout/style/CSSKeyframeRule.cpp
layout/style/CSSKeyframesRule.cpp
layout/style/CSSMediaRule.cpp
layout/style/CSSMozDocumentRule.cpp
layout/style/CSSRuleList.cpp
layout/style/CSSSupportsRule.cpp
layout/style/ComputedStyle.cpp
layout/style/CounterStyleManager.cpp
layout/style/DeclarationBlock.cpp
layout/style/ErrorReporter.cpp
layout/style/FontFace.cpp
layout/style/FontFaceSet.cpp
layout/style/GroupRule.cpp
layout/style/ImageLoader.cpp
layout/style/LayerAnimationInfo.cpp
layout/style/MediaList.cpp
layout/style/PreloadedStyleSheet.cpp
layout/style/Rule.cpp
layout/style/ServoCSSParser.cpp
layout/style/ServoStyleSet.cpp
layout/style/StyleAnimationValue.cpp
layout/style/StyleSheet.cpp
layout/style/URLExtraData.cpp
layout/style/nsCSSAnonBoxes.cpp
layout/style/nsCSSProps.cpp
layout/style/nsCSSPseudoElements.cpp
layout/style/nsCSSValue.cpp
layout/style/nsComputedDOMStyle.cpp
layout/style/nsDOMCSSDeclaration.cpp
layout/style/nsFontFaceLoader.cpp
layout/style/nsFontFaceUtils.cpp
layout/style/nsLayoutStylesheetCache.cpp
layout/style/nsMediaFeatures.cpp
layout/style/nsStyleUtil.cpp
layout/style/nsTransitionManager.cpp
layout/svg/SVGContextPaint.cpp
layout/svg/SVGFEImageFrame.cpp
layout/svg/SVGGeometryFrame.cpp
layout/svg/SVGImageContext.cpp
layout/svg/SVGTextFrame.cpp
layout/svg/nsCSSClipPathInstance.cpp
layout/svg/nsSVGContainerFrame.cpp
layout/svg/nsSVGImageFrame.cpp
layout/svg/nsSVGIntegrationUtils.cpp
layout/svg/nsSVGOuterSVGFrame.cpp
layout/svg/nsSVGUtils.cpp
layout/tables/BasicTableLayoutStrategy.cpp
layout/tables/FixedTableLayoutStrategy.cpp
layout/tables/SpanningCellSorter.cpp
layout/tables/nsTableCellFrame.cpp
layout/tables/nsTableColFrame.cpp
layout/tables/nsTableColGroupFrame.cpp
layout/tables/nsTableFrame.cpp
layout/tables/nsTableRowFrame.cpp
layout/tables/nsTableRowGroupFrame.cpp
layout/tables/nsTableWrapperFrame.cpp
layout/xul/nsBox.cpp
layout/xul/nsBoxFrame.cpp
layout/xul/nsImageBoxFrame.cpp
layout/xul/nsLeafBoxFrame.cpp
layout/xul/nsMenuBarFrame.cpp
layout/xul/nsMenuPopupFrame.cpp
layout/xul/nsRepeatService.cpp
layout/xul/nsResizerFrame.cpp
layout/xul/nsSprocketLayout.cpp
layout/xul/nsStackLayout.cpp
layout/xul/nsTextBoxFrame.cpp
layout/xul/tree/nsTreeBodyFrame.cpp
layout/xul/tree/nsTreeColumns.cpp
--- a/layout/base/AccessibleCaret.cpp
+++ b/layout/base/AccessibleCaret.cpp
@@ -101,18 +101,18 @@ void AccessibleCaret::SetAppearance(Appe
 
   // Need to reset rect since the cached rect will be compared in SetPosition.
   if (mAppearance == Appearance::None) {
     mImaginaryCaretRect = nsRect();
     mZoomLevel = 0.0f;
   }
 }
 
-/* static */ nsAutoString AccessibleCaret::AppearanceString(
-    Appearance aAppearance) {
+/* static */
+nsAutoString AccessibleCaret::AppearanceString(Appearance aAppearance) {
   nsAutoString string;
   switch (aAppearance) {
     case Appearance::None:
     case Appearance::NormalNotShown:
       string = NS_LITERAL_STRING("none");
       break;
     case Appearance::Normal:
       string = NS_LITERAL_STRING("normal");
--- a/layout/base/AccessibleCaretEventHub.cpp
+++ b/layout/base/AccessibleCaretEventHub.cpp
@@ -571,18 +571,19 @@ void AccessibleCaretEventHub::LaunchLong
 void AccessibleCaretEventHub::CancelLongTapInjector() {
   if (!mLongTapInjectorTimer) {
     return;
   }
 
   mLongTapInjectorTimer->Cancel();
 }
 
-/* static */ void AccessibleCaretEventHub::FireLongTap(
-    nsITimer* aTimer, void* aAccessibleCaretEventHub) {
+/* static */
+void AccessibleCaretEventHub::FireLongTap(nsITimer* aTimer,
+                                          void* aAccessibleCaretEventHub) {
   RefPtr<AccessibleCaretEventHub> self =
       static_cast<AccessibleCaretEventHub*>(aAccessibleCaretEventHub);
   self->mState->OnLongTap(self, self->mPressPoint);
 }
 
 NS_IMETHODIMP
 AccessibleCaretEventHub::Reflow(DOMHighResTimeStamp aStart,
                                 DOMHighResTimeStamp aEnd) {
--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -744,17 +744,18 @@ already_AddRefed<nsFrameSelection> nsIPr
   return ret.forget();
 }
 
 //----------------------------------------------------------------------
 
 static bool sSynthMouseMove = true;
 static uint32_t sNextPresShellId;
 
-/* static */ bool PresShell::AccessibleCaretEnabled(nsIDocShell* aDocShell) {
+/* static */
+bool PresShell::AccessibleCaretEnabled(nsIDocShell* aDocShell) {
   // If the pref forces it on, then enable it.
   if (StaticPrefs::layout_accessiblecaret_enabled()) {
     return true;
   }
   // If the touch pref is on, and touch events are enabled (this depends
   // on the specific device running), then enable it.
   if (StaticPrefs::layout_accessiblecaret_enabled_on_touch() &&
       dom::TouchEvent::PrefEnabled(aDocShell)) {
@@ -5445,17 +5446,18 @@ void PresShell::ProcessSynthMouseMoveEve
     shell->DispatchSynthMouseMove(&event);
   }
 
   if (!aFromScroll) {
     mSynthMouseMoveEvent.Forget();
   }
 }
 
-/* static */ void PresShell::MarkFramesInListApproximatelyVisible(
+/* static */
+void PresShell::MarkFramesInListApproximatelyVisible(
     const nsDisplayList& aList) {
   for (nsDisplayItem* item = aList.GetBottom(); item; item = item->GetAbove()) {
     nsDisplayList* sublist = item->GetChildren();
     if (sublist) {
       MarkFramesInListApproximatelyVisible(*sublist);
       continue;
     }
 
@@ -5472,17 +5474,18 @@ void PresShell::ProcessSynthMouseMoveEve
     if (presShell->mApproximatelyVisibleFrames.EnsureInserted(frame)) {
       // The frame was added to mApproximatelyVisibleFrames, so increment its
       // visible count.
       frame->IncApproximateVisibleCount();
     }
   }
 }
 
-/* static */ void PresShell::DecApproximateVisibleCount(
+/* static */
+void PresShell::DecApproximateVisibleCount(
     VisibleFrames& aFrames, const Maybe<OnNonvisible>& aNonvisibleAction
     /* = Nothing() */) {
   for (auto iter = aFrames.Iter(); !iter.Done(); iter.Next()) {
     nsIFrame* frame = iter.Get()->GetKey();
     // Decrement the frame's visible count if we're still tracking its
     // visibility. (We may not be, if the frame disabled visibility tracking
     // after we added it to the visible frames list.)
     if (frame->TrackingVisibility()) {
@@ -5501,18 +5504,19 @@ void PresShell::RebuildApproximateFrameV
   VisibleFrames oldApproximatelyVisibleFrames;
   mApproximatelyVisibleFrames.SwapElements(oldApproximatelyVisibleFrames);
 
   MarkFramesInListApproximatelyVisible(aList);
 
   DecApproximateVisibleCount(oldApproximatelyVisibleFrames);
 }
 
-/* static */ void PresShell::ClearApproximateFrameVisibilityVisited(
-    nsView* aView, bool aClear) {
+/* static */
+void PresShell::ClearApproximateFrameVisibilityVisited(nsView* aView,
+                                                       bool aClear) {
   nsViewManager* vm = aView->GetViewManager();
   if (aClear) {
     PresShell* presShell = static_cast<PresShell*>(vm->GetPresShell());
     if (!presShell->mApproximateFrameVisibilityVisited) {
       presShell->ClearApproximatelyVisibleFramesList();
     }
     presShell->mApproximateFrameVisibilityVisited = false;
   }
@@ -6371,33 +6375,34 @@ bool PresShell::CanDispatchEvent(const W
   bool rv =
       mPresContext && !mHaveShutDown && nsContentUtils::IsSafeToRunScript();
   if (aEvent) {
     rv &= (aEvent && aEvent->mWidget && !aEvent->mWidget->Destroyed());
   }
   return rv;
 }
 
-/* static */ PresShell* PresShell::GetShellForEventTarget(
-    nsIFrame* aFrame, nsIContent* aContent) {
+/* static */
+PresShell* PresShell::GetShellForEventTarget(nsIFrame* aFrame,
+                                             nsIContent* aContent) {
   if (aFrame) {
     return static_cast<PresShell*>(aFrame->PresShell());
   }
   if (aContent) {
     Document* doc = aContent->GetComposedDoc();
     if (!doc) {
       return nullptr;
     }
     return static_cast<PresShell*>(doc->GetShell());
   }
   return nullptr;
 }
 
-/* static */ PresShell* PresShell::GetShellForTouchEvent(
-    WidgetGUIEvent* aEvent) {
+/* static */
+PresShell* PresShell::GetShellForTouchEvent(WidgetGUIEvent* aEvent) {
   PresShell* shell = nullptr;
   switch (aEvent->mMessage) {
     case eTouchMove:
     case eTouchCancel:
     case eTouchEnd: {
       // get the correct shell to dispatch to
       WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
       for (dom::Touch* touch : touchEvent->mTouches) {
@@ -9340,27 +9345,28 @@ bool nsIPresShell::AddRefreshObserver(ns
 
 bool nsIPresShell::RemoveRefreshObserver(nsARefreshObserver* aObserver,
                                          FlushType aFlushType) {
   nsPresContext* presContext = GetPresContext();
   return presContext && presContext->RefreshDriver()->RemoveRefreshObserver(
                             aObserver, aFlushType);
 }
 
-/* virtual */ bool nsIPresShell::AddPostRefreshObserver(
-    nsAPostRefreshObserver* aObserver) {
+/* virtual */
+bool nsIPresShell::AddPostRefreshObserver(nsAPostRefreshObserver* aObserver) {
   nsPresContext* presContext = GetPresContext();
   if (!presContext) {
     return false;
   }
   presContext->RefreshDriver()->AddPostRefreshObserver(aObserver);
   return true;
 }
 
-/* virtual */ bool nsIPresShell::RemovePostRefreshObserver(
+/* virtual */
+bool nsIPresShell::RemovePostRefreshObserver(
     nsAPostRefreshObserver* aObserver) {
   nsPresContext* presContext = GetPresContext();
   if (!presContext) {
     return false;
   }
   presContext->RefreshDriver()->RemovePostRefreshObserver(aObserver);
   return true;
 }
--- a/layout/base/RestyleManager.cpp
+++ b/layout/base/RestyleManager.cpp
@@ -510,18 +510,18 @@ void RestyleManager::ContentStateChanged
   if (aStateMask.HasState(NS_EVENT_STATE_VISITED)) {
     // Exposing information to the page about whether the link is
     // visited or not isn't really something we can worry about here.
     // FIXME: We could probably do this a bit better.
     *aOutChangeHint |= nsChangeHint_RepaintFrame;
   }
 }
 
-/* static */ nsCString RestyleManager::RestyleHintToString(
-    nsRestyleHint aHint) {
+/* static */
+nsCString RestyleManager::RestyleHintToString(nsRestyleHint aHint) {
   nsCString result;
   bool any = false;
   const char* names[] = {"Self",           "SomeDescendants",
                          "Subtree",        "LaterSiblings",
                          "CSSTransitions", "CSSAnimations",
                          "StyleAttribute", "StyleAttribute_Animations",
                          "Force",          "ForceDescendants"};
   uint32_t hint = aHint & ((1 << ArrayLength(names)) - 1);
@@ -544,17 +544,18 @@ void RestyleManager::ContentStateChanged
     if (!any) {
       result.AppendLiteral("0");
     }
   }
   return result;
 }
 
 #ifdef DEBUG
-/* static */ nsCString RestyleManager::ChangeHintToString(nsChangeHint aHint) {
+/* static */
+nsCString RestyleManager::ChangeHintToString(nsChangeHint aHint) {
   nsCString result;
   bool any = false;
   const char* names[] = {"RepaintFrame",
                          "NeedReflow",
                          "ClearAncestorIntrinsics",
                          "ClearDescendantIntrinsics",
                          "NeedDirtyReflow",
                          "SyncFrameView",
@@ -1854,32 +1855,33 @@ void RestyleManager::ProcessRestyledFram
         frame->UpdateVisibleDescendantsState();
       }
     }
   }
 
   aChangeList.Clear();
 }
 
-/* static */ uint64_t RestyleManager::GetAnimationGenerationForFrame(
-    nsIFrame* aFrame) {
+/* static */
+uint64_t RestyleManager::GetAnimationGenerationForFrame(nsIFrame* aFrame) {
   EffectSet* effectSet = EffectSet::GetEffectSet(aFrame);
   return effectSet ? effectSet->GetAnimationGeneration() : 0;
 }
 
 void RestyleManager::IncrementAnimationGeneration() {
   // We update the animation generation at start of each call to
   // ProcessPendingRestyles so we should ignore any subsequent (redundant)
   // calls that occur while we are still processing restyles.
   if (!mInStyleRefresh) {
     ++mAnimationGeneration;
   }
 }
 
-/* static */ void RestyleManager::AddLayerChangesForAnimation(
+/* static */
+void RestyleManager::AddLayerChangesForAnimation(
     nsIFrame* aFrame, nsIContent* aContent, nsChangeHint aHintForThisFrame,
     nsStyleChangeList& aChangeListToProcess) {
   if (!aFrame || !aContent) {
     return;
   }
 
   uint64_t frameGeneration =
       RestyleManager::GetAnimationGenerationForFrame(aFrame);
@@ -2372,18 +2374,19 @@ void RestyleManager::PostRebuildAllStyle
     PostRestyleEvent(root, aRestyleHint, aExtraHint);
   }
 
   // TODO(emilio, bz): Extensions can add/remove stylesheets that can affect
   // non-inheriting anon boxes. It's not clear if we want to support that, but
   // if we do, we need to re-selector-match them here.
 }
 
-/* static */ void RestyleManager::ClearServoDataFromSubtree(
-    Element* aElement, IncludeRoot aIncludeRoot) {
+/* static */
+void RestyleManager::ClearServoDataFromSubtree(Element* aElement,
+                                               IncludeRoot aIncludeRoot) {
   if (aElement->HasServoData()) {
     StyleChildrenIterator it(aElement);
     for (nsIContent* n = it.GetNextChild(); n; n = it.GetNextChild()) {
       if (n->IsElement()) {
         ClearServoDataFromSubtree(n->AsElement(), IncludeRoot::Yes);
       }
     }
   }
@@ -2391,18 +2394,18 @@ void RestyleManager::PostRebuildAllStyle
   if (MOZ_LIKELY(aIncludeRoot == IncludeRoot::Yes)) {
     aElement->ClearServoData();
     MOZ_ASSERT(!aElement->HasAnyOfFlags(Element::kAllServoDescendantBits |
                                         NODE_NEEDS_FRAME));
     MOZ_ASSERT(aElement != aElement->OwnerDoc()->GetServoRestyleRoot());
   }
 }
 
-/* static */ void RestyleManager::ClearRestyleStateFromSubtree(
-    Element* aElement) {
+/* static */
+void RestyleManager::ClearRestyleStateFromSubtree(Element* aElement) {
   if (aElement->HasAnyOfFlags(Element::kAllServoDescendantBits)) {
     StyleChildrenIterator it(aElement);
     for (nsIContent* n = it.GetNextChild(); n; n = it.GetNextChild()) {
       if (n->IsElement()) {
         ClearRestyleStateFromSubtree(n->AsElement());
       }
     }
   }
--- a/layout/base/ShapeUtils.cpp
+++ b/layout/base/ShapeUtils.cpp
@@ -99,18 +99,19 @@ nsSize ShapeUtils::ComputeEllipseRadii(c
         ComputeShapeRadius(radiusY, aCenter.y, aRefBox.y, aRefBox.YMost());
   } else {
     radii.height = coords[1].ComputeCoordPercentCalc(aRefBox.height);
   }
 
   return radii;
 }
 
-/* static */ nsRect ShapeUtils::ComputeInsetRect(
-    const StyleBasicShape& aBasicShape, const nsRect& aRefBox) {
+/* static */
+nsRect ShapeUtils::ComputeInsetRect(const StyleBasicShape& aBasicShape,
+                                    const nsRect& aRefBox) {
   MOZ_ASSERT(aBasicShape.GetShapeType() == StyleBasicShapeType::Inset,
              "The basic shape must be inset()!");
 
   const nsTArray<nsStyleCoord>& coords = aBasicShape.Coordinates();
   MOZ_ASSERT(coords.Length() == 4, "wrong number of arguments");
 
   nsMargin inset(coords[0].ComputeCoordPercentCalc(aRefBox.Height()),
                  coords[1].ComputeCoordPercentCalc(aRefBox.Width()),
@@ -132,25 +133,27 @@ nsSize ShapeUtils::ComputeEllipseRadii(c
   if (height < 0) {
     height *= -1;
     y -= height;
   }
 
   return nsRect(x, y, width, height);
 }
 
-/* static */ bool ShapeUtils::ComputeInsetRadii(
-    const StyleBasicShape& aBasicShape, const nsRect& aInsetRect,
-    const nsRect& aRefBox, nscoord aRadii[8]) {
+/* static */
+bool ShapeUtils::ComputeInsetRadii(const StyleBasicShape& aBasicShape,
+                                   const nsRect& aInsetRect,
+                                   const nsRect& aRefBox, nscoord aRadii[8]) {
   const auto& radius = aBasicShape.GetRadius();
   return nsIFrame::ComputeBorderRadii(radius, aInsetRect.Size(), aRefBox.Size(),
                                       Sides(), aRadii);
 }
 
-/* static */ nsTArray<nsPoint> ShapeUtils::ComputePolygonVertices(
+/* static */
+nsTArray<nsPoint> ShapeUtils::ComputePolygonVertices(
     const StyleBasicShape& aBasicShape, const nsRect& aRefBox) {
   MOZ_ASSERT(aBasicShape.GetShapeType() == StyleBasicShapeType::Polygon,
              "The basic shape must be polygon()!");
 
   const nsTArray<nsStyleCoord>& coords = aBasicShape.Coordinates();
   MOZ_ASSERT(coords.Length() % 2 == 0 && coords.Length() >= 2,
              "Wrong number of arguments!");
 
--- a/layout/base/TouchManager.cpp
+++ b/layout/base/TouchManager.cpp
@@ -16,23 +16,25 @@
 
 using namespace mozilla::dom;
 
 namespace mozilla {
 
 nsDataHashtable<nsUint32HashKey, TouchManager::TouchInfo>*
     TouchManager::sCaptureTouchList;
 
-/*static*/ void TouchManager::InitializeStatics() {
+/*static*/
+void TouchManager::InitializeStatics() {
   NS_ASSERTION(!sCaptureTouchList, "InitializeStatics called multiple times!");
   sCaptureTouchList =
       new nsDataHashtable<nsUint32HashKey, TouchManager::TouchInfo>;
 }
 
-/*static*/ void TouchManager::ReleaseStatics() {
+/*static*/
+void TouchManager::ReleaseStatics() {
   NS_ASSERTION(sCaptureTouchList, "ReleaseStatics called without Initialize!");
   delete sCaptureTouchList;
   sCaptureTouchList = nullptr;
 }
 
 void TouchManager::Init(PresShell* aPresShell, Document* aDocument) {
   mPresShell = aPresShell;
   mDocument = aDocument;
@@ -47,18 +49,19 @@ void TouchManager::Destroy() {
 static nsIContent* GetNonAnonymousAncestor(EventTarget* aTarget) {
   nsCOMPtr<nsIContent> content(do_QueryInterface(aTarget));
   if (content && content->IsInNativeAnonymousSubtree()) {
     content = content->FindFirstNonChromeOnlyAccessContent();
   }
   return content;
 }
 
-/*static*/ void TouchManager::EvictTouchPoint(RefPtr<Touch>& aTouch,
-                                              Document* aLimitToDocument) {
+/*static*/
+void TouchManager::EvictTouchPoint(RefPtr<Touch>& aTouch,
+                                   Document* aLimitToDocument) {
   nsCOMPtr<nsINode> node(do_QueryInterface(aTouch->mOriginalTarget));
   if (node) {
     Document* doc = node->GetComposedDoc();
     if (doc && (!aLimitToDocument || aLimitToDocument == doc)) {
       nsIPresShell* presShell = doc->GetShell();
       if (presShell) {
         nsIFrame* frame = presShell->GetRootFrame();
         if (frame) {
@@ -75,35 +78,36 @@ static nsIContent* GetNonAnonymousAncest
       }
     }
   }
   if (!node || !aLimitToDocument || node->OwnerDoc() == aLimitToDocument) {
     sCaptureTouchList->Remove(aTouch->Identifier());
   }
 }
 
-/*static*/ void TouchManager::AppendToTouchList(
-    WidgetTouchEvent::TouchArray* aTouchList) {
+/*static*/
+void TouchManager::AppendToTouchList(WidgetTouchEvent::TouchArray* aTouchList) {
   for (auto iter = sCaptureTouchList->Iter(); !iter.Done(); iter.Next()) {
     RefPtr<Touch>& touch = iter.Data().mTouch;
     touch->mChanged = false;
     aTouchList->AppendElement(touch);
   }
 }
 
 void TouchManager::EvictTouches() {
   WidgetTouchEvent::AutoTouchArray touches;
   AppendToTouchList(&touches);
   for (uint32_t i = 0; i < touches.Length(); ++i) {
     EvictTouchPoint(touches[i], mDocument);
   }
 }
 
-/* static */ nsIFrame* TouchManager::SetupTarget(WidgetTouchEvent* aEvent,
-                                                 nsIFrame* aFrame) {
+/* static */
+nsIFrame* TouchManager::SetupTarget(WidgetTouchEvent* aEvent,
+                                    nsIFrame* aFrame) {
   MOZ_ASSERT(aEvent);
 
   if (!aEvent || aEvent->mMessage != eTouchStart) {
     // All touch events except for touchstart use a captured target.
     return aFrame;
   }
 
   uint32_t flags = 0;
@@ -143,17 +147,18 @@ void TouchManager::EvictTouches() {
       if (oldTouch) {
         touch->SetTouchTarget(oldTouch->mOriginalTarget);
       }
     }
   }
   return target;
 }
 
-/* static */ nsIFrame* TouchManager::SuppressInvalidPointsAndGetTargetedFrame(
+/* static */
+nsIFrame* TouchManager::SuppressInvalidPointsAndGetTargetedFrame(
     WidgetTouchEvent* aEvent) {
   MOZ_ASSERT(aEvent);
 
   if (!aEvent || aEvent->mMessage != eTouchStart) {
     // All touch events except for touchstart use a captured target.
     return nullptr;
   }
 
@@ -387,18 +392,18 @@ bool TouchManager::PreHandleEvent(Widget
       break;
     }
     default:
       break;
   }
   return true;
 }
 
-/*static*/ already_AddRefed<nsIContent>
-TouchManager::GetAnyCapturedTouchTarget() {
+/*static*/
+already_AddRefed<nsIContent> TouchManager::GetAnyCapturedTouchTarget() {
   nsCOMPtr<nsIContent> result = nullptr;
   if (sCaptureTouchList->Count() == 0) {
     return result.forget();
   }
   for (auto iter = sCaptureTouchList->Iter(); !iter.Done(); iter.Next()) {
     RefPtr<Touch>& touch = iter.Data().mTouch;
     if (touch) {
       EventTarget* target = touch->GetTarget();
@@ -406,31 +411,34 @@ TouchManager::GetAnyCapturedTouchTarget(
         result = do_QueryInterface(target);
         break;
       }
     }
   }
   return result.forget();
 }
 
-/*static*/ bool TouchManager::HasCapturedTouch(int32_t aId) {
+/*static*/
+bool TouchManager::HasCapturedTouch(int32_t aId) {
   return sCaptureTouchList->Contains(aId);
 }
 
-/*static*/ already_AddRefed<Touch> TouchManager::GetCapturedTouch(int32_t aId) {
+/*static*/
+already_AddRefed<Touch> TouchManager::GetCapturedTouch(int32_t aId) {
   RefPtr<Touch> touch;
   TouchInfo info;
   if (sCaptureTouchList->Get(aId, &info)) {
     touch = info.mTouch;
   }
   return touch.forget();
 }
 
-/*static*/ bool TouchManager::ShouldConvertTouchToPointer(
-    const Touch* aTouch, const WidgetTouchEvent* aEvent) {
+/*static*/
+bool TouchManager::ShouldConvertTouchToPointer(const Touch* aTouch,
+                                               const WidgetTouchEvent* aEvent) {
   if (!aTouch || !aTouch->convertToPointer) {
     return false;
   }
   TouchInfo info;
   if (!sCaptureTouchList->Get(aTouch->Identifier(), &info)) {
     // This check runs before the TouchManager has the touch registered in its
     // touch list. It's because we dispatching pointer events before handling
     // touch events. So we convert eTouchStart to pointerdown even it's not
--- a/layout/base/nsBidiPresUtils.cpp
+++ b/layout/base/nsBidiPresUtils.cpp
@@ -1296,19 +1296,22 @@ bool nsBidiPresUtils::ChildListMayRequir
 }
 
 void nsBidiPresUtils::ResolveParagraphWithinBlock(BidiParagraphData* aBpd) {
   aBpd->ClearBidiControls();
   ResolveParagraph(aBpd);
   aBpd->ResetData();
 }
 
-/* static */ nscoord nsBidiPresUtils::ReorderFrames(
-    nsIFrame* aFirstFrameOnLine, int32_t aNumFramesOnLine, WritingMode aLineWM,
-    const nsSize& aContainerSize, nscoord aStart) {
+/* static */
+nscoord nsBidiPresUtils::ReorderFrames(nsIFrame* aFirstFrameOnLine,
+                                       int32_t aNumFramesOnLine,
+                                       WritingMode aLineWM,
+                                       const nsSize& aContainerSize,
+                                       nscoord aStart) {
   nsSize containerSize(aContainerSize);
 
   // If this line consists of a line frame, reorder the line frame's children.
   if (aFirstFrameOnLine->IsLineFrame()) {
     // The line frame is positioned at the start-edge, so use its size
     // as the container size.
     containerSize = aFirstFrameOnLine->GetSize();
 
@@ -1461,17 +1464,18 @@ void nsBidiPresUtils::IsFirstOrLast(
     if (aIsLast) {
       aFrame->AddStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST);
     } else {
       aFrame->RemoveStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST);
     }
   }
 }
 
-/* static */ void nsBidiPresUtils::RepositionRubyContentFrame(
+/* static */
+void nsBidiPresUtils::RepositionRubyContentFrame(
     nsIFrame* aFrame, WritingMode aFrameWM,
     const LogicalMargin& aBorderPadding) {
   const nsFrameList& childList = aFrame->PrincipalChildList();
   if (childList.IsEmpty()) {
     return;
   }
 
   // Reorder the children.
@@ -1495,17 +1499,18 @@ void nsBidiPresUtils::IsFirstOrLast(
   const nsSize dummyContainerSize;
   for (nsIFrame* child : childList) {
     LogicalRect rect = child->GetLogicalRect(aFrameWM, dummyContainerSize);
     rect.IStart(aFrameWM) += residualISize / 2;
     child->SetRect(aFrameWM, rect, dummyContainerSize);
   }
 }
 
-/* static */ nscoord nsBidiPresUtils::RepositionRubyFrame(
+/* static */
+nscoord nsBidiPresUtils::RepositionRubyFrame(
     nsIFrame* aFrame, const nsContinuationStates* aContinuationStates,
     const WritingMode aContainerWM, const LogicalMargin& aBorderPadding) {
   LayoutFrameType frameType = aFrame->Type();
   MOZ_ASSERT(RubyUtils::IsRubyBox(frameType));
 
   nscoord icoord = 0;
   WritingMode frameWM = aFrame->GetWritingMode();
   bool isLTR = frameWM.IsBidiLTR();
@@ -1556,17 +1561,18 @@ void nsBidiPresUtils::IsFirstOrLast(
     // above. It is intended, because the children of rtc are reordered
     // with the children of ruby base container simultaneously. We only
     // need to return its isize here, as it should not be changed.
     icoord += aFrame->ISize(aContainerWM);
   }
   return icoord;
 }
 
-/* static */ nscoord nsBidiPresUtils::RepositionFrame(
+/* static */
+nscoord nsBidiPresUtils::RepositionFrame(
     nsIFrame* aFrame, bool aIsEvenLevel, nscoord aStartOrEnd,
     const nsContinuationStates* aContinuationStates, WritingMode aContainerWM,
     bool aContainerReverseDir, const nsSize& aContainerSize) {
   nscoord lineSize =
       aContainerWM.IsVertical() ? aContainerSize.height : aContainerSize.width;
   NS_ASSERTION(lineSize != NS_UNCONSTRAINEDSIZE,
                "Unconstrained inline line size in bidi frame reordering");
   if (!aFrame) return 0;
@@ -1668,19 +1674,21 @@ void nsBidiPresUtils::InitContinuationSt
   if (!IsBidiLeaf(aFrame) || RubyUtils::IsRubyBox(aFrame->Type())) {
     // Continue for child frames
     for (nsIFrame* frame : aFrame->PrincipalChildList()) {
       InitContinuationStates(frame, aContinuationStates);
     }
   }
 }
 
-/* static */ nscoord nsBidiPresUtils::RepositionInlineFrames(
-    BidiLineData* aBld, WritingMode aLineWM, const nsSize& aContainerSize,
-    nscoord aStart) {
+/* static */
+nscoord nsBidiPresUtils::RepositionInlineFrames(BidiLineData* aBld,
+                                                WritingMode aLineWM,
+                                                const nsSize& aContainerSize,
+                                                nscoord aStart) {
   nscoord start = aStart;
   nsIFrame* frame;
   int32_t count = aBld->mVisualFrames.Length();
   int32_t index;
   nsContinuationStates continuationStates;
 
   // Initialize continuation states to (nullptr, 0) for
   // each frame on the line.
--- a/layout/base/nsCaret.cpp
+++ b/layout/base/nsCaret.cpp
@@ -235,19 +235,19 @@ void nsCaret::RemoveForceHide() {
 }
 
 void nsCaret::SetCaretReadOnly(bool inMakeReadonly) {
   mReadOnly = inMakeReadonly;
   ResetBlinking();
   SchedulePaint();
 }
 
-/* static */ nsRect nsCaret::GetGeometryForFrame(nsIFrame* aFrame,
-                                                 int32_t aFrameOffset,
-                                                 nscoord* aBidiIndicatorSize) {
+/* static */
+nsRect nsCaret::GetGeometryForFrame(nsIFrame* aFrame, int32_t aFrameOffset,
+                                    nscoord* aBidiIndicatorSize) {
   nsPoint framePos(0, 0);
   nsRect rect;
   nsresult rv = aFrame->GetPointFromOffset(aFrameOffset, &framePos);
   if (NS_FAILED(rv)) {
     if (aBidiIndicatorSize) {
       *aBidiIndicatorSize = 0;
     }
     return rect;
@@ -379,18 +379,18 @@ nsIFrame* nsCaret::GetFrameAndOffset(Sel
       frameSelection, contentNode, focusOffset, frameSelection->GetHint(),
       bidiLevel, &frame, aUnadjustedFrame, aFrameOffset);
   if (NS_FAILED(rv) || !frame) {
     return nullptr;
   }
   return frame;
 }
 
-/* static */ nsIFrame* nsCaret::GetGeometry(Selection* aSelection,
-                                            nsRect* aRect) {
+/* static */
+nsIFrame* nsCaret::GetGeometry(Selection* aSelection, nsRect* aRect) {
   int32_t frameOffset;
   nsIFrame* frame = GetFrameAndOffset(aSelection, nullptr, 0, &frameOffset);
   if (frame) {
     *aRect = GetGeometryForFrame(frame, frameOffset, nullptr);
   }
   return frame;
 }
 
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -636,17 +636,18 @@ nsDocumentViewer::~nsDocumentViewer() {
 /*
  * This method is called by the Document Loader once a document has
  * been created for a particular data stream...  The content viewer
  * must cache this document for later use when Init(...) is called.
  *
  * This method is also called when an out of band document.write() happens.
  * In that case, the document passed in is the same as the previous document.
  */
-/* virtual */ void nsDocumentViewer::LoadStart(Document* aDocument) {
+/* virtual */
+void nsDocumentViewer::LoadStart(Document* aDocument) {
   MOZ_ASSERT(aDocument);
 
   if (!mDocument) {
     mDocument = aDocument;
   }
 }
 
 nsresult nsDocumentViewer::SyncParentSubDocMap() {
--- a/layout/base/nsGenConList.cpp
+++ b/layout/base/nsGenConList.cpp
@@ -61,18 +61,19 @@ inline int32_t PseudoCompareType(nsIFram
   if (pseudo == mozilla::PseudoStyleType::after) {
     *aContent = aFrame->GetContent()->GetParent();
     return 1;
   }
   *aContent = aFrame->GetContent();
   return 0;
 }
 
-/* static */ bool nsGenConList::NodeAfter(const nsGenConNode* aNode1,
-                                          const nsGenConNode* aNode2) {
+/* static */
+bool nsGenConList::NodeAfter(const nsGenConNode* aNode1,
+                             const nsGenConNode* aNode2) {
   nsIFrame* frame1 = aNode1->mPseudoFrame;
   nsIFrame* frame2 = aNode2->mPseudoFrame;
   if (frame1 == frame2) {
     NS_ASSERTION(aNode2->mContentIndex != aNode1->mContentIndex, "identical");
     return aNode1->mContentIndex > aNode2->mContentIndex;
   }
   nsIContent* content1;
   nsIContent* content2;
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -171,31 +171,46 @@ using mozilla::dom::HTMLMediaElement_Bin
 #ifdef DEBUG
 // TODO: remove, see bug 598468.
 bool nsLayoutUtils::gPreventAssertInCompareTreePosition = false;
 #endif  // DEBUG
 
 typedef ScrollableLayerGuid::ViewID ViewID;
 typedef nsStyleTransformMatrix::TransformReferenceBox TransformReferenceBox;
 
-/* static */ uint32_t nsLayoutUtils::sFontSizeInflationEmPerLine;
-/* static */ uint32_t nsLayoutUtils::sFontSizeInflationMinTwips;
-/* static */ uint32_t nsLayoutUtils::sFontSizeInflationLineThreshold;
-/* static */ int32_t nsLayoutUtils::sFontSizeInflationMappingIntercept;
-/* static */ uint32_t nsLayoutUtils::sFontSizeInflationMaxRatio;
-/* static */ bool nsLayoutUtils::sFontSizeInflationForceEnabled;
-/* static */ bool nsLayoutUtils::sFontSizeInflationDisabledInMasterProcess;
-/* static */ uint32_t nsLayoutUtils::sSystemFontScale;
-/* static */ uint32_t nsLayoutUtils::sZoomMaxPercent;
-/* static */ uint32_t nsLayoutUtils::sZoomMinPercent;
-/* static */ bool nsLayoutUtils::sInvalidationDebuggingIsEnabled;
-/* static */ bool nsLayoutUtils::sInterruptibleReflowEnabled;
-/* static */ bool nsLayoutUtils::sSVGTransformBoxEnabled;
-/* static */ uint32_t nsLayoutUtils::sIdlePeriodDeadlineLimit;
-/* static */ uint32_t nsLayoutUtils::sQuiescentFramesBeforeIdlePeriod;
+/* static */
+uint32_t nsLayoutUtils::sFontSizeInflationEmPerLine;
+/* static */
+uint32_t nsLayoutUtils::sFontSizeInflationMinTwips;
+/* static */
+uint32_t nsLayoutUtils::sFontSizeInflationLineThreshold;
+/* static */
+int32_t nsLayoutUtils::sFontSizeInflationMappingIntercept;
+/* static */
+uint32_t nsLayoutUtils::sFontSizeInflationMaxRatio;
+/* static */
+bool nsLayoutUtils::sFontSizeInflationForceEnabled;
+/* static */
+bool nsLayoutUtils::sFontSizeInflationDisabledInMasterProcess;
+/* static */
+uint32_t nsLayoutUtils::sSystemFontScale;
+/* static */
+uint32_t nsLayoutUtils::sZoomMaxPercent;
+/* static */
+uint32_t nsLayoutUtils::sZoomMinPercent;
+/* static */
+bool nsLayoutUtils::sInvalidationDebuggingIsEnabled;
+/* static */
+bool nsLayoutUtils::sInterruptibleReflowEnabled;
+/* static */
+bool nsLayoutUtils::sSVGTransformBoxEnabled;
+/* static */
+uint32_t nsLayoutUtils::sIdlePeriodDeadlineLimit;
+/* static */
+uint32_t nsLayoutUtils::sQuiescentFramesBeforeIdlePeriod;
 
 static ViewID sScrollIdCounter = ScrollableLayerGuid::START_SCROLL_ID;
 
 typedef nsDataHashtable<nsUint64HashKey, nsIContent*> ContentMap;
 static ContentMap* sContentMap = nullptr;
 static ContentMap& GetContentMap() {
   if (!sContentMap) {
     sContentMap = new ContentMap();
@@ -294,18 +309,19 @@ bool nsLayoutUtils::HasEffectiveAnimatio
 
   return HasMatchingAnimations(effects, [&aPropertySet,
                                          &effects](KeyframeEffect& aEffect) {
     return (aEffect.IsInEffect() || aEffect.IsCurrent()) &&
            aEffect.HasEffectiveAnimationOfPropertySet(aPropertySet, *effects);
   });
 }
 
-/* static */ nsCSSPropertyIDSet
-nsLayoutUtils::GetAnimationPropertiesForCompositor(const nsIFrame* aFrame) {
+/* static */
+nsCSSPropertyIDSet nsLayoutUtils::GetAnimationPropertiesForCompositor(
+    const nsIFrame* aFrame) {
   nsCSSPropertyIDSet properties;
 
   EffectSet* effects = EffectSet::GetEffectSet(aFrame);
   if (!effects) {
     return properties;
   }
 
   AnimationPerformanceWarning::Type warning;
@@ -1073,17 +1089,18 @@ bool nsLayoutUtils::GetDisplayPort(
   }
   return usingDisplayPort;
 }
 
 bool nsLayoutUtils::HasDisplayPort(nsIContent* aContent) {
   return GetDisplayPort(aContent, nullptr);
 }
 
-/* static */ bool nsLayoutUtils::GetDisplayPortForVisibilityTesting(
+/* static */
+bool nsLayoutUtils::GetDisplayPortForVisibilityTesting(
     nsIContent* aContent, nsRect* aResult,
     RelativeTo aRelativeTo /* = RelativeTo::ScrollPort */) {
   MOZ_ASSERT(aResult);
   // Since the base rect might not have been updated very recently, it's
   // possible to end up with an extra-large displayport at this point, if the
   // zoom level is changed by a lot. Instead of using the default behaviour of
   // asserting, we can just ignore the displayport if that happens, as this
   // call site is best-effort.
@@ -1353,30 +1370,34 @@ static Element* GetPseudo(const nsIConte
   MOZ_ASSERT(aPseudoProperty == nsGkAtoms::beforePseudoProperty ||
              aPseudoProperty == nsGkAtoms::afterPseudoProperty);
   if (!aContent->MayHaveAnonymousChildren()) {
     return nullptr;
   }
   return static_cast<Element*>(aContent->GetProperty(aPseudoProperty));
 }
 
-/*static*/ Element* nsLayoutUtils::GetBeforePseudo(const nsIContent* aContent) {
+/*static*/
+Element* nsLayoutUtils::GetBeforePseudo(const nsIContent* aContent) {
   return GetPseudo(aContent, nsGkAtoms::beforePseudoProperty);
 }
 
-/*static*/ nsIFrame* nsLayoutUtils::GetBeforeFrame(const nsIContent* aContent) {
+/*static*/
+nsIFrame* nsLayoutUtils::GetBeforeFrame(const nsIContent* aContent) {
   Element* pseudo = GetBeforePseudo(aContent);
   return pseudo ? pseudo->GetPrimaryFrame() : nullptr;
 }
 
-/*static*/ Element* nsLayoutUtils::GetAfterPseudo(const nsIContent* aContent) {
+/*static*/
+Element* nsLayoutUtils::GetAfterPseudo(const nsIContent* aContent) {
   return GetPseudo(aContent, nsGkAtoms::afterPseudoProperty);
 }
 
-/*static*/ nsIFrame* nsLayoutUtils::GetAfterFrame(const nsIContent* aContent) {
+/*static*/
+nsIFrame* nsLayoutUtils::GetAfterFrame(const nsIContent* aContent) {
   Element* pseudo = GetAfterPseudo(aContent);
   return pseudo ? pseudo->GetPrimaryFrame() : nullptr;
 }
 
 // static
 nsIFrame* nsLayoutUtils::GetClosestFrameOfType(nsIFrame* aFrame,
                                                LayoutFrameType aFrameType,
                                                nsIFrame* aStopAt) {
@@ -1386,17 +1407,18 @@ nsIFrame* nsLayoutUtils::GetClosestFrame
     }
     if (frame == aStopAt) {
       break;
     }
   }
   return nullptr;
 }
 
-/* static */ nsIFrame* nsLayoutUtils::GetPageFrame(nsIFrame* aFrame) {
+/* static */
+nsIFrame* nsLayoutUtils::GetPageFrame(nsIFrame* aFrame) {
   return GetClosestFrameOfType(aFrame, LayoutFrameType::Page);
 }
 
 // static
 nsIFrame* nsLayoutUtils::GetStyleFrame(nsIFrame* aFrame) {
   if (aFrame->IsTableWrapperFrame()) {
     nsIFrame* inner = aFrame->PrincipalChildList().FirstChild();
     // inner may be null, if aFrame is mid-destruction
@@ -1410,18 +1432,18 @@ nsIFrame* nsLayoutUtils::GetStyleFrame(c
   nsIFrame* frame = aContent->GetPrimaryFrame();
   if (!frame) {
     return nullptr;
   }
 
   return nsLayoutUtils::GetStyleFrame(frame);
 }
 
-/* static */ nsIFrame* nsLayoutUtils::GetRealPrimaryFrameFor(
-    const nsIContent* aContent) {
+/* static */
+nsIFrame* nsLayoutUtils::GetRealPrimaryFrameFor(const nsIContent* aContent) {
   nsIFrame* frame = aContent->GetPrimaryFrame();
   if (!frame) {
     return nullptr;
   }
 
   return nsPlaceholderFrame::GetRealFrameFor(frame);
 }
 
@@ -1734,17 +1756,18 @@ nsView* nsLayoutUtils::FindSiblingViewFo
 // static
 nsIScrollableFrame* nsLayoutUtils::GetScrollableFrameFor(
     const nsIFrame* aScrolledFrame) {
   nsIFrame* frame = aScrolledFrame->GetParent();
   nsIScrollableFrame* sf = do_QueryFrame(frame);
   return (sf && sf->GetScrolledFrame() == aScrolledFrame) ? sf : nullptr;
 }
 
-/* static */ void nsLayoutUtils::SetFixedPositionLayerData(
+/* static */
+void nsLayoutUtils::SetFixedPositionLayerData(
     Layer* aLayer, const nsIFrame* aViewportFrame, const nsRect& aAnchorRect,
     const nsIFrame* aFixedPosFrame, nsPresContext* aPresContext,
     const ContainerLayerParameters& aContainerParameters) {
   // Find out the rect of the viewport frame relative to the reference frame.
   // This, in conjunction with the container scale, will correspond to the
   // coordinate-space of the built layer.
   float factor = aPresContext->AppUnitsPerDevPixel();
   Rect anchorRect(NSAppUnitsToFloatPixels(aAnchorRect.x, factor) *
@@ -4400,20 +4423,22 @@ static bool IsCoord50Pct(const LengthPer
 // for the "object-fit" and "object-position" properties.
 static bool HasInitialObjectFitAndPosition(const nsStylePosition* aStylePos) {
   const Position& objectPos = aStylePos->mObjectPosition;
 
   return aStylePos->mObjectFit == NS_STYLE_OBJECT_FIT_FILL &&
          IsCoord50Pct(objectPos.horizontal) && IsCoord50Pct(objectPos.vertical);
 }
 
-/* static */ nsRect nsLayoutUtils::ComputeObjectDestRect(
-    const nsRect& aConstraintRect, const IntrinsicSize& aIntrinsicSize,
-    const nsSize& aIntrinsicRatio, const nsStylePosition* aStylePos,
-    nsPoint* aAnchorPoint) {
+/* static */
+nsRect nsLayoutUtils::ComputeObjectDestRect(const nsRect& aConstraintRect,
+                                            const IntrinsicSize& aIntrinsicSize,
+                                            const nsSize& aIntrinsicRatio,
+                                            const nsStylePosition* aStylePos,
+                                            nsPoint* aAnchorPoint) {
   // Step 1: Figure out our "concrete object size"
   // (the size of the region we'll actually draw our image's pixels into).
   nsSize concreteObjectSize =
       ComputeConcreteObjectSize(aConstraintRect.Size(), aIntrinsicSize,
                                 aIntrinsicRatio, aStylePos->mObjectFit);
 
   // Step 2: Figure out how to align that region in the element's content-box.
   nsPoint imageTopLeftPt, imageAnchorPt;
@@ -5081,17 +5106,18 @@ static void AddStateBitToAncestors(nsIFr
   for (nsIFrame* f = aFrame; f; f = f->GetParent()) {
     if (f->HasAnyStateBits(aBit)) {
       break;
     }
     f->AddStateBits(aBit);
   }
 }
 
-/* static */ nscoord nsLayoutUtils::IntrinsicForAxis(
+/* static */
+nscoord nsLayoutUtils::IntrinsicForAxis(
     PhysicalAxis aAxis, gfxContext* aRenderingContext, nsIFrame* aFrame,
     IntrinsicISizeType aType, const Maybe<LogicalSize>& aPercentageBasis,
     uint32_t aFlags, nscoord aMarginBoxMinSizeClamp) {
   MOZ_ASSERT(aFrame, "null frame");
   MOZ_ASSERT(aFrame->GetParent(),
              "IntrinsicForAxis called on frame not in tree");
   MOZ_ASSERT(aType == MIN_ISIZE || aType == PREF_ISIZE, "bad type");
   MOZ_ASSERT(aFrame->GetParent()->Type() != LayoutFrameType::GridContainer ||
@@ -5361,28 +5387,31 @@ static void AddStateBitToAncestors(nsIFr
   printf_stderr(" %s %s intrinsic size for container is %d twips.\n",
                 aType == MIN_ISIZE ? "min" : "pref",
                 horizontalAxis ? "horizontal" : "vertical", result);
 #endif
 
   return result;
 }
 
-/* static */ nscoord nsLayoutUtils::IntrinsicForContainer(
-    gfxContext* aRenderingContext, nsIFrame* aFrame, IntrinsicISizeType aType,
-    uint32_t aFlags) {
+/* static */
+nscoord nsLayoutUtils::IntrinsicForContainer(gfxContext* aRenderingContext,
+                                             nsIFrame* aFrame,
+                                             IntrinsicISizeType aType,
+                                             uint32_t aFlags) {
   MOZ_ASSERT(aFrame && aFrame->GetParent());
   // We want the size aFrame will contribute to its parent's inline-size.
   PhysicalAxis axis =
       aFrame->GetParent()->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
   return IntrinsicForAxis(axis, aRenderingContext, aFrame, aType, Nothing(),
                           aFlags);
 }
 
-/* static */ nscoord nsLayoutUtils::MinSizeContributionForAxis(
+/* static */
+nscoord nsLayoutUtils::MinSizeContributionForAxis(
     PhysicalAxis aAxis, gfxContext* aRC, nsIFrame* aFrame,
     IntrinsicISizeType aType, const LogicalSize& aPercentageBasis,
     uint32_t aFlags) {
   MOZ_ASSERT(aFrame);
   MOZ_ASSERT(aFrame->IsFlexOrGridItem(),
              "only grid/flex items have this behavior currently");
 
 #ifdef DEBUG_INTRINSIC_WIDTH
@@ -5484,17 +5513,18 @@ static void AddStateBitToAncestors(nsIFr
   static_cast<nsFrame*>(aFrame)->ListTag(stderr);
   printf_stderr(" %s min-isize is %d twips.\n",
                 aType == MIN_ISIZE ? "min" : "pref", result);
 #endif
 
   return result;
 }
 
-/* static */ nscoord nsLayoutUtils::ComputeBSizeDependentValue(
+/* static */
+nscoord nsLayoutUtils::ComputeBSizeDependentValue(
     nscoord aContainingBlockBSize, const LengthPercentageOrAuto& aCoord) {
   // XXXldb Some callers explicitly check aContainingBlockBSize
   // against NS_AUTOHEIGHT *and* unit against eStyleUnit_Percent or
   // calc()s containing percents before calling this function.
   // However, it would be much more likely to catch problems without
   // the unit conditions.
   // XXXldb Many callers pass a non-'auto' containing block height when
   // according to CSS2.1 they should be passing 'auto'.
@@ -5503,17 +5533,18 @@ static void AddStateBitToAncestors(nsIFr
 
   if (aCoord.IsAuto()) {
     return 0;
   }
 
   return aCoord.AsLengthPercentage().Resolve(aContainingBlockBSize);
 }
 
-/* static */ void nsLayoutUtils::MarkDescendantsDirty(nsIFrame* aSubtreeRoot) {
+/* static */
+void nsLayoutUtils::MarkDescendantsDirty(nsIFrame* aSubtreeRoot) {
   AutoTArray<nsIFrame*, 4> subtrees;
   subtrees.AppendElement(aSubtreeRoot);
 
   // dirty descendants, iterating over subtrees that may include
   // additional subtrees associated with placeholders
   do {
     nsIFrame* subtreeRoot = subtrees.PopLastElement();
 
@@ -5652,30 +5683,32 @@ nsSize nsLayoutUtils::ComputeAutoSizeWit
       width = tentWidth;
       height = tentHeight;
     }
   }
 
   return nsSize(width, height);
 }
 
-/* static */ nscoord nsLayoutUtils::MinISizeFromInline(
-    nsIFrame* aFrame, gfxContext* aRenderingContext) {
+/* static */
+nscoord nsLayoutUtils::MinISizeFromInline(nsIFrame* aFrame,
+                                          gfxContext* aRenderingContext) {
   NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
                "should not be container for font size inflation");
 
   nsIFrame::InlineMinISizeData data;
   DISPLAY_MIN_INLINE_SIZE(aFrame, data.mPrevLines);
   aFrame->AddInlineMinISize(aRenderingContext, &data);
   data.ForceBreak();
   return data.mPrevLines;
 }
 
-/* static */ nscoord nsLayoutUtils::PrefISizeFromInline(
-    nsIFrame* aFrame, gfxContext* aRenderingContext) {
+/* static */
+nscoord nsLayoutUtils::PrefISizeFromInline(nsIFrame* aFrame,
+                                           gfxContext* aRenderingContext) {
   NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
                "should not be container for font size inflation");
 
   nsIFrame::InlinePrefISizeData data;
   DISPLAY_PREF_INLINE_SIZE(aFrame, data.mPrevLines);
   aFrame->AddInlinePrefISize(aRenderingContext, &data);
   data.ForceBreak();
   return data.mPrevLines;
@@ -5915,17 +5948,18 @@ void nsLayoutUtils::DrawUniDirString(con
     if (!isRTL) {
       x += width;
     }
     aLength -= len;
     aString += len;
   }
 }
 
-/* static */ void nsLayoutUtils::PaintTextShadow(
+/* static */
+void nsLayoutUtils::PaintTextShadow(
     const nsIFrame* aFrame, gfxContext* aContext, const nsRect& aTextRect,
     const nsRect& aDirtyRect, const nscolor& aForegroundColor,
     TextShadowCallback aCallback, void* aCallbackData) {
   const nsStyleText* textStyle = aFrame->StyleText();
   if (!textStyle->HasTextShadow()) return;
 
   // Text shadow happens with the last value being painted at the back,
   // ie. it is painted first.
@@ -5976,38 +6010,42 @@ void nsLayoutUtils::DrawUniDirString(con
     // The callback will draw whatever we want to blur as a shadow.
     aCallback(shadowContext, shadowOffset, shadowColor, aCallbackData);
 
     contextBoxBlur.DoPaint();
     aDestCtx->Restore();
   }
 }
 
-/* static */ nscoord nsLayoutUtils::GetCenteredFontBaseline(
-    nsFontMetrics* aFontMetrics, nscoord aLineHeight, bool aIsInverted) {
+/* static */
+nscoord nsLayoutUtils::GetCenteredFontBaseline(nsFontMetrics* aFontMetrics,
+                                               nscoord aLineHeight,
+                                               bool aIsInverted) {
   nscoord fontAscent =
       aIsInverted ? aFontMetrics->MaxDescent() : aFontMetrics->MaxAscent();
   nscoord fontHeight = aFontMetrics->MaxHeight();
 
   nscoord leading = aLineHeight - fontHeight;
   return fontAscent + leading / 2;
 }
 
-/* static */ bool nsLayoutUtils::GetFirstLineBaseline(WritingMode aWritingMode,
-                                                      const nsIFrame* aFrame,
-                                                      nscoord* aResult) {
+/* static */
+bool nsLayoutUtils::GetFirstLineBaseline(WritingMode aWritingMode,
+                                         const nsIFrame* aFrame,
+                                         nscoord* aResult) {
   LinePosition position;
   if (!GetFirstLinePosition(aWritingMode, aFrame, &position)) return false;
   *aResult = position.mBaseline;
   return true;
 }
 
-/* static */ bool nsLayoutUtils::GetFirstLinePosition(WritingMode aWM,
-                                                      const nsIFrame* aFrame,
-                                                      LinePosition* aResult) {
+/* static */
+bool nsLayoutUtils::GetFirstLinePosition(WritingMode aWM,
+                                         const nsIFrame* aFrame,
+                                         LinePosition* aResult) {
   if (aFrame->StyleDisplay()->IsContainLayout()) {
     return false;
   }
   const nsBlockFrame* block = do_QueryFrame(aFrame);
   if (!block) {
     // For the first-line baseline we also have to check for a table, and if
     // so, use the baseline of its first row.
     LayoutFrameType fType = aFrame->Type();
@@ -6096,19 +6134,19 @@ void nsLayoutUtils::DrawUniDirString(con
         aResult->mBEnd = bStart + line->BSize();
         return true;
       }
     }
   }
   return false;
 }
 
-/* static */ bool nsLayoutUtils::GetLastLineBaseline(WritingMode aWM,
-                                                     const nsIFrame* aFrame,
-                                                     nscoord* aResult) {
+/* static */
+bool nsLayoutUtils::GetLastLineBaseline(WritingMode aWM, const nsIFrame* aFrame,
+                                        nscoord* aResult) {
   if (aFrame->StyleDisplay()->IsContainLayout()) {
     return false;
   }
 
   const nsBlockFrame* block = do_QueryFrame(aFrame);
   if (!block)
     // No baseline.  (We intentionally don't descend into scroll frames.)
     return false;
@@ -6164,18 +6202,18 @@ static nscoord CalculateBlockContentBEnd
                    nsLayoutUtils::CalculateContentBEnd(aWM, child) + offset);
     } else {
       contentBEnd = std::max(contentBEnd, line->BEnd());
     }
   }
   return contentBEnd;
 }
 
-/* static */ nscoord nsLayoutUtils::CalculateContentBEnd(WritingMode aWM,
-                                                         nsIFrame* aFrame) {
+/* static */
+nscoord nsLayoutUtils::CalculateContentBEnd(WritingMode aWM, nsIFrame* aFrame) {
   MOZ_ASSERT(aFrame, "null ptr");
 
   nscoord contentBEnd = aFrame->BSize(aWM);
 
   // We want scrollable overflow rather than visual because this
   // calculation is intended to affect layout.
   LogicalSize overflowSize(aWM, aFrame->GetScrollableOverflowRect().Size());
   if (overflowSize.BSize(aWM) > contentBEnd) {
@@ -6200,17 +6238,18 @@ static nscoord CalculateBlockContentBEnd
               std::max(contentBEnd, CalculateContentBEnd(aWM, child) + offset);
         }
       }
     }
   }
   return contentBEnd;
 }
 
-/* static */ nsIFrame* nsLayoutUtils::GetClosestLayer(nsIFrame* aFrame) {
+/* static */
+nsIFrame* nsLayoutUtils::GetClosestLayer(nsIFrame* aFrame) {
   nsIFrame* layer;
   for (layer = aFrame; layer; layer = layer->GetParent()) {
     if (layer->IsAbsPosContainingBlock() ||
         (layer->GetParent() && layer->GetParent()->IsScrollFrame()))
       break;
   }
   if (layer) return layer;
   return aFrame->PresShell()->GetRootFrame();
@@ -6261,18 +6300,19 @@ static gfxPoint MapToFloatImagePixels(co
  * @param aPt a point in image space
  */
 static gfxPoint MapToFloatUserPixels(const gfxSize& aSize, const gfxRect& aDest,
                                      const gfxPoint& aPt) {
   return gfxPoint(aPt.x * aDest.Width() / aSize.width + aDest.X(),
                   aPt.y * aDest.Height() / aSize.height + aDest.Y());
 }
 
-/* static */ gfxRect nsLayoutUtils::RectToGfxRect(
-    const nsRect& aRect, int32_t aAppUnitsPerDevPixel) {
+/* static */
+gfxRect nsLayoutUtils::RectToGfxRect(const nsRect& aRect,
+                                     int32_t aAppUnitsPerDevPixel) {
   return gfxRect(gfxFloat(aRect.x) / aAppUnitsPerDevPixel,
                  gfxFloat(aRect.y) / aAppUnitsPerDevPixel,
                  gfxFloat(aRect.width) / aAppUnitsPerDevPixel,
                  gfxFloat(aRect.height) / aAppUnitsPerDevPixel);
 }
 
 struct SnappedImageDrawingParameters {
   // A transform from image space to device space.
@@ -6589,17 +6629,18 @@ static ImgDrawResult DrawImageInternal(
                           imgIContainer::FRAME_CURRENT, aSamplingFilter,
                           aSVGContext ? aSVGContext : fallbackContext,
                           aImageFlags, aOpacity);
   }
 
   return result;
 }
 
-/* static */ ImgDrawResult nsLayoutUtils::DrawSingleUnscaledImage(
+/* static */
+ImgDrawResult nsLayoutUtils::DrawSingleUnscaledImage(
     gfxContext& aContext, nsPresContext* aPresContext, imgIContainer* aImage,
     const SamplingFilter aSamplingFilter, const nsPoint& aDest,
     const nsRect* aDirty, const Maybe<SVGImageContext>& aSVGContext,
     uint32_t aImageFlags, const nsRect* aSourceArea) {
   CSSIntSize imageSize;
   aImage->GetWidth(&imageSize.width);
   aImage->GetHeight(&imageSize.height);
   if (imageSize.width < 1 || imageSize.height < 1) {
@@ -6621,17 +6662,18 @@ static ImgDrawResult DrawImageInternal(
   // outside the image bounds, we want to honor the aSourceArea-to-aDest
   // translation but we don't want to actually tile the image.
   fill.IntersectRect(fill, dest);
   return DrawImageInternal(aContext, aPresContext, aImage, aSamplingFilter,
                            dest, fill, aDest, aDirty ? *aDirty : dest,
                            aSVGContext, aImageFlags);
 }
 
-/* static */ ImgDrawResult nsLayoutUtils::DrawSingleImage(
+/* static */
+ImgDrawResult nsLayoutUtils::DrawSingleImage(
     gfxContext& aContext, nsPresContext* aPresContext, imgIContainer* aImage,
     const SamplingFilter aSamplingFilter, const nsRect& aDest,
     const nsRect& aDirty, const Maybe<SVGImageContext>& aSVGContext,
     uint32_t aImageFlags, const nsPoint* aAnchorPoint,
     const nsRect* aSourceArea) {
   nscoord appUnitsPerCSSPixel = AppUnitsPerCSSPixel();
   CSSIntSize pixelImageSize(
       ComputeSizeForDrawingWithFallback(aImage, aDest.Size()));
@@ -6668,17 +6710,18 @@ static ImgDrawResult DrawImageInternal(
   // transform but we don't want to actually tile the image.
   nsRect fill;
   fill.IntersectRect(aDest, dest);
   return DrawImageInternal(aContext, aPresContext, image, aSamplingFilter, dest,
                            fill, aAnchorPoint ? *aAnchorPoint : fill.TopLeft(),
                            aDirty, aSVGContext, aImageFlags);
 }
 
-/* static */ void nsLayoutUtils::ComputeSizeForDrawing(
+/* static */
+void nsLayoutUtils::ComputeSizeForDrawing(
     imgIContainer* aImage, /* outparam */ CSSIntSize& aImageSize,
     /* outparam */ nsSize& aIntrinsicRatio,
     /* outparam */ bool& aGotWidth,
     /* outparam */ bool& aGotHeight) {
   aGotWidth = NS_SUCCEEDED(aImage->GetWidth(&aImageSize.width));
   aGotHeight = NS_SUCCEEDED(aImage->GetHeight(&aImageSize.height));
   bool gotRatio = NS_SUCCEEDED(aImage->GetIntrinsicRatio(&aIntrinsicRatio));
 
@@ -6686,17 +6729,18 @@ static ImgDrawResult DrawImageInternal(
     // We hit an error (say, because the image failed to load or couldn't be
     // decoded) and should return zero size.
     aGotWidth = aGotHeight = true;
     aImageSize = CSSIntSize(0, 0);
     aIntrinsicRatio = nsSize(0, 0);
   }
 }
 
-/* static */ CSSIntSize nsLayoutUtils::ComputeSizeForDrawingWithFallback(
+/* static */
+CSSIntSize nsLayoutUtils::ComputeSizeForDrawingWithFallback(
     imgIContainer* aImage, const nsSize& aFallbackSize) {
   CSSIntSize imageSize;
   nsSize imageRatio;
   bool gotHeight, gotWidth;
   ComputeSizeForDrawing(aImage, imageSize, imageRatio, gotWidth, gotHeight);
 
   // If we didn't get both width and height, try to compute them using the
   // intrinsic ratio of the image.
@@ -6727,17 +6771,18 @@ static ImgDrawResult DrawImageInternal(
   if (!gotHeight) {
     imageSize.height =
         nsPresContext::AppUnitsToIntCSSPixels(aFallbackSize.height);
   }
 
   return imageSize;
 }
 
-/* static */ IntSize nsLayoutUtils::ComputeImageContainerDrawingParameters(
+/* static */
+IntSize nsLayoutUtils::ComputeImageContainerDrawingParameters(
     imgIContainer* aImage, nsIFrame* aForFrame,
     const LayoutDeviceRect& aDestRect, const StackingContextHelper& aSc,
     uint32_t aFlags, Maybe<SVGImageContext>& aSVGContext) {
   MOZ_ASSERT(aImage);
   MOZ_ASSERT(aForFrame);
 
   gfx::Size scaleFactors = aSc.GetInheritedScale();
   SamplingFilter samplingFilter =
@@ -6772,26 +6817,29 @@ static ImgDrawResult DrawImageInternal(
   // 1 pixel wide/tall.
   gfxSize gfxLayerSize =
       gfxSize(std::max(layerSize.width, 1), std::max(layerSize.height, 1));
 
   return aImage->OptimalImageSizeForDest(
       gfxLayerSize, imgIContainer::FRAME_CURRENT, samplingFilter, aFlags);
 }
 
-/* static */ nsPoint nsLayoutUtils::GetBackgroundFirstTilePos(
-    const nsPoint& aDest, const nsPoint& aFill, const nsSize& aRepeatSize) {
+/* static */
+nsPoint nsLayoutUtils::GetBackgroundFirstTilePos(const nsPoint& aDest,
+                                                 const nsPoint& aFill,
+                                                 const nsSize& aRepeatSize) {
   return nsPoint(NSToIntFloor(float(aFill.x - aDest.x) / aRepeatSize.width) *
                      aRepeatSize.width,
                  NSToIntFloor(float(aFill.y - aDest.y) / aRepeatSize.height) *
                      aRepeatSize.height) +
          aDest;
 }
 
-/* static */ ImgDrawResult nsLayoutUtils::DrawBackgroundImage(
+/* static */
+ImgDrawResult nsLayoutUtils::DrawBackgroundImage(
     gfxContext& aContext, nsIFrame* aForFrame, nsPresContext* aPresContext,
     imgIContainer* aImage, const CSSIntSize& aImageSize,
     SamplingFilter aSamplingFilter, const nsRect& aDest, const nsRect& aFill,
     const nsSize& aRepeatSize, const nsPoint& aAnchor, const nsRect& aDirty,
     uint32_t aImageFlags, ExtendMode aExtendMode, float aOpacity) {
   AUTO_PROFILER_LABEL("nsLayoutUtils::DrawBackgroundImage",
                       GRAPHICS_Rasterization);
 
@@ -6818,62 +6866,65 @@ static ImgDrawResult DrawImageInternal(
         return result;
       }
     }
   }
 
   return ImgDrawResult::SUCCESS;
 }
 
-/* static */ ImgDrawResult nsLayoutUtils::DrawImage(
+/* static */
+ImgDrawResult nsLayoutUtils::DrawImage(
     gfxContext& aContext, ComputedStyle* aComputedStyle,
     nsPresContext* aPresContext, imgIContainer* aImage,
     const SamplingFilter aSamplingFilter, const nsRect& aDest,
     const nsRect& aFill, const nsPoint& aAnchor, const nsRect& aDirty,
     uint32_t aImageFlags, float aOpacity) {
   Maybe<SVGImageContext> svgContext;
   SVGImageContext::MaybeStoreContextPaint(svgContext, aComputedStyle, aImage);
 
   return DrawImageInternal(aContext, aPresContext, aImage, aSamplingFilter,
                            aDest, aFill, aAnchor, aDirty, svgContext,
                            aImageFlags, ExtendMode::CLAMP, aOpacity);
 }
 
-/* static */ nsRect nsLayoutUtils::GetWholeImageDestination(
-    const nsSize& aWholeImageSize, const nsRect& aImageSourceArea,
-    const nsRect& aDestArea) {
+/* static */
+nsRect nsLayoutUtils::GetWholeImageDestination(const nsSize& aWholeImageSize,
+                                               const nsRect& aImageSourceArea,
+                                               const nsRect& aDestArea) {
   double scaleX = double(aDestArea.width) / aImageSourceArea.width;
   double scaleY = double(aDestArea.height) / aImageSourceArea.height;
   nscoord destOffsetX = NSToCoordRound(aImageSourceArea.x * scaleX);
   nscoord destOffsetY = NSToCoordRound(aImageSourceArea.y * scaleY);
   nscoord wholeSizeX = NSToCoordRound(aWholeImageSize.width * scaleX);
   nscoord wholeSizeY = NSToCoordRound(aWholeImageSize.height * scaleY);
   return nsRect(aDestArea.TopLeft() - nsPoint(destOffsetX, destOffsetY),
                 nsSize(wholeSizeX, wholeSizeY));
 }
 
-/* static */ already_AddRefed<imgIContainer> nsLayoutUtils::OrientImage(
+/* static */
+already_AddRefed<imgIContainer> nsLayoutUtils::OrientImage(
     imgIContainer* aContainer, const StyleImageOrientation& aOrientation) {
   MOZ_ASSERT(aContainer, "Should have an image container");
   nsCOMPtr<imgIContainer> img(aContainer);
 
   if (aOrientation == StyleImageOrientation::FromImage) {
     img = ImageOps::Orient(img, img->GetOrientation());
   }
 
   return img.forget();
 }
 
 static bool NonZeroCorner(const LengthPercentage& aLength) {
   // Since negative results are clamped to 0, check > 0.
   return aLength.Resolve(nscoord_MAX) > 0 || aLength.Resolve(0) > 0;
 }
 
-/* static */ bool nsLayoutUtils::HasNonZeroCorner(
-    const BorderRadius& aCorners) {
+/* static */
+bool nsLayoutUtils::HasNonZeroCorner(const BorderRadius& aCorners) {
   NS_FOR_CSS_HALF_CORNERS(corner) {
     if (NonZeroCorner(aCorners.Get(corner))) return true;
   }
   return false;
 }
 
 // aCorner is a "full corner" value, i.e. eCornerTopLeft etc.
 static bool IsCornerAdjacentToSide(uint8_t aCorner, Side aSide) {
@@ -6889,18 +6940,19 @@ static bool IsCornerAdjacentToSide(uint8
   static_assert((int)eSideBottom == ((eCornerBottomLeft - 1) & 3),
                 "Check for Full Corner");
   static_assert((int)eSideLeft == ((eCornerTopLeft - 1) & 3),
                 "Check for Full Corner");
 
   return aSide == aCorner || aSide == ((aCorner - 1) & 3);
 }
 
-/* static */ bool nsLayoutUtils::HasNonZeroCornerOnSide(
-    const BorderRadius& aCorners, Side aSide) {
+/* static */
+bool nsLayoutUtils::HasNonZeroCornerOnSide(const BorderRadius& aCorners,
+                                           Side aSide) {
   static_assert(eCornerTopLeftX / 2 == eCornerTopLeft,
                 "Check for Non Zero on side");
   static_assert(eCornerTopLeftY / 2 == eCornerTopLeft,
                 "Check for Non Zero on side");
   static_assert(eCornerTopRightX / 2 == eCornerTopRight,
                 "Check for Non Zero on side");
   static_assert(eCornerTopRightY / 2 == eCornerTopRight,
                 "Check for Non Zero on side");
@@ -6918,17 +6970,18 @@ static bool IsCornerAdjacentToSide(uint8
     // "full corner" value.
     if (NonZeroCorner(aCorners.Get(corner)) &&
         IsCornerAdjacentToSide(corner / 2, aSide))
       return true;
   }
   return false;
 }
 
-/* static */ nsTransparencyMode nsLayoutUtils::GetFrameTransparency(
+/* static */
+nsTransparencyMode nsLayoutUtils::GetFrameTransparency(
     nsIFrame* aBackgroundFrame, nsIFrame* aCSSRootFrame) {
   if (aCSSRootFrame->StyleEffects()->mOpacity < 1.0f)
     return eTransparencyTransparent;
 
   if (HasNonZeroCorner(aCSSRootFrame->StyleBorder()->mBorderRadius))
     return eTransparencyTransparent;
 
   if (aCSSRootFrame->StyleDisplay()->mAppearance ==
@@ -6972,26 +7025,28 @@ static bool IsPopupFrame(const nsIFrame*
         static_cast<const nsListControlFrame*>(aFrame);
     return lcf->IsInDropDownMode();
   }
 
   // ... or if it's a XUL menupopup frame.
   return frameType == LayoutFrameType::MenuPopup;
 }
 
-/* static */ bool nsLayoutUtils::IsPopup(const nsIFrame* aFrame) {
+/* static */
+bool nsLayoutUtils::IsPopup(const nsIFrame* aFrame) {
   // Optimization: the frame can't possibly be a popup if it has no view.
   if (!aFrame->HasView()) {
     NS_ASSERTION(!IsPopupFrame(aFrame), "popup frame must have a view");
     return false;
   }
   return IsPopupFrame(aFrame);
 }
 
-/* static */ nsIFrame* nsLayoutUtils::GetDisplayRootFrame(nsIFrame* aFrame) {
+/* static */
+nsIFrame* nsLayoutUtils::GetDisplayRootFrame(nsIFrame* aFrame) {
   // We could use GetRootPresContext() here if the
   // NS_FRAME_IN_POPUP frame bit is set.
   nsIFrame* f = aFrame;
   for (;;) {
     if (!f->HasAnyStateBits(NS_FRAME_IN_POPUP)) {
       f = f->PresShell()->GetRootFrame();
       if (!f) {
         return aFrame;
@@ -7000,17 +7055,18 @@ static bool IsPopupFrame(const nsIFrame*
       return f;
     }
     nsIFrame* parent = GetCrossDocParentFrame(f);
     if (!parent) return f;
     f = parent;
   }
 }
 
-/* static */ nsIFrame* nsLayoutUtils::GetReferenceFrame(nsIFrame* aFrame) {
+/* static */
+nsIFrame* nsLayoutUtils::GetReferenceFrame(nsIFrame* aFrame) {
   nsIFrame* f = aFrame;
   for (;;) {
     const nsStyleDisplay* disp = f->StyleDisplay();
     if (f->IsTransformed(disp) || f->IsPreserve3DLeaf(disp) || IsPopup(f)) {
       return f;
     }
     nsIFrame* parent = GetCrossDocParentFrame(f);
     if (!parent) {
@@ -7076,20 +7132,20 @@ static bool IsPopupFrame(const nsIFrame*
       return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
 
     default:
       MOZ_ASSERT_UNREACHABLE("unknown writing-mode");
       return gfx::ShapedTextFlags();
   }
 }
 
-/* static */ void nsLayoutUtils::GetRectDifferenceStrips(const nsRect& aR1,
-                                                         const nsRect& aR2,
-                                                         nsRect* aHStrip,
-                                                         nsRect* aVStrip) {
+/* static */
+void nsLayoutUtils::GetRectDifferenceStrips(const nsRect& aR1,
+                                            const nsRect& aR2, nsRect* aHStrip,
+                                            nsRect* aVStrip) {
   NS_ASSERTION(aR1.TopLeft() == aR2.TopLeft(),
                "expected rects at the same position");
   nsRect unionRect(aR1.x, aR1.y, std::max(aR1.width, aR2.width),
                    std::max(aR1.height, aR2.height));
   nscoord VStripStart = std::min(aR1.width, aR2.width);
   nscoord HStripStart = std::min(aR1.height, aR2.height);
   *aVStrip = unionRect;
   aVStrip->x += VStripStart;
@@ -7130,23 +7186,25 @@ nsDeviceContext* nsLayoutUtils::GetDevic
     nsCOMPtr<nsIDocShellTreeItem> parentItem;
     docShell->GetParent(getter_AddRefs(parentItem));
     docShell = do_QueryInterface(parentItem);
   }
 
   return nullptr;
 }
 
-/* static */ bool nsLayoutUtils::IsReallyFixedPos(const nsIFrame* aFrame) {
+/* static */
+bool nsLayoutUtils::IsReallyFixedPos(const nsIFrame* aFrame) {
   MOZ_ASSERT(aFrame->StyleDisplay()->mPosition == NS_STYLE_POSITION_FIXED,
              "IsReallyFixedPos called on non-'position:fixed' frame");
   return MayBeReallyFixedPos(aFrame);
 }
 
-/* static */ bool nsLayoutUtils::MayBeReallyFixedPos(const nsIFrame* aFrame) {
+/* static */
+bool nsLayoutUtils::MayBeReallyFixedPos(const nsIFrame* aFrame) {
   MOZ_ASSERT(aFrame->GetParent(),
              "MayBeReallyFixedPos called on frame not in tree");
   LayoutFrameType parentType = aFrame->GetParent()->Type();
   return parentType == LayoutFrameType::Viewport ||
          parentType == LayoutFrameType::PageContent;
 }
 
 nsLayoutUtils::SurfaceFromElementResult
@@ -7451,17 +7509,18 @@ Element* nsLayoutUtils::GetEditableRootC
   Element* bodyElement = aDocument->GetBody();
   if (bodyElement && bodyElement->IsEditable()) {
     return bodyElement;
   }
   return nullptr;
 }
 
 #ifdef DEBUG
-/* static */ void nsLayoutUtils::AssertNoDuplicateContinuations(
+/* static */
+void nsLayoutUtils::AssertNoDuplicateContinuations(
     nsIFrame* aContainer, const nsFrameList& aFrameList) {
   for (nsIFrame* f : aFrameList) {
     // Check only later continuations of f; we deal with checking the
     // earlier continuations when we hit those earlier continuations in
     // the frame list.
     for (nsIFrame* c = f; (c = c->GetNextInFlow());) {
       NS_ASSERTION(c->GetParent() != aContainer || !aFrameList.ContainsFrame(c),
                    "Two continuations of the same frame in the same "
@@ -7475,18 +7534,18 @@ static bool IsInLetterFrame(nsIFrame* aF
   for (nsIFrame* f = aFrame->GetParent(); f; f = f->GetParent()) {
     if (f->IsLetterFrame()) {
       return true;
     }
   }
   return false;
 }
 
-/* static */ void nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(
-    nsIFrame* aSubtreeRoot) {
+/* static */
+void nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(nsIFrame* aSubtreeRoot) {
   NS_ASSERTION(aSubtreeRoot->GetPrevInFlow(),
                "frame tree not empty, but caller reported complete status");
 
   // Also assert that text frames map no text.
   int32_t start, end;
   nsresult rv = aSubtreeRoot->GetOffsets(start, end);
   NS_ASSERTION(NS_SUCCEEDED(rv), "GetOffsets failed");
   // In some cases involving :first-letter, we'll partially unlink a
@@ -7532,19 +7591,22 @@ static void GetFontFacesForFramesInner(
       nsIFrame* child = e.get();
       child = nsPlaceholderFrame::GetRealFrameFor(child);
       GetFontFacesForFramesInner(child, aResult, aFontFaces, aMaxRanges,
                                  aSkipCollapsedWhitespace);
     }
   }
 }
 
-/* static */ nsresult nsLayoutUtils::GetFontFacesForFrames(
-    nsIFrame* aFrame, UsedFontFaceList& aResult, UsedFontFaceTable& aFontFaces,
-    uint32_t aMaxRanges, bool aSkipCollapsedWhitespace) {
+/* static */
+nsresult nsLayoutUtils::GetFontFacesForFrames(nsIFrame* aFrame,
+                                              UsedFontFaceList& aResult,
+                                              UsedFontFaceTable& aFontFaces,
+                                              uint32_t aMaxRanges,
+                                              bool aSkipCollapsedWhitespace) {
   MOZ_ASSERT(aFrame, "NULL frame pointer");
 
   while (aFrame) {
     GetFontFacesForFramesInner(aFrame, aResult, aFontFaces, aMaxRanges,
                                aSkipCollapsedWhitespace);
     aFrame = GetNextContinuationOrIBSplitSibling(aFrame);
   }
 
@@ -7603,21 +7665,24 @@ static void AddFontsFromTextRun(gfxTextR
         } else {
           fontFace->AddRange(range);
         }
       }
     }
   }
 }
 
-/* static */ void nsLayoutUtils::GetFontFacesForText(
-    nsIFrame* aFrame, int32_t aStartOffset, int32_t aEndOffset,
-    bool aFollowContinuations, UsedFontFaceList& aResult,
-    UsedFontFaceTable& aFontFaces, uint32_t aMaxRanges,
-    bool aSkipCollapsedWhitespace) {
+/* static */
+void nsLayoutUtils::GetFontFacesForText(nsIFrame* aFrame, int32_t aStartOffset,
+                                        int32_t aEndOffset,
+                                        bool aFollowContinuations,
+                                        UsedFontFaceList& aResult,
+                                        UsedFontFaceTable& aFontFaces,
+                                        uint32_t aMaxRanges,
+                                        bool aSkipCollapsedWhitespace) {
   MOZ_ASSERT(aFrame, "NULL frame pointer");
 
   if (!aFrame->IsTextFrame()) {
     return;
   }
 
   if (!aFrame->StyleVisibility()->IsVisible()) {
     return;
@@ -7910,18 +7975,19 @@ static nscoord MinimumFontSizeFor(nsPres
     float deviceISizeInches =
         aWritingMode.IsVertical() ? screenSize.height : screenSize.width;
     byInch =
         NSToCoordRound(aContainerISize / (deviceISizeInches * 1440 / minTwips));
   }
   return std::max(byLine, byInch);
 }
 
-/* static */ float nsLayoutUtils::FontSizeInflationInner(const nsIFrame* aFrame,
-                                                         nscoord aMinFontSize) {
+/* static */
+float nsLayoutUtils::FontSizeInflationInner(const nsIFrame* aFrame,
+                                            nscoord aMinFontSize) {
   // Note that line heights should be inflated by the same ratio as the
   // font size of the same text; thus we operate only on the font size
   // even when we're scaling a line height.
   nscoord styleFontSize = aFrame->StyleFont()->mFont.size;
   if (styleFontSize <= 0) {
     // Never scale zero font size.
     return 1.0;
   }
@@ -8070,29 +8136,30 @@ float nsLayoutUtils::FontSizeInflationFo
 
   if (!FontSizeInflationEnabled(aFrame->PresContext())) {
     return 1.0f;
   }
 
   return FontSizeInflationInner(aFrame, InflationMinFontSizeFor(aFrame));
 }
 
-/* static */ bool nsLayoutUtils::FontSizeInflationEnabled(
-    nsPresContext* aPresContext) {
+/* static */
+bool nsLayoutUtils::FontSizeInflationEnabled(nsPresContext* aPresContext) {
   nsIPresShell* presShell = aPresContext->GetPresShell();
 
   if (!presShell) {
     return false;
   }
 
   return presShell->FontSizeInflationEnabled();
 }
 
-/* static */ nsRect nsLayoutUtils::GetBoxShadowRectForFrame(
-    nsIFrame* aFrame, const nsSize& aFrameSize) {
+/* static */
+nsRect nsLayoutUtils::GetBoxShadowRectForFrame(nsIFrame* aFrame,
+                                               const nsSize& aFrameSize) {
   nsCSSShadowArray* boxShadows = aFrame->StyleEffects()->mBoxShadow;
   if (!boxShadows) {
     return nsRect();
   }
 
   nsRect inputRect(nsPoint(0, 0), aFrameSize);
 
   // According to the CSS spec, box-shadow should be based on the border box.
@@ -8125,18 +8192,19 @@ float nsLayoutUtils::FontSizeInflationFo
     tmpRect.Inflate(shadow->mSpread);
     tmpRect.Inflate(
         nsContextBoxBlur::GetBlurRadiusMargin(shadow->mRadius, A2D));
     shadows.UnionRect(shadows, tmpRect);
   }
   return shadows;
 }
 
-/* static */ bool nsLayoutUtils::GetContentViewerSize(
-    nsPresContext* aPresContext, LayoutDeviceIntSize& aOutSize) {
+/* static */
+bool nsLayoutUtils::GetContentViewerSize(nsPresContext* aPresContext,
+                                         LayoutDeviceIntSize& aOutSize) {
   nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell();
   if (!docShell) {
     return false;
   }
 
   nsCOMPtr<nsIContentViewer> cv;
   docShell->GetContentViewer(getter_AddRefs(cv));
   if (!cv) {
@@ -8184,18 +8252,18 @@ static bool UpdateCompositionBoundsForRC
     }
     aCompBounds.SizeTo(contentSize * scale);
     return true;
   }
 
   return false;
 }
 
-/* static */ nsMargin
-nsLayoutUtils::ScrollbarAreaToExcludeFromCompositionBoundsFor(
+/* static */
+nsMargin nsLayoutUtils::ScrollbarAreaToExcludeFromCompositionBoundsFor(
     nsIFrame* aScrollFrame) {
   if (!aScrollFrame || !aScrollFrame->GetScrollTargetFrame()) {
     return nsMargin();
   }
   nsPresContext* presContext = aScrollFrame->PresContext();
   nsIPresShell* presShell = presContext->GetPresShell();
   if (!presShell) {
     return nsMargin();
@@ -8211,17 +8279,18 @@ nsLayoutUtils::ScrollbarAreaToExcludeFro
   }
   nsIScrollableFrame* scrollableFrame = aScrollFrame->GetScrollTargetFrame();
   if (!scrollableFrame) {
     return nsMargin();
   }
   return scrollableFrame->GetActualScrollbarSizes();
 }
 
-/* static */ nsSize nsLayoutUtils::CalculateCompositionSizeForFrame(
+/* static */
+nsSize nsLayoutUtils::CalculateCompositionSizeForFrame(
     nsIFrame* aFrame, bool aSubtractScrollbars) {
   // If we have a scrollable frame, restrict the composition bounds to its
   // scroll port. The scroll port excludes the frame borders and the scroll
   // bars, which we don't want to be part of the composition bounds.
   nsIScrollableFrame* scrollableFrame = aFrame->GetScrollTargetFrame();
   nsRect rect = scrollableFrame ? scrollableFrame->GetScrollPortRect()
                                 : aFrame->GetRect();
   nsSize size = rect.Size();
@@ -8245,17 +8314,18 @@ nsLayoutUtils::ScrollbarAreaToExcludeFro
     nsMargin margins = ScrollbarAreaToExcludeFromCompositionBoundsFor(aFrame);
     size.width -= margins.LeftRight();
     size.height -= margins.TopBottom();
   }
 
   return size;
 }
 
-/* static */ CSSSize nsLayoutUtils::CalculateRootCompositionSize(
+/* static */
+CSSSize nsLayoutUtils::CalculateRootCompositionSize(
     nsIFrame* aFrame, bool aIsRootContentDocRootScrollFrame,
     const FrameMetrics& aMetrics) {
   if (aIsRootContentDocRootScrollFrame) {
     return ViewAs<LayerPixel>(
                aMetrics.GetCompositionBounds().Size(),
                PixelCastJustification::ParentLayerToLayerForRootComposition) *
            LayerToScreenScale(1.0f) / aMetrics.DisplayportPixelsPerCSSPixel();
   }
@@ -8305,17 +8375,18 @@ nsLayoutUtils::ScrollbarAreaToExcludeFro
   // Scrollbars are not subject to resolution scaling, so LD pixels = layer
   // pixels for them.
   rootCompositionSize.width -= margins.LeftRight();
   rootCompositionSize.height -= margins.TopBottom();
 
   return rootCompositionSize / aMetrics.DisplayportPixelsPerCSSPixel();
 }
 
-/* static */ nsRect nsLayoutUtils::CalculateScrollableRectForFrame(
+/* static */
+nsRect nsLayoutUtils::CalculateScrollableRectForFrame(
     nsIScrollableFrame* aScrollableFrame, nsIFrame* aRootFrame) {
   nsRect contentBounds;
   if (aScrollableFrame) {
     contentBounds = aScrollableFrame->GetScrollRange();
 
     nsPoint scrollPosition = aScrollableFrame->GetScrollPosition();
     if (aScrollableFrame->GetScrollStyles().mVertical ==
         StyleOverflow::Hidden) {
@@ -8331,18 +8402,18 @@ nsLayoutUtils::ScrollbarAreaToExcludeFro
     contentBounds.width += aScrollableFrame->GetScrollPortRect().width;
     contentBounds.height += aScrollableFrame->GetScrollPortRect().height;
   } else {
     contentBounds = aRootFrame->GetRect();
   }
   return contentBounds;
 }
 
-/* static */ nsRect nsLayoutUtils::CalculateExpandedScrollableRect(
-    nsIFrame* aFrame) {
+/* static */
+nsRect nsLayoutUtils::CalculateExpandedScrollableRect(nsIFrame* aFrame) {
   nsRect scrollableRect = CalculateScrollableRectForFrame(
       aFrame->GetScrollTargetFrame(), aFrame->PresShell()->GetRootFrame());
   nsSize compSize = CalculateCompositionSizeForFrame(aFrame);
 
   if (aFrame == aFrame->PresShell()->GetRootScrollFrame()) {
     // the composition size for the root scroll frame does not include the
     // local resolution, so we adjust.
     float res = aFrame->PresShell()->GetResolution();
@@ -8359,29 +8430,32 @@ nsLayoutUtils::ScrollbarAreaToExcludeFro
   if (scrollableRect.height < compSize.height) {
     scrollableRect.y = std::max(
         0, scrollableRect.y - (compSize.height - scrollableRect.height));
     scrollableRect.height = compSize.height;
   }
   return scrollableRect;
 }
 
-/* static */ void nsLayoutUtils::DoLogTestDataForPaint(
-    LayerManager* aManager, ViewID aScrollId, const std::string& aKey,
-    const std::string& aValue) {
+/* static */
+void nsLayoutUtils::DoLogTestDataForPaint(LayerManager* aManager,
+                                          ViewID aScrollId,
+                                          const std::string& aKey,
+                                          const std::string& aValue) {
   MOZ_ASSERT(nsLayoutUtils::IsAPZTestLoggingEnabled(), "don't call me");
   if (ClientLayerManager* mgr = aManager->AsClientLayerManager()) {
     mgr->LogTestDataForCurrentPaint(aScrollId, aKey, aValue);
   } else if (WebRenderLayerManager* wrlm =
                  aManager->AsWebRenderLayerManager()) {
     wrlm->LogTestDataForCurrentPaint(aScrollId, aKey, aValue);
   }
 }
 
-/* static */ bool nsLayoutUtils::IsAPZTestLoggingEnabled() {
+/* static */
+bool nsLayoutUtils::IsAPZTestLoggingEnabled() {
   return gfxPrefs::APZTestLoggingEnabled();
 }
 
 ////////////////////////////////////////
 // SurfaceFromElementResult
 
 nsLayoutUtils::SurfaceFromElementResult::SurfaceFromElementResult()
     // Use safe default values here
@@ -8494,33 +8568,36 @@ void MaybeSetupTransactionIdAllocator(la
       backendType == LayersBackend::LAYERS_WR) {
     aManager->SetTransactionIdAllocator(aPresContext->RefreshDriver());
   }
 }
 
 }  // namespace layout
 }  // namespace mozilla
 
-/* static */ bool nsLayoutUtils::IsOutlineStyleAutoEnabled() {
+/* static */
+bool nsLayoutUtils::IsOutlineStyleAutoEnabled() {
   static bool sOutlineStyleAutoEnabled;
   static bool sOutlineStyleAutoPrefCached = false;
 
   if (!sOutlineStyleAutoPrefCached) {
     sOutlineStyleAutoPrefCached = true;
     Preferences::AddBoolVarCache(&sOutlineStyleAutoEnabled,
                                  "layout.css.outline-style-auto.enabled",
                                  false);
   }
   return sOutlineStyleAutoEnabled;
 }
 
-/* static */ void nsLayoutUtils::SetBSizeFromFontMetrics(
-    const nsIFrame* aFrame, ReflowOutput& aMetrics,
-    const LogicalMargin& aFramePadding, WritingMode aLineWM,
-    WritingMode aFrameWM) {
+/* static */
+void nsLayoutUtils::SetBSizeFromFontMetrics(const nsIFrame* aFrame,
+                                            ReflowOutput& aMetrics,
+                                            const LogicalMargin& aFramePadding,
+                                            WritingMode aLineWM,
+                                            WritingMode aFrameWM) {
   RefPtr<nsFontMetrics> fm =
       nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
 
   if (fm) {
     // Compute final height of the frame.
     //
     // Do things the standard css2 way -- though it's hard to find it
     // in the css2 spec! It's actually found in the css1 spec section
@@ -8537,17 +8614,18 @@ void MaybeSetupTransactionIdAllocator(la
     NS_WARNING("Cannot get font metrics - defaulting sizes to 0");
     aMetrics.SetBlockStartAscent(aMetrics.BSize(aLineWM) = 0);
   }
   aMetrics.SetBlockStartAscent(aMetrics.BlockStartAscent() +
                                aFramePadding.BStart(aFrameWM));
   aMetrics.BSize(aLineWM) += aFramePadding.BStartEnd(aFrameWM);
 }
 
-/* static */ bool nsLayoutUtils::HasDocumentLevelListenersForApzAwareEvents(
+/* static */
+bool nsLayoutUtils::HasDocumentLevelListenersForApzAwareEvents(
     nsIPresShell* aShell) {
   if (Document* doc = aShell->GetDocument()) {
     WidgetEvent event(true, eVoidEvent);
     nsTArray<EventTarget*> targets;
     nsresult rv = EventDispatcher::Dispatch(
         ToSupports(doc), nullptr, &event, nullptr, nullptr, nullptr, &targets);
     NS_ENSURE_SUCCESS(rv, false);
     for (size_t i = 0; i < targets.Length(); i++) {
@@ -8593,40 +8671,42 @@ static void MaybeReflowForInflationScree
             }
           }
         }
       }
     }
   }
 }
 
-/* static */ void nsLayoutUtils::SetVisualViewportSize(nsIPresShell* aPresShell,
-                                                       CSSSize aSize) {
+/* static */
+void nsLayoutUtils::SetVisualViewportSize(nsIPresShell* aPresShell,
+                                          CSSSize aSize) {
   MOZ_ASSERT(aSize.width >= 0.0 && aSize.height >= 0.0);
 
   aPresShell->SetVisualViewportSize(
       nsPresContext::CSSPixelsToAppUnits(aSize.width),
       nsPresContext::CSSPixelsToAppUnits(aSize.height));
 
   // When the "font.size.inflation.minTwips" preference is set, the
   // layout depends on the size of the screen.  Since when the size
   // of the screen changes, the scroll position clamping scroll port
   // size also changes, we hook in the needed updates here rather
   // than adding a separate notification just for this change.
   nsPresContext* presContext = aPresShell->GetPresContext();
   MaybeReflowForInflationScreenSizeChange(presContext);
 }
 
-/* static */ bool nsLayoutUtils::CanScrollOriginClobberApz(
-    nsAtom* aScrollOrigin) {
+/* static */
+bool nsLayoutUtils::CanScrollOriginClobberApz(nsAtom* aScrollOrigin) {
   return aScrollOrigin != nullptr && aScrollOrigin != nsGkAtoms::apz &&
          aScrollOrigin != nsGkAtoms::restore;
 }
 
-/* static */ ScrollMetadata nsLayoutUtils::ComputeScrollMetadata(
+/* static */
+ScrollMetadata nsLayoutUtils::ComputeScrollMetadata(
     nsIFrame* aForFrame, nsIFrame* aScrollFrame, nsIContent* aContent,
     const nsIFrame* aReferenceFrame, LayerManager* aLayerManager,
     ViewID aScrollParentId, const nsRect& aViewport,
     const Maybe<nsRect>& aClipRect, bool aIsRootContent,
     const Maybe<ContainerLayerParameters>& aContainerParameters) {
   nsPresContext* presContext = aForFrame->PresContext();
   int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
 
@@ -8957,17 +9037,18 @@ static void MaybeReflowForInflationScree
 
   if (ShouldDisableApzForElement(aContent)) {
     metadata.SetForceDisableApz(true);
   }
 
   return metadata;
 }
 
-/*static*/ Maybe<ScrollMetadata> nsLayoutUtils::GetRootMetadata(
+/*static*/
+Maybe<ScrollMetadata> nsLayoutUtils::GetRootMetadata(
     nsDisplayListBuilder* aBuilder, LayerManager* aLayerManager,
     const ContainerLayerParameters& aContainerParameters,
     const std::function<bool(ViewID& aScrollId)>& aCallback) {
   nsIFrame* frame = aBuilder->RootReferenceFrame();
   nsPresContext* presContext = frame->PresContext();
   nsIPresShell* presShell = presContext->PresShell();
   Document* document = presShell->GetDocument();
 
@@ -9017,33 +9098,35 @@ static void MaybeReflowForInflationScree
         frame, rootScrollFrame, content, aBuilder->FindReferenceFrameFor(frame),
         aLayerManager, ScrollableLayerGuid::NULL_SCROLL_ID, viewport, Nothing(),
         isRootContent, Some(aContainerParameters)));
   }
 
   return Nothing();
 }
 
-/* static */ bool nsLayoutUtils::ContainsMetricsWithId(
-    const Layer* aLayer, const ViewID& aScrollId) {
+/* static */
+bool nsLayoutUtils::ContainsMetricsWithId(const Layer* aLayer,
+                                          const ViewID& aScrollId) {
   for (uint32_t i = aLayer->GetScrollMetadataCount(); i > 0; i--) {
     if (aLayer->GetFrameMetrics(i - 1).GetScrollId() == aScrollId) {
       return true;
     }
   }
   for (Layer* child = aLayer->GetFirstChild(); child;
        child = child->GetNextSibling()) {
     if (ContainsMetricsWithId(child, aScrollId)) {
       return true;
     }
   }
   return false;
 }
 
-/* static */ uint32_t nsLayoutUtils::GetTouchActionFromFrame(nsIFrame* aFrame) {
+/* static */
+uint32_t nsLayoutUtils::GetTouchActionFromFrame(nsIFrame* aFrame) {
   // If aFrame is null then return default value
   if (!aFrame) {
     return NS_STYLE_TOUCH_ACTION_AUTO;
   }
 
   // The touch-action CSS property applies to: all elements except:
   // non-replaced inline elements, table rows, row groups, table columns, and
   // column groups
@@ -9057,17 +9140,18 @@ static void MaybeReflowForInflationScree
   bool isTableElement = disp->IsInternalTableStyleExceptCell();
   if (isTableElement) {
     return NS_STYLE_TOUCH_ACTION_AUTO;
   }
 
   return disp->mTouchAction;
 }
 
-/* static */ void nsLayoutUtils::TransformToAncestorAndCombineRegions(
+/* static */
+void nsLayoutUtils::TransformToAncestorAndCombineRegions(
     const nsRegion& aRegion, nsIFrame* aFrame, const nsIFrame* aAncestorFrame,
     nsRegion* aPreciseTargetDest, nsRegion* aImpreciseTargetDest,
     Maybe<Matrix4x4Flagged>* aMatrixCache, const DisplayItemClip* aClip) {
   if (aRegion.IsEmpty()) {
     return;
   }
   bool isPrecise;
   RegionBuilder<nsRegion> transformedRegion;
@@ -9092,42 +9176,45 @@ static void MaybeReflowForInflationScree
       aPreciseTargetDest->OrWith(*aImpreciseTargetDest);
       *aImpreciseTargetDest = std::move(*aPreciseTargetDest);
       aImpreciseTargetDest->SimplifyOutward(6);
       *aPreciseTargetDest = nsRegion();
     }
   }
 }
 
-/* static */ bool nsLayoutUtils::ShouldUseNoScriptSheet(Document* aDocument) {
+/* static */
+bool nsLayoutUtils::ShouldUseNoScriptSheet(Document* aDocument) {
   // also handle the case where print is done from print preview
   // see bug #342439 for more details
   if (aDocument->IsStaticDocument()) {
     aDocument = aDocument->GetOriginalDocument();
   }
   return aDocument->IsScriptEnabled();
 }
 
-/* static */ bool nsLayoutUtils::ShouldUseNoFramesSheet(Document* aDocument) {
+/* static */
+bool nsLayoutUtils::ShouldUseNoFramesSheet(Document* aDocument) {
   bool allowSubframes = true;
   nsIDocShell* docShell = aDocument->GetDocShell();
   if (docShell) {
     docShell->GetAllowSubframes(&allowSubframes);
   }
   return !allowSubframes;
 }
 
-/* static */ void nsLayoutUtils::GetFrameTextContent(nsIFrame* aFrame,
-                                                     nsAString& aResult) {
+/* static */
+void nsLayoutUtils::GetFrameTextContent(nsIFrame* aFrame, nsAString& aResult) {
   aResult.Truncate();
   AppendFrameTextContent(aFrame, aResult);
 }
 
-/* static */ void nsLayoutUtils::AppendFrameTextContent(nsIFrame* aFrame,
-                                                        nsAString& aResult) {
+/* static */
+void nsLayoutUtils::AppendFrameTextContent(nsIFrame* aFrame,
+                                           nsAString& aResult) {
   if (aFrame->IsTextFrame()) {
     auto textFrame = static_cast<nsTextFrame*>(aFrame);
     auto offset = textFrame->GetContentOffset();
     auto length = textFrame->GetContentLength();
     textFrame->GetContent()->GetText()->AppendTo(aResult, offset, length);
   } else {
     for (nsIFrame* child : aFrame->PrincipalChildList()) {
       AppendFrameTextContent(child, aResult);
@@ -9159,30 +9246,31 @@ nsRect nsLayoutUtils::GetSelectionBoundi
     }
     res = accumulator.mResultRect.IsEmpty() ? accumulator.mFirstRect
                                             : accumulator.mResultRect;
   }
 
   return res;
 }
 
-/* static */ nsBlockFrame* nsLayoutUtils::GetFloatContainingBlock(
-    nsIFrame* aFrame) {
+/* static */
+nsBlockFrame* nsLayoutUtils::GetFloatContainingBlock(nsIFrame* aFrame) {
   nsIFrame* ancestor = aFrame->GetParent();
   while (ancestor && !ancestor->IsFloatContainingBlock()) {
     ancestor = ancestor->GetParent();
   }
   MOZ_ASSERT(!ancestor || ancestor->IsBlockFrameOrSubclass(),
              "Float containing block can only be block frame");
   return static_cast<nsBlockFrame*>(ancestor);
 }
 
 // The implementation of this calculation is adapted from
 // Element::GetBoundingClientRect().
-/* static */ CSSRect nsLayoutUtils::GetBoundingContentRect(
+/* static */
+CSSRect nsLayoutUtils::GetBoundingContentRect(
     const nsIContent* aContent, const nsIScrollableFrame* aRootScrollFrame) {
   CSSRect result;
   if (nsIFrame* frame = aContent->GetPrimaryFrame()) {
     nsIFrame* relativeTo = aRootScrollFrame->GetScrolledFrame();
     result = CSSRect::FromAppUnits(nsLayoutUtils::GetAllInFlowRectsUnion(
         frame, relativeTo, nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS));
 
     // If the element is contained in a scrollable frame that is not
@@ -9258,17 +9346,18 @@ static void UpdateDisplayPortMarginsForP
       CSSPoint::FromAppUnits(frame->GetScrollPosition());
   ScreenMargin displayPortMargins =
       APZCCallbackHelper::AdjustDisplayPortForScrollDelta(aMetrics,
                                                           frameScrollOffset);
 
   nsLayoutUtils::SetDisplayPortMargins(content, shell, displayPortMargins, 0);
 }
 
-/* static */ void nsLayoutUtils::UpdateDisplayPortMarginsFromPendingMessages() {
+/* static */
+void nsLayoutUtils::UpdateDisplayPortMarginsFromPendingMessages() {
   if (XRE_IsContentProcess() && mozilla::layers::CompositorBridgeChild::Get() &&
       mozilla::layers::CompositorBridgeChild::Get()->GetIPCChannel()) {
     CompositorBridgeChild::Get()->GetIPCChannel()->PeekMessages(
         [](const IPC::Message& aMsg) -> bool {
           if (aMsg.type() ==
               mozilla::layers::PAPZ::Msg_RequestContentRepaint__ID) {
             PickleIterator iter(aMsg);
             RepaintRequest request;
@@ -9279,28 +9368,28 @@ static void UpdateDisplayPortMarginsForP
 
             UpdateDisplayPortMarginsForPendingMetrics(request);
           }
           return true;
         });
   }
 }
 
-/* static */ bool nsLayoutUtils::IsTransformed(nsIFrame* aForFrame,
-                                               nsIFrame* aTopFrame) {
+/* static */
+bool nsLayoutUtils::IsTransformed(nsIFrame* aForFrame, nsIFrame* aTopFrame) {
   for (nsIFrame* f = aForFrame; f != aTopFrame; f = f->GetParent()) {
     if (f->IsTransformed()) {
       return true;
     }
   }
   return false;
 }
 
-/*static*/ CSSPoint nsLayoutUtils::GetCumulativeApzCallbackTransform(
-    nsIFrame* aFrame) {
+/*static*/
+CSSPoint nsLayoutUtils::GetCumulativeApzCallbackTransform(nsIFrame* aFrame) {
   CSSPoint delta;
   if (!aFrame) {
     return delta;
   }
   nsIFrame* frame = aFrame;
   nsCOMPtr<nsIContent> content = frame->GetContent();
   nsCOMPtr<nsIContent> lastContent;
   while (frame) {
@@ -9312,17 +9401,18 @@ static void UpdateDisplayPortMarginsForP
     }
     frame = GetCrossDocParentFrame(frame);
     lastContent = content;
     content = frame ? frame->GetContent() : nullptr;
   }
   return delta;
 }
 
-/* static */ nsRect nsLayoutUtils::ComputePartialPrerenderArea(
+/* static */
+nsRect nsLayoutUtils::ComputePartialPrerenderArea(
     const nsRect& aDirtyRect, const nsRect& aOverflow,
     const nsSize& aPrerenderSize) {
   // Simple calculation for now: center the pre-render area on the dirty rect,
   // and clamp to the overflow area. Later we can do more advanced things like
   // redistributing from one axis to another, or from one side to another.
   nscoord xExcess = std::max(aPrerenderSize.width - aDirtyRect.width, 0);
   nscoord yExcess = std::max(aPrerenderSize.height - aDirtyRect.height, 0);
   nsRect result = aDirtyRect;
@@ -9353,18 +9443,19 @@ static bool LineHasNonEmptyContent(nsLin
        --count, frame = frame->GetNextSibling()) {
     if (LineHasNonEmptyContentWorker(frame)) {
       return true;
     }
   }
   return false;
 }
 
-/* static */ bool nsLayoutUtils::IsInvisibleBreak(nsINode* aNode,
-                                                  nsIFrame** aNextLineFrame) {
+/* static */
+bool nsLayoutUtils::IsInvisibleBreak(nsINode* aNode,
+                                     nsIFrame** aNextLineFrame) {
   if (aNextLineFrame) {
     *aNextLineFrame = nullptr;
   }
 
   if (!aNode->IsElement() || !aNode->IsEditable()) {
     return false;
   }
   nsIFrame* frame = aNode->AsElement()->GetPrimaryFrame();
@@ -9507,30 +9598,32 @@ static nsRect ComputeHTMLReferenceRect(n
       MOZ_ASSERT_UNREACHABLE("unknown StyleGeometryBox type");
       r = aFrame->GetRectRelativeToSelf();
       break;
   }
 
   return r;
 }
 
-/* static */ nsRect nsLayoutUtils::ComputeGeometryBox(
-    nsIFrame* aFrame, StyleGeometryBox aGeometryBox) {
+/* static */
+nsRect nsLayoutUtils::ComputeGeometryBox(nsIFrame* aFrame,
+                                         StyleGeometryBox aGeometryBox) {
   // We use ComputeSVGReferenceRect for all SVG elements, except <svg>
   // element, which does have an associated CSS layout box. In this case we
   // should still use ComputeHTMLReferenceRect for region computing.
   nsRect r = (aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT)
                  ? ComputeSVGReferenceRect(aFrame, aGeometryBox)
                  : ComputeHTMLReferenceRect(aFrame, aGeometryBox);
 
   return r;
 }
 
-/* static */ nsPoint nsLayoutUtils::ComputeOffsetToUserSpace(
-    nsDisplayListBuilder* aBuilder, nsIFrame* aFrame) {
+/* static */
+nsPoint nsLayoutUtils::ComputeOffsetToUserSpace(nsDisplayListBuilder* aBuilder,
+                                                nsIFrame* aFrame) {
   nsPoint offsetToBoundingBox =
       aBuilder->ToReferenceFrame(aFrame) -
       nsSVGIntegrationUtils::GetOffsetToBoundingBox(aFrame);
   if (!aFrame->IsFrameOfType(nsIFrame::eSVG)) {
     // Snap the offset if the reference frame is not a SVG frame, since other
     // frames will be snapped to pixel when rendering.
     offsetToBoundingBox =
         nsPoint(aFrame->PresContext()->RoundAppUnitsToNearestDevPixels(
@@ -9555,17 +9648,18 @@ static nsRect ComputeHTMLReferenceRect(n
       nsSVGUtils::FrameSpaceInCSSPxToUserSpaceOffset(aFrame);
   nsPoint toUserSpace =
       nsPoint(nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.x)),
               nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.y)));
 
   return (offsetToBoundingBox - toUserSpace);
 }
 
-/* static */ uint8_t nsLayoutUtils::ControlCharVisibilityDefault() {
+/* static */
+uint8_t nsLayoutUtils::ControlCharVisibilityDefault() {
   return StaticPrefs::layout_css_control_characters_visible()
              ? NS_STYLE_CONTROL_CHARACTER_VISIBILITY_VISIBLE
              : NS_STYLE_CONTROL_CHARACTER_VISIBILITY_HIDDEN;
 }
 
 /* static */
 already_AddRefed<nsFontMetrics> nsLayoutUtils::GetMetricsFor(
     nsPresContext* aPresContext, bool aIsVertical,
@@ -9580,18 +9674,19 @@ already_AddRefed<nsFontMetrics> nsLayout
   params.orientation = orientation;
   params.userFontSet =
       aUseUserFontSet ? aPresContext->GetUserFontSet() : nullptr;
   params.textPerf = aPresContext->GetTextPerfMetrics();
   params.featureValueLookup = aPresContext->GetFontFeatureValuesLookup();
   return aPresContext->DeviceContext()->GetMetricsFor(font, params);
 }
 
-/* static */ void nsLayoutUtils::FixupNoneGeneric(
-    nsFont* aFont, uint8_t aGenericFontID, const nsFont* aDefaultVariableFont) {
+/* static */
+void nsLayoutUtils::FixupNoneGeneric(nsFont* aFont, uint8_t aGenericFontID,
+                                     const nsFont* aDefaultVariableFont) {
   bool useDocumentFonts = StaticPrefs::browser_display_use_document_fonts();
   if (aGenericFontID == kGenericFont_NONE ||
       (!useDocumentFonts && (aGenericFontID == kGenericFont_cursive ||
                              aGenericFontID == kGenericFont_fantasy))) {
     FontFamilyType defaultGeneric =
         aDefaultVariableFont->fontlist.GetDefaultFontType();
     MOZ_ASSERT(aDefaultVariableFont->fontlist.IsEmpty() &&
                (defaultGeneric == eFamily_serif ||
@@ -9607,19 +9702,20 @@ already_AddRefed<nsFontMetrics> nsLayout
         }
       }
     }
   } else {
     aFont->fontlist.SetDefaultFontType(eFamily_none);
   }
 }
 
-/* static */ void nsLayoutUtils::ApplyMinFontSize(nsStyleFont* aFont,
-                                                  const Document* aDocument,
-                                                  nscoord aMinFontSize) {
+/* static */
+void nsLayoutUtils::ApplyMinFontSize(nsStyleFont* aFont,
+                                     const Document* aDocument,
+                                     nscoord aMinFontSize) {
   nscoord fontSize = aFont->mSize;
 
   // enforce the user' specified minimum font-size on the value that we expose
   // (but don't change font-size:0, since that would unhide hidden text)
   if (fontSize > 0) {
     if (aMinFontSize < 0) {
       aMinFontSize = 0;
     } else {
@@ -9628,19 +9724,20 @@ already_AddRefed<nsFontMetrics> nsLayout
     if (fontSize < aMinFontSize && !nsContentUtils::IsChromeDoc(aDocument)) {
       // override the minimum font-size constraint
       fontSize = aMinFontSize;
     }
   }
   aFont->mFont.size = fontSize;
 }
 
-/* static */ void nsLayoutUtils::ComputeSystemFont(
-    nsFont* aSystemFont, LookAndFeel::FontID aFontID,
-    const nsFont* aDefaultVariableFont) {
+/* static */
+void nsLayoutUtils::ComputeSystemFont(nsFont* aSystemFont,
+                                      LookAndFeel::FontID aFontID,
+                                      const nsFont* aDefaultVariableFont) {
   gfxFontStyle fontStyle;
   nsAutoString systemFontName;
   if (LookAndFeel::GetFont(aFontID, systemFontName, fontStyle)) {
     systemFontName.Trim("\"'");
     aSystemFont->fontlist =
         FontFamilyList(NS_ConvertUTF16toUTF8(systemFontName), eUnquotedName);
     aSystemFont->fontlist.SetDefaultFontType(eFamily_none);
     aSystemFont->style = fontStyle.style;
@@ -9674,17 +9771,18 @@ already_AddRefed<nsFontMetrics> nsLayout
       aSystemFont->size = std::max(
           aDefaultVariableFont->size - nsPresContext::CSSPointsToAppUnits(2),
           0);
     }
 #endif
   }
 }
 
-/* static */ bool nsLayoutUtils::ShouldHandleMetaViewport(Document* aDocument) {
+/* static */
+bool nsLayoutUtils::ShouldHandleMetaViewport(Document* aDocument) {
   auto metaViewportOverride = nsIDocShell::META_VIEWPORT_OVERRIDE_NONE;
   if (aDocument) {
     if (nsIDocShell* docShell = aDocument->GetDocShell()) {
       metaViewportOverride = docShell->GetMetaViewportOverride();
     }
   }
   switch (metaViewportOverride) {
     case nsIDocShell::META_VIEWPORT_OVERRIDE_ENABLED:
@@ -9695,18 +9793,18 @@ already_AddRefed<nsFontMetrics> nsLayout
       MOZ_ASSERT(metaViewportOverride ==
                  nsIDocShell::META_VIEWPORT_OVERRIDE_NONE);
       // The META_VIEWPORT_OVERRIDE_NONE case means that there is no override
       // and we rely solely on the gfxPrefs.
       return gfxPrefs::MetaViewportEnabled();
   }
 }
 
-/* static */ ComputedStyle* nsLayoutUtils::StyleForScrollbar(
-    nsIFrame* aScrollbarPart) {
+/* static */
+ComputedStyle* nsLayoutUtils::StyleForScrollbar(nsIFrame* aScrollbarPart) {
   // Get the closest content node which is not an anonymous scrollbar
   // part. It should be the originating element of the scrollbar part.
   nsIContent* content = aScrollbarPart->GetContent();
   // Note that the content may be a normal element with scrollbar part
   // value specified for its -moz-appearance, so don't rely on it being
   // a native anonymous. Also note that we have to check the node name
   // because anonymous element like generated content may originate a
   // scrollbar.
@@ -9738,18 +9836,18 @@ already_AddRefed<nsFontMetrics> nsLayout
              "path to be triggered");
   RefPtr<ComputedStyle> style =
       pc->StyleSet()->ResolveServoStyle(*content->AsElement());
   // Dropping the strong reference is fine because the style should be
   // held strongly by the element.
   return style.get();
 }
 
-/* static */ Maybe<MotionPathData> nsLayoutUtils::ResolveMotionPath(
-    const nsIFrame* aFrame) {
+/* static */
+Maybe<MotionPathData> nsLayoutUtils::ResolveMotionPath(const nsIFrame* aFrame) {
   MOZ_ASSERT(aFrame);
 
   const nsStyleDisplay* display = aFrame->StyleDisplay();
   if (!display->mMotion || !display->mMotion->HasPath()) {
     return Nothing();
   }
 
   const UniquePtr<StyleMotion>& motion = display->mMotion;
--- a/layout/base/nsPresContext.cpp
+++ b/layout/base/nsPresContext.cpp
@@ -1280,17 +1280,18 @@ bool nsPresContext::ElementWouldPropagat
 }
 
 nsISupports* nsPresContext::GetContainerWeak() const { return GetDocShell(); }
 
 nsIDocShell* nsPresContext::GetDocShell() const {
   return mDocument->GetDocShell();
 }
 
-/* virtual */ void nsPresContext::Detach() { SetLinkHandler(nullptr); }
+/* virtual */
+void nsPresContext::Detach() { SetLinkHandler(nullptr); }
 
 bool nsPresContext::BidiEnabled() const { return Document()->GetBidiEnabled(); }
 
 void nsPresContext::SetBidiEnabled() const { Document()->SetBidiEnabled(); }
 
 void nsPresContext::SetBidi(uint32_t aSource) {
   // Don't do all this stuff unless the options have changed.
   if (aSource == GetBidi()) {
@@ -1518,17 +1519,18 @@ void nsPresContext::UIResolutionChanged(
 
 void nsPresContext::UIResolutionChangedSync() {
   if (!mPendingUIResolutionChanged) {
     mPendingUIResolutionChanged = true;
     UIResolutionChangedInternalScale(0.0);
   }
 }
 
-/*static*/ bool nsPresContext::UIResolutionChangedSubdocumentCallback(
+/*static*/
+bool nsPresContext::UIResolutionChangedSubdocumentCallback(
     dom::Document* aDocument, void* aData) {
   nsPresContext* pc = aDocument->GetPresContext();
   if (pc) {
     // For subdocuments, we want to apply the parent's scale, because there
     // are cases where the subdoc's device context is connected to a widget
     // that has an out-of-date resolution (it's on a different screen, but
     // currently hidden, and will not be updated until shown): bug 1249279.
     double scale = *static_cast<double*>(aData);
@@ -2054,18 +2056,19 @@ void nsPresContext::NotifyInvalidation(T
     }
   }
 
   TransactionInvalidations* transaction = GetInvalidations(aTransactionId);
   MOZ_ASSERT(transaction);
   transaction->mInvalidations.AppendElement(aRect);
 }
 
-/* static */ void nsPresContext::NotifySubDocInvalidation(
-    ContainerLayer* aContainer, const nsIntRegion* aRegion) {
+/* static */
+void nsPresContext::NotifySubDocInvalidation(ContainerLayer* aContainer,
+                                             const nsIntRegion* aRegion) {
   ContainerLayerPresContext* data = static_cast<ContainerLayerPresContext*>(
       aContainer->GetUserData(&gNotifySubDocInvalidationData));
   if (!data) {
     return;
   }
 
   TransactionId transactionId = aContainer->Manager()->GetLastTransactionId();
   IntRect visibleBounds =
@@ -2090,17 +2093,18 @@ void nsPresContext::NotifyInvalidation(T
 
 void nsPresContext::SetNotifySubDocInvalidationData(
     ContainerLayer* aContainer) {
   ContainerLayerPresContext* pres = new ContainerLayerPresContext;
   pres->mPresContext = this;
   aContainer->SetUserData(&gNotifySubDocInvalidationData, pres);
 }
 
-/* static */ void nsPresContext::ClearNotifySubDocInvalidationData(
+/* static */
+void nsPresContext::ClearNotifySubDocInvalidationData(
     ContainerLayer* aContainer) {
   aContainer->SetUserData(&gNotifySubDocInvalidationData, nullptr);
 }
 
 struct NotifyDidPaintSubdocumentCallbackClosure {
   TransactionId mTransactionId;
   const mozilla::TimeStamp& mTimeStamp;
 };
@@ -2576,17 +2580,18 @@ nsRootPresContext::nsRootPresContext(dom
     : nsPresContext(aDocument, aType) {}
 
 nsRootPresContext::~nsRootPresContext() {
   NS_ASSERTION(mRegisteredPlugins.Count() == 0,
                "All plugins should have been unregistered");
   CancelApplyPluginGeometryTimer();
 }
 
-/* virtual */ void nsRootPresContext::Detach() {
+/* virtual */
+void nsRootPresContext::Detach() {
   // XXXmats maybe also CancelApplyPluginGeometryTimer(); ?
   nsPresContext::Detach();
 }
 
 void nsRootPresContext::RegisterPluginForGeometryUpdates(nsIContent* aPlugin) {
   mRegisteredPlugins.PutEntry(aPlugin);
 }
 
--- a/layout/base/nsRefreshDriver.cpp
+++ b/layout/base/nsRefreshDriver.cpp
@@ -1002,23 +1002,25 @@ static uint32_t GetFirstFrameDelay(imgIR
 
   // If this image isn't animated, there isn't a first frame delay.
   int32_t delay = container->GetFirstFrameDelay();
   if (delay < 0) return 0;
 
   return static_cast<uint32_t>(delay);
 }
 
-/* static */ void nsRefreshDriver::Shutdown() {
+/* static */
+void nsRefreshDriver::Shutdown() {
   // clean up our timers
   sRegularRateTimer = nullptr;
   sThrottledRateTimer = nullptr;
 }
 
-/* static */ int32_t nsRefreshDriver::DefaultInterval() {
+/* static */
+int32_t nsRefreshDriver::DefaultInterval() {
   return NSToIntRound(1000.0 / gfxPlatform::GetDefaultFrameRate());
 }
 
 // Compute the interval to use for the refresh driver timer, in milliseconds.
 // outIsDefault indicates that rate was not explicitly set by the user
 // so we might choose other, more appropriate rates (e.g. vsync, etc)
 // layout.frame_rate=0 indicates "ASAP mode".
 // In ASAP mode rendering is iterated as fast as possible (typically for stress
@@ -1031,17 +1033,18 @@ double nsRefreshDriver::GetRegularTimerI
     rate = gfxPlatform::GetDefaultFrameRate();
   } else if (rate == 0) {
     rate = 10000;
   }
 
   return 1000.0 / rate;
 }
 
-/* static */ double nsRefreshDriver::GetThrottledTimerInterval() {
+/* static */
+double nsRefreshDriver::GetThrottledTimerInterval() {
   int32_t rate = Preferences::GetInt("layout.throttled_frame_rate", -1);
   if (rate <= 0) {
     rate = DEFAULT_THROTTLED_FRAME_RATE;
   }
   return 1000.0 / rate;
 }
 
 /* static */ mozilla::TimeDuration
@@ -2263,17 +2266,18 @@ void nsRefreshDriver::SetThrottled(bool 
     if (mActiveTimer) {
       // We want to switch our timer type here, so just stop and
       // restart the timer.
       EnsureTimerStarted(eForceAdjustTimer);
     }
   }
 }
 
-/*static*/ void nsRefreshDriver::PVsyncActorCreated(VsyncChild* aVsyncChild) {
+/*static*/
+void nsRefreshDriver::PVsyncActorCreated(VsyncChild* aVsyncChild) {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!XRE_IsParentProcess());
   RefPtr<RefreshDriverTimer> vsyncRefreshDriverTimer =
       new VsyncRefreshDriverTimer(aVsyncChild);
 
   // If we are using software timer, swap current timer to
   // VsyncRefreshDriverTimer.
   if (sRegularRateTimer) {
@@ -2345,35 +2349,36 @@ void nsRefreshDriver::CancelPendingFulls
 
 void nsRefreshDriver::CancelPendingAnimationEvents(
     AnimationEventDispatcher* aDispatcher) {
   MOZ_ASSERT(aDispatcher);
   aDispatcher->ClearEventQueue();
   mAnimationEventFlushObservers.RemoveElement(aDispatcher);
 }
 
-/* static */ TimeStamp nsRefreshDriver::GetIdleDeadlineHint(
-    TimeStamp aDefault) {
+/* static */
+TimeStamp nsRefreshDriver::GetIdleDeadlineHint(TimeStamp aDefault) {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!aDefault.IsNull());
 
   if (!sRegularRateTimer) {
     return aDefault;
   }
 
   // For computing idleness of refresh drivers we only care about
   // sRegularRateTimer, since we consider refresh drivers attached to
   // sThrottledRateTimer to be inactive. This implies that tasks
   // resulting from a tick on the sRegularRateTimer counts as being
   // busy but tasks resulting from a tick on sThrottledRateTimer
   // counts as being idle.
   return sRegularRateTimer->GetIdleDeadlineHint(aDefault);
 }
 
-/* static */ Maybe<TimeStamp> nsRefreshDriver::GetNextTickHint() {
+/* static */
+Maybe<TimeStamp> nsRefreshDriver::GetNextTickHint() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!sRegularRateTimer) {
     return Nothing();
   }
   return sRegularRateTimer->GetNextTickHint();
 }
 
@@ -2385,19 +2390,21 @@ void nsRefreshDriver::Disconnect() {
   if (mPresContext) {
     mPresContext = nullptr;
     if (--sRefreshDriverCount == 0) {
       Shutdown();
     }
   }
 }
 
-/* static */ bool nsRefreshDriver::IsJankCritical() {
+/* static */
+bool nsRefreshDriver::IsJankCritical() {
   MOZ_ASSERT(NS_IsMainThread());
   return sActiveVsyncTimers > 0;
 }
 
-/* static */ bool nsRefreshDriver::GetJankLevels(Vector<uint64_t>& aJank) {
+/* static */
+bool nsRefreshDriver::GetJankLevels(Vector<uint64_t>& aJank) {
   aJank.clear();
   return aJank.append(sJankLevels, ArrayLength(sJankLevels));
 }
 
 #undef LOG
--- a/layout/build/nsContentDLF.cpp
+++ b/layout/build/nsContentDLF.cpp
@@ -254,17 +254,18 @@ nsContentDLF::CreateInstanceForDocument(
   nsCOMPtr<nsIContentViewer> contentViewer = NS_NewContentViewer();
 
   // Bind the document to the Content Viewer
   contentViewer->LoadStart(aDocument);
   contentViewer.forget(aContentViewer);
   return NS_OK;
 }
 
-/* static */ already_AddRefed<Document> nsContentDLF::CreateBlankDocument(
+/* static */
+already_AddRefed<Document> nsContentDLF::CreateBlankDocument(
     nsILoadGroup* aLoadGroup, nsIPrincipal* aPrincipal,
     nsDocShell* aContainer) {
   // create a new blank HTML document
   RefPtr<Document> blankDoc;
   mozilla::Unused << NS_NewHTMLDocument(getter_AddRefs(blankDoc));
 
   if (!blankDoc) {
     return nullptr;
--- a/layout/forms/nsCheckboxRadioFrame.cpp
+++ b/layout/forms/nsCheckboxRadioFrame.cpp
@@ -40,26 +40,26 @@ void nsCheckboxRadioFrame::DestroyFrom(n
 }
 
 NS_IMPL_FRAMEARENA_HELPERS(nsCheckboxRadioFrame)
 
 NS_QUERYFRAME_HEAD(nsCheckboxRadioFrame)
   NS_QUERYFRAME_ENTRY(nsIFormControlFrame)
 NS_QUERYFRAME_TAIL_INHERITING(nsAtomicContainerFrame)
 
-/* virtual */ nscoord nsCheckboxRadioFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsCheckboxRadioFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_MIN_INLINE_SIZE(this, result);
   result = StyleDisplay()->HasAppearance() ? DefaultSize() : 0;
   return result;
 }
 
-/* virtual */ nscoord nsCheckboxRadioFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsCheckboxRadioFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_PREF_INLINE_SIZE(this, result);
   result = StyleDisplay()->HasAppearance() ? DefaultSize() : 0;
   return result;
 }
 
 /* virtual */
 LogicalSize nsCheckboxRadioFrame::ComputeAutoSize(
--- a/layout/forms/nsNumberControlFrame.cpp
+++ b/layout/forms/nsNumberControlFrame.cpp
@@ -412,18 +412,19 @@ nsresult nsNumberControlFrame::SetFormPr
                                                const nsAString& aValue) {
   return GetTextFieldFrame()->SetFormProperty(aName, aValue);
 }
 
 HTMLInputElement* nsNumberControlFrame::GetAnonTextControl() {
   return HTMLInputElement::FromNode(mTextField);
 }
 
-/* static */ nsNumberControlFrame*
-nsNumberControlFrame::GetNumberControlFrameForTextField(nsIFrame* aFrame) {
+/* static */
+nsNumberControlFrame* nsNumberControlFrame::GetNumberControlFrameForTextField(
+    nsIFrame* aFrame) {
   // If aFrame is the anon text field for an <input type=number> then we expect
   // the frame of its mContent's grandparent to be that input's frame. We
   // have to check for this via the content tree because we don't know whether
   // extra frames will be wrapped around any of the elements between aFrame and
   // the nsNumberControlFrame that we're looking for (e.g. flex wrappers).
   nsIContent* content = aFrame->GetContent();
   if (content->IsInNativeAnonymousSubtree() && content->GetParent() &&
       content->GetParent()->GetParent()) {
@@ -433,18 +434,19 @@ nsNumberControlFrame::GetNumberControlFr
             kNameSpaceID_None, nsGkAtoms::type, nsGkAtoms::number,
             eCaseMatters)) {
       return do_QueryFrame(grandparent->GetPrimaryFrame());
     }
   }
   return nullptr;
 }
 
-/* static */ nsNumberControlFrame*
-nsNumberControlFrame::GetNumberControlFrameForSpinButton(nsIFrame* aFrame) {
+/* static */
+nsNumberControlFrame* nsNumberControlFrame::GetNumberControlFrameForSpinButton(
+    nsIFrame* aFrame) {
   // If aFrame is a spin button for an <input type=number> then we expect the
   // frame of its mContent's great-grandparent to be that input's frame. We
   // have to check for this via the content tree because we don't know whether
   // extra frames will be wrapped around any of the elements between aFrame and
   // the nsNumberControlFrame that we're looking for (e.g. flex wrappers).
   nsIContent* content = aFrame->GetContent();
   if (content->IsInNativeAnonymousSubtree() && content->GetParent() &&
       content->GetParent()->GetParent() &&
--- a/layout/generic/BRFrame.cpp
+++ b/layout/generic/BRFrame.cpp
@@ -164,39 +164,43 @@ void BRFrame::Reflow(nsPresContext* aPre
   aMetrics.SetSize(wm, finalSize);
   aMetrics.SetOverflowAreasToDesiredBounds();
 
   mAscent = aMetrics.BlockStartAscent();
 
   NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
 }
 
-/* virtual */ void BRFrame::AddInlineMinISize(
-    gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
+/* virtual */
+void BRFrame::AddInlineMinISize(gfxContext* aRenderingContext,
+                                nsIFrame::InlineMinISizeData* aData) {
   if (!GetParent()->Style()->ShouldSuppressLineBreak()) {
     aData->ForceBreak();
   }
 }
 
-/* virtual */ void BRFrame::AddInlinePrefISize(
-    gfxContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) {
+/* virtual */
+void BRFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
+                                 nsIFrame::InlinePrefISizeData* aData) {
   if (!GetParent()->Style()->ShouldSuppressLineBreak()) {
     // Match the 1 appunit width assigned in the Reflow method above
     aData->mCurrentLine += 1;
     aData->ForceBreak();
   }
 }
 
-/* virtual */ nscoord BRFrame::GetMinISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord BRFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result = 0;
   DISPLAY_MIN_INLINE_SIZE(this, result);
   return result;
 }
 
-/* virtual */ nscoord BRFrame::GetPrefISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord BRFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nscoord result = 0;
   DISPLAY_PREF_INLINE_SIZE(this, result);
   return result;
 }
 
 nscoord BRFrame::GetLogicalBaseline(mozilla::WritingMode aWritingMode) const {
   return mAscent;
 }
--- a/layout/generic/ColumnSetWrapperFrame.cpp
+++ b/layout/generic/ColumnSetWrapperFrame.cpp
@@ -145,17 +145,18 @@ void ColumnSetWrapperFrame::MarkIntrinsi
   // continuations. Clear the bit because we don't want to call ResolveBidi().
   for (nsIFrame* f = FirstContinuation(); f; f = f->GetNextContinuation()) {
     f->RemoveStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION);
   }
 }
 
 #ifdef DEBUG
 
-/* static */ void ColumnSetWrapperFrame::AssertColumnSpanWrapperSubtreeIsSane(
+/* static */
+void ColumnSetWrapperFrame::AssertColumnSpanWrapperSubtreeIsSane(
     const nsIFrame* aFrame) {
   MOZ_ASSERT(aFrame->IsColumnSpan(), "aFrame is not column-span?");
 
   if (!nsLayoutUtils::GetStyleFrame(const_cast<nsIFrame*>(aFrame))
            ->Style()
            ->IsAnonBox()) {
     // aFrame's style frame has "column-span: all". Traverse no further.
     return;
--- a/layout/generic/ReflowInput.cpp
+++ b/layout/generic/ReflowInput.cpp
@@ -336,17 +336,18 @@ void ReflowInput::SetComputedHeight(nsco
     ComputedHeight() = aComputedHeight;
     LayoutFrameType frameType = mFrame->Type();
     if (frameType != LayoutFrameType::Viewport || !mWritingMode.IsVertical()) {
       InitResizeFlags(mFrame->PresContext(), frameType);
     }
   }
 }
 
-/* static */ void ReflowInput::MarkFrameChildrenDirty(nsIFrame* aFrame) {
+/* static */
+void ReflowInput::MarkFrameChildrenDirty(nsIFrame* aFrame) {
   if (aFrame->IsXULBoxFrame()) {
     return;
   }
   // Mark all child frames as dirty.
   //
   // We don't do this for XUL boxes because they handle their child
   // reflow separately.
   for (nsIFrame::ChildListIterator childLists(aFrame); !childLists.IsDone();
@@ -997,19 +998,20 @@ void ReflowInput::InitFrameType(LayoutFr
     frameType = NS_FRAME_REPLACED_CONTAINS_BLOCK(frameType);
   } else if (mFrame->IsFrameOfType(nsIFrame::eReplaced)) {
     frameType = NS_FRAME_REPLACED(frameType);
   }
 
   mFrameType = frameType;
 }
 
-/* static */ void ReflowInput::ComputeRelativeOffsets(
-    WritingMode aWM, nsIFrame* aFrame, const LogicalSize& aCBSize,
-    nsMargin& aComputedOffsets) {
+/* static */
+void ReflowInput::ComputeRelativeOffsets(WritingMode aWM, nsIFrame* aFrame,
+                                         const LogicalSize& aCBSize,
+                                         nsMargin& aComputedOffsets) {
   LogicalMargin offsets(aWM);
   mozilla::Side inlineStart = aWM.PhysicalSide(eLogicalSideIStart);
   mozilla::Side inlineEnd = aWM.PhysicalSide(eLogicalSideIEnd);
   mozilla::Side blockStart = aWM.PhysicalSide(eLogicalSideBStart);
   mozilla::Side blockEnd = aWM.PhysicalSide(eLogicalSideBEnd);
 
   const nsStylePosition* position = aFrame->StylePosition();
 
@@ -1104,18 +1106,20 @@ void ReflowInput::InitFrameType(LayoutFr
   if (physicalOffsets) {
     *physicalOffsets = aComputedOffsets;
   } else {
     aFrame->AddProperty(nsIFrame::ComputedOffsetProperty(),
                         new nsMargin(aComputedOffsets));
   }
 }
 
-/* static */ void ReflowInput::ApplyRelativePositioning(
-    nsIFrame* aFrame, const nsMargin& aComputedOffsets, nsPoint* aPosition) {
+/* static */
+void ReflowInput::ApplyRelativePositioning(nsIFrame* aFrame,
+                                           const nsMargin& aComputedOffsets,
+                                           nsPoint* aPosition) {
   if (!aFrame->IsRelativelyPositioned()) {
     NS_ASSERTION(!aFrame->GetProperty(nsIFrame::NormalPositionProperty()),
                  "We assume that changing the 'position' property causes "
                  "frame reconstruction.  If that ever changes, this code "
                  "should call "
                  "aFrame->DeleteProperty(nsIFrame::NormalPositionProperty())");
     return;
   }
@@ -2885,21 +2889,22 @@ nscoord ReflowInput::CalcLineHeight() co
           ? ComputedBSize()
           : (mCBReflowInput ? mCBReflowInput->ComputedBSize() : NS_AUTOHEIGHT);
 
   return CalcLineHeight(mFrame->GetContent(), mFrame->Style(),
                         mFrame->PresContext(), blockBSize,
                         nsLayoutUtils::FontSizeInflationFor(mFrame));
 }
 
-/* static */ nscoord ReflowInput::CalcLineHeight(nsIContent* aContent,
-                                                 ComputedStyle* aComputedStyle,
-                                                 nsPresContext* aPresContext,
-                                                 nscoord aBlockBSize,
-                                                 float aFontSizeInflation) {
+/* static */
+nscoord ReflowInput::CalcLineHeight(nsIContent* aContent,
+                                    ComputedStyle* aComputedStyle,
+                                    nsPresContext* aPresContext,
+                                    nscoord aBlockBSize,
+                                    float aFontSizeInflation) {
   MOZ_ASSERT(aComputedStyle, "Must have a ComputedStyle");
 
   nscoord lineHeight = ComputeLineHeight(aComputedStyle, aPresContext,
                                          aBlockBSize, aFontSizeInflation);
 
   NS_ASSERTION(lineHeight >= 0, "ComputeLineHeight screwed up");
 
   HTMLInputElement* input = HTMLInputElement::FromNodeOrNull(aContent);
--- a/layout/generic/RubyUtils.cpp
+++ b/layout/generic/RubyUtils.cpp
@@ -10,28 +10,30 @@
 #include "nsRubyTextFrame.h"
 #include "nsRubyBaseContainerFrame.h"
 #include "nsRubyTextContainerFrame.h"
 
 using namespace mozilla;
 
 NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(ReservedISize, nscoord)
 
-/* static */ void RubyUtils::SetReservedISize(nsIFrame* aFrame,
-                                              nscoord aISize) {
+/* static */
+void RubyUtils::SetReservedISize(nsIFrame* aFrame, nscoord aISize) {
   MOZ_ASSERT(IsExpandableRubyBox(aFrame));
   aFrame->SetProperty(ReservedISize(), aISize);
 }
 
-/* static */ void RubyUtils::ClearReservedISize(nsIFrame* aFrame) {
+/* static */
+void RubyUtils::ClearReservedISize(nsIFrame* aFrame) {
   MOZ_ASSERT(IsExpandableRubyBox(aFrame));
   aFrame->RemoveProperty(ReservedISize());
 }
 
-/* static */ nscoord RubyUtils::GetReservedISize(nsIFrame* aFrame) {
+/* static */
+nscoord RubyUtils::GetReservedISize(nsIFrame* aFrame) {
   MOZ_ASSERT(IsExpandableRubyBox(aFrame));
   return aFrame->GetProperty(ReservedISize());
 }
 
 AutoRubyTextContainerArray::AutoRubyTextContainerArray(
     nsRubyBaseContainerFrame* aBaseContainer) {
   for (nsIFrame* frame = aBaseContainer->GetNextSibling();
        frame && frame->IsRubyTextContainerFrame();
--- a/layout/generic/TextOverflow.cpp
+++ b/layout/generic/TextOverflow.cpp
@@ -336,17 +336,18 @@ TextOverflow::TextOverflow(nsDisplayList
   } else {
     mIStart.Init(style->mTextOverflow.GetRight(direction));
     mIEnd.Init(style->mTextOverflow.GetLeft(direction));
   }
   // The left/right marker string is setup in ExamineLineFrames when a line
   // has overflow on that side.
 }
 
-/* static */ Maybe<TextOverflow> TextOverflow::WillProcessLines(
+/* static */
+Maybe<TextOverflow> TextOverflow::WillProcessLines(
     nsDisplayListBuilder* aBuilder, nsIFrame* aBlockFrame) {
   // Ignore 'text-overflow' for event and frame visibility processing.
   if (aBuilder->IsForEventDelivery() || aBuilder->IsForFrameVisibility() ||
       !CanHaveTextOverflow(aBlockFrame)) {
     return Nothing();
   }
   nsIScrollableFrame* scrollableFrame =
       nsLayoutUtils::GetScrollableFrameFor(aBlockFrame);
@@ -755,23 +756,25 @@ void TextOverflow::PruneDisplayListConte
       }
     }
 
     saved.AppendToTop(item);
   }
   aList->AppendToTop(&saved);
 }
 
-/* static */ bool TextOverflow::HasClippedOverflow(nsIFrame* aBlockFrame) {
+/* static */
+bool TextOverflow::HasClippedOverflow(nsIFrame* aBlockFrame) {
   const nsStyleTextReset* style = aBlockFrame->StyleTextReset();
   return style->mTextOverflow.mLeft.mType == NS_STYLE_TEXT_OVERFLOW_CLIP &&
          style->mTextOverflow.mRight.mType == NS_STYLE_TEXT_OVERFLOW_CLIP;
 }
 
-/* static */ bool TextOverflow::CanHaveTextOverflow(nsIFrame* aBlockFrame) {
+/* static */
+bool TextOverflow::CanHaveTextOverflow(nsIFrame* aBlockFrame) {
   // Nothing to do for text-overflow:clip or if 'overflow-x/y:visible'.
   if (HasClippedOverflow(aBlockFrame) ||
       IsInlineAxisOverflowVisible(aBlockFrame)) {
     return false;
   }
 
   // Skip ComboboxControlFrame because it would clip the drop-down arrow.
   // Its anon block inherits 'text-overflow' and does what is expected.
--- a/layout/generic/ViewportFrame.cpp
+++ b/layout/generic/ViewportFrame.cpp
@@ -198,30 +198,30 @@ void ViewportFrame::InsertFrames(ChildLi
 }
 
 void ViewportFrame::RemoveFrame(ChildListID aListID, nsIFrame* aOldFrame) {
   NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
   nsContainerFrame::RemoveFrame(aListID, aOldFrame);
 }
 #endif
 
-/* virtual */ nscoord ViewportFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord ViewportFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_MIN_INLINE_SIZE(this, result);
   if (mFrames.IsEmpty())
     result = 0;
   else
     result = mFrames.FirstChild()->GetMinISize(aRenderingContext);
 
   return result;
 }
 
-/* virtual */ nscoord ViewportFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord ViewportFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_PREF_INLINE_SIZE(this, result);
   if (mFrames.IsEmpty())
     result = 0;
   else
     result = mFrames.FirstChild()->GetPrefISize(aRenderingContext);
 
   return result;
--- a/layout/generic/nsBackdropFrame.cpp
+++ b/layout/generic/nsBackdropFrame.cpp
@@ -15,59 +15,63 @@ using namespace mozilla;
 NS_IMPL_FRAMEARENA_HELPERS(nsBackdropFrame)
 
 #ifdef DEBUG_FRAME_DUMP
 nsresult nsBackdropFrame::GetFrameName(nsAString& aResult) const {
   return MakeFrameName(NS_LITERAL_STRING("Backdrop"), aResult);
 }
 #endif
 
-/* virtual */ ComputedStyle* nsBackdropFrame::GetParentComputedStyle(
+/* virtual */
+ComputedStyle* nsBackdropFrame::GetParentComputedStyle(
     nsIFrame** aProviderFrame) const {
   // Style context of backdrop pseudo-element does not inherit from
   // any element, per the Fullscreen API spec.
   *aProviderFrame = nullptr;
   return nullptr;
 }
 
-/* virtual */ void nsBackdropFrame::BuildDisplayList(
-    nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists) {
+/* virtual */
+void nsBackdropFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                       const nsDisplayListSet& aLists) {
   DO_GLOBAL_REFLOW_COUNT_DSP("nsBackdropFrame");
   // We want this frame to always be there even if its display value is
   // none or contents so that we can respond to style change on it. To
   // support those values, we skip painting ourselves in those cases.
   auto display = StyleDisplay()->mDisplay;
   if (display == mozilla::StyleDisplay::None ||
       display == mozilla::StyleDisplay::Contents) {
     return;
   }
 
   DisplayBorderBackgroundOutline(aBuilder, aLists);
 }
 
-/* virtual */ LogicalSize nsBackdropFrame::ComputeAutoSize(
+/* virtual */
+LogicalSize nsBackdropFrame::ComputeAutoSize(
     gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
     nscoord aAvailableISize, const LogicalSize& aMargin,
     const LogicalSize& aBorder, const LogicalSize& aPadding,
     ComputeSizeFlags aFlags) {
   // Note that this frame is a child of the viewport frame.
   LogicalSize result(aWM, 0xdeadbeef, NS_UNCONSTRAINEDSIZE);
   if (aFlags & ComputeSizeFlags::eShrinkWrap) {
     result.ISize(aWM) = 0;
   } else {
     result.ISize(aWM) = aAvailableISize - aMargin.ISize(aWM) -
                         aBorder.ISize(aWM) - aPadding.ISize(aWM);
   }
   return result;
 }
 
-/* virtual */ void nsBackdropFrame::Reflow(nsPresContext* aPresContext,
-                                           ReflowOutput& aDesiredSize,
-                                           const ReflowInput& aReflowInput,
-                                           nsReflowStatus& aStatus) {
+/* virtual */
+void nsBackdropFrame::Reflow(nsPresContext* aPresContext,
+                             ReflowOutput& aDesiredSize,
+                             const ReflowInput& aReflowInput,
+                             nsReflowStatus& aStatus) {
   MarkInReflow();
   DO_GLOBAL_REFLOW_COUNT("nsBackdropFrame");
   DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
   MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
 
   // Note that this frame is a child of the viewport frame.
   WritingMode wm = aReflowInput.GetWritingMode();
   LogicalMargin borderPadding = aReflowInput.ComputedLogicalBorderPadding();
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -350,17 +350,18 @@ void nsBlockFrame::DestroyFrom(nsIFrame*
     SafelyDestroyFrameListProp(aDestructRoot, aPostDestroyData, shell,
                                OutsideBulletProperty());
     RemoveStateBits(NS_BLOCK_FRAME_HAS_OUTSIDE_BULLET);
   }
 
   nsContainerFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
 }
 
-/* virtual */ nsILineIterator* nsBlockFrame::GetLineIterator() {
+/* virtual */
+nsILineIterator* nsBlockFrame::GetLineIterator() {
   nsLineIterator* it = new nsLineIterator;
   if (!it) return nullptr;
 
   const nsStyleVisibility* visibility = StyleVisibility();
   nsresult rv =
       it->Init(mLines, visibility->mDirection == NS_STYLE_DIRECTION_RTL);
   if (NS_FAILED(rv)) {
     delete it;
@@ -569,17 +570,18 @@ void nsBlockFrame::GetChildLists(nsTArra
     list->AppendIfNonempty(aLists, kBulletList);
   }
   list = GetPushedFloats();
   if (list) {
     list->AppendIfNonempty(aLists, kPushedFloatsList);
   }
 }
 
-/* virtual */ bool nsBlockFrame::IsFloatContainingBlock() const { return true; }
+/* virtual */
+bool nsBlockFrame::IsFloatContainingBlock() const { return true; }
 
 static void ReparentFrameInternal(nsIFrame* aFrame,
                                   nsContainerFrame* aOldParent,
                                   nsContainerFrame* aNewParent,
                                   bool aMarkDirty) {
   NS_ASSERTION(aOldParent == aFrame->GetParent(),
                "Parent not consistent with expectations");
 
@@ -671,17 +673,18 @@ static bool RemoveFirstLine(nsLineList& 
   nsFrameList::FrameLinkEnumerator linkToBreak(aFromFrames, lastFrame);
   *aOutFrames = aFromFrames.ExtractHead(linkToBreak);
   return isLastLine;
 }
 
 //////////////////////////////////////////////////////////////////////
 // Reflow methods
 
-/* virtual */ void nsBlockFrame::MarkIntrinsicISizesDirty() {
+/* virtual */
+void nsBlockFrame::MarkIntrinsicISizesDirty() {
   nsBlockFrame* dirtyBlock = static_cast<nsBlockFrame*>(FirstContinuation());
   dirtyBlock->mMinWidth = NS_INTRINSIC_WIDTH_UNKNOWN;
   dirtyBlock->mPrefWidth = NS_INTRINSIC_WIDTH_UNKNOWN;
   if (!(GetStateBits() & NS_BLOCK_NEEDS_BIDI_RESOLUTION)) {
     for (nsIFrame* frame = dirtyBlock; frame;
          frame = frame->GetNextContinuation()) {
       frame->AddStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION);
     }
@@ -703,17 +706,18 @@ void nsBlockFrame::CheckIntrinsicCacheAg
     if (inflationEnabled) {
       AddStateBits(NS_BLOCK_FRAME_INTRINSICS_INFLATED);
     } else {
       RemoveStateBits(NS_BLOCK_FRAME_INTRINSICS_INFLATED);
     }
   }
 }
 
-/* virtual */ nscoord nsBlockFrame::GetMinISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsBlockFrame::GetMinISize(gfxContext* aRenderingContext) {
   nsIFrame* firstInFlow = FirstContinuation();
   if (firstInFlow != this) return firstInFlow->GetMinISize(aRenderingContext);
 
   DISPLAY_MIN_INLINE_SIZE(this, mMinWidth);
 
   CheckIntrinsicCacheAgainstShrinkWrapState();
 
   if (mMinWidth != NS_INTRINSIC_WIDTH_UNKNOWN) return mMinWidth;
@@ -783,18 +787,18 @@ void nsBlockFrame::CheckIntrinsicCacheAg
     }
   }
   data.ForceBreak();
 
   mMinWidth = data.mPrevLines;
   return mMinWidth;
 }
 
-/* virtual */ nscoord nsBlockFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsBlockFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nsIFrame* firstInFlow = FirstContinuation();
   if (firstInFlow != this) return firstInFlow->GetPrefISize(aRenderingContext);
 
   DISPLAY_PREF_INLINE_SIZE(this, mPrefWidth);
 
   CheckIntrinsicCacheAgainstShrinkWrapState();
 
   if (mPrefWidth != NS_INTRINSIC_WIDTH_UNKNOWN) return mPrefWidth;
@@ -883,18 +887,19 @@ void nsBlockFrame::CheckIntrinsicCacheAg
 nsRect nsBlockFrame::ComputeTightBounds(DrawTarget* aDrawTarget) const {
   // be conservative
   if (Style()->HasTextDecorationLines()) {
     return GetVisualOverflowRect();
   }
   return ComputeSimpleTightBounds(aDrawTarget);
 }
 
-/* virtual */ nsresult nsBlockFrame::GetPrefWidthTightBounds(
-    gfxContext* aRenderingContext, nscoord* aX, nscoord* aXMost) {
+/* virtual */
+nsresult nsBlockFrame::GetPrefWidthTightBounds(gfxContext* aRenderingContext,
+                                               nscoord* aX, nscoord* aXMost) {
   nsIFrame* firstInFlow = FirstContinuation();
   if (firstInFlow != this) {
     return firstInFlow->GetPrefWidthTightBounds(aRenderingContext, aX, aXMost);
   }
 
   *aX = 0;
   *aXMost = 0;
 
@@ -3033,17 +3038,18 @@ static inline bool IsNonAutoNonZeroBSize
     // negative calc() results to 0.
     return aCoord.AsLengthPercentage().Resolve(nscoord_MAX) > 0 ||
            aCoord.AsLengthPercentage().Resolve(0) > 0;
   }
   MOZ_ASSERT(false, "unexpected unit for height or min-height");
   return true;
 }
 
-/* virtual */ bool nsBlockFrame::IsSelfEmpty() {
+/* virtual */
+bool nsBlockFrame::IsSelfEmpty() {
   // Blocks which are margin-roots (including inline-blocks) cannot be treated
   // as empty for margin-collapsing and other purposes. They're more like
   // replaced elements.
   if (GetStateBits() & NS_BLOCK_MARGIN_ROOT) {
     return false;
   }
 
   WritingMode wm = GetWritingMode();
@@ -6638,17 +6644,18 @@ nsLineBox* nsBlockFrame::GetFirstLineCon
 
   if (cursor.get() != property) {
     SetProperty(LineCursorProperty(), cursor.get());
   }
 
   return cursor.get();
 }
 
-/* virtual */ void nsBlockFrame::ChildIsDirty(nsIFrame* aChild) {
+/* virtual */
+void nsBlockFrame::ChildIsDirty(nsIFrame* aChild) {
   // See if the child is absolutely positioned
   if (aChild->GetStateBits() & NS_FRAME_OUT_OF_FLOW &&
       aChild->IsAbsolutelyPositioned()) {
     // do nothing
   } else if (aChild == GetOutsideBullet()) {
     // The bullet lives in the first line, unless the first line has
     // height 0 and there is a second line, in which case it lives
     // in the second line.
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -91,18 +91,18 @@ nsresult nsBulletFrame::GetFrameName(nsA
 #endif
 
 bool nsBulletFrame::IsEmpty() { return IsSelfEmpty(); }
 
 bool nsBulletFrame::IsSelfEmpty() {
   return StyleList()->mCounterStyle.IsNone();
 }
 
-/* virtual */ void nsBulletFrame::DidSetComputedStyle(
-    ComputedStyle* aOldComputedStyle) {
+/* virtual */
+void nsBulletFrame::DidSetComputedStyle(ComputedStyle* aOldComputedStyle) {
   nsFrame::DidSetComputedStyle(aOldComputedStyle);
 
   imgRequestProxy* newRequest = StyleList()->GetListStyleImage();
 
   if (newRequest) {
     if (!mListener) {
       mListener = new nsBulletListener();
       mListener->SetFrame(this);
@@ -1005,30 +1005,30 @@ void nsBulletFrame::Reflow(nsPresContext
   // overflow their font-boxes. It'll do for now; to fix it for real, we really
   // should rewrite all the text-handling code here to use gfxTextRun (bug
   // 397294).
   aMetrics.SetOverflowAreasToDesiredBounds();
 
   NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
 }
 
-/* virtual */ nscoord nsBulletFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsBulletFrame::GetMinISize(gfxContext* aRenderingContext) {
   WritingMode wm = GetWritingMode();
   ReflowOutput reflowOutput(wm);
   DISPLAY_MIN_INLINE_SIZE(this, reflowOutput.ISize(wm));
   LogicalMargin padding(wm);
   GetDesiredSize(PresContext(), aRenderingContext, reflowOutput, 1.0f,
                  &padding);
   reflowOutput.ISize(wm) += padding.IStartEnd(wm);
   return reflowOutput.ISize(wm);
 }
 
-/* virtual */ nscoord nsBulletFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsBulletFrame::GetPrefISize(gfxContext* aRenderingContext) {
   WritingMode wm = GetWritingMode();
   ReflowOutput metrics(wm);
   DISPLAY_PREF_INLINE_SIZE(this, metrics.ISize(wm));
   LogicalMargin padding(wm);
   GetDesiredSize(PresContext(), aRenderingContext, metrics, 1.0f, &padding);
   metrics.ISize(wm) += padding.IStartEnd(wm);
   return metrics.ISize(wm);
 }
@@ -1039,27 +1039,29 @@ void nsBulletFrame::Reflow(nsPresContext
 static inline bool IsIgnoreable(const nsIFrame* aFrame, nscoord aISize) {
   if (aISize != nscoord(0)) {
     return false;
   }
   auto listStyle = aFrame->StyleList();
   return listStyle->mCounterStyle.IsNone() && !listStyle->GetListStyleImage();
 }
 
-/* virtual */ void nsBulletFrame::AddInlineMinISize(
-    gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
+/* virtual */
+void nsBulletFrame::AddInlineMinISize(gfxContext* aRenderingContext,
+                                      nsIFrame::InlineMinISizeData* aData) {
   nscoord isize = nsLayoutUtils::IntrinsicForContainer(
       aRenderingContext, this, nsLayoutUtils::MIN_ISIZE);
   if (MOZ_LIKELY(!::IsIgnoreable(this, isize))) {
     aData->DefaultAddInlineMinISize(this, isize);
   }
 }
 
-/* virtual */ void nsBulletFrame::AddInlinePrefISize(
-    gfxContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) {
+/* virtual */
+void nsBulletFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
+                                       nsIFrame::InlinePrefISizeData* aData) {
   nscoord isize = nsLayoutUtils::IntrinsicForContainer(
       aRenderingContext, this, nsLayoutUtils::PREF_ISIZE);
   if (MOZ_LIKELY(!::IsIgnoreable(this, isize))) {
     aData->DefaultAddInlinePrefISize(isize);
   }
 }
 
 NS_IMETHODIMP
--- a/layout/generic/nsCanvasFrame.cpp
+++ b/layout/generic/nsCanvasFrame.cpp
@@ -635,29 +635,29 @@ void nsCanvasFrame::PaintFocus(DrawTarge
     NS_ERROR("current color cannot be found");
     return;
   }
 
   nsCSSRendering::PaintFocus(PresContext(), aDrawTarget, focusRect,
                              color->mColor);
 }
 
-/* virtual */ nscoord nsCanvasFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsCanvasFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_MIN_INLINE_SIZE(this, result);
   if (mFrames.IsEmpty())
     result = 0;
   else
     result = mFrames.FirstChild()->GetMinISize(aRenderingContext);
   return result;
 }
 
-/* virtual */ nscoord nsCanvasFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsCanvasFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_PREF_INLINE_SIZE(this, result);
   if (mFrames.IsEmpty())
     result = 0;
   else
     result = mFrames.FirstChild()->GetPrefISize(aRenderingContext);
   return result;
 }
--- a/layout/generic/nsColumnSetFrame.cpp
+++ b/layout/generic/nsColumnSetFrame.cpp
@@ -278,17 +278,18 @@ static nscoord GetColumnGap(nsColumnSetF
                             nscoord aPercentageBasis) {
   const auto& columnGap = aFrame->StylePosition()->mColumnGap;
   if (columnGap.GetUnit() == eStyleUnit_Normal) {
     return aFrame->StyleFont()->mFont.size;
   }
   return nsLayoutUtils::ResolveGapToLength(columnGap, aPercentageBasis);
 }
 
-/* static */ nscoord nsColumnSetFrame::ClampUsedColumnWidth(
+/* static */
+nscoord nsColumnSetFrame::ClampUsedColumnWidth(
     const nsStyleCoord& aColumnWidth) {
   MOZ_ASSERT(aColumnWidth.GetUnit() == eStyleUnit_Coord,
              "This should only be called when column-width is a <length>!");
 
   // Per spec, used values will be clamped to a minimum of 1px.
   return std::max(CSSPixel::ToAppUnits(1), aColumnWidth.GetCoordValue());
 }
 
--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -359,17 +359,18 @@ void nsContainerFrame::BuildDisplayListF
   nsDisplayListSet set(aLists, aLists.Content());
   // The children should be in content order
   while (kid) {
     BuildDisplayListForChild(aBuilder, kid, set, aFlags);
     kid = kid->GetNextSibling();
   }
 }
 
-/* virtual */ void nsContainerFrame::ChildIsDirty(nsIFrame* aChild) {
+/* virtual */
+void nsContainerFrame::ChildIsDirty(nsIFrame* aChild) {
   NS_ASSERTION(NS_SUBTREE_DIRTY(aChild), "child isn't actually dirty");
 
   AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
 }
 
 nsIFrame::FrameSearchResult nsContainerFrame::PeekOffsetNoAmount(
     bool aForward, int32_t* aOffset) {
   NS_ASSERTION(aOffset && *aOffset <= 1, "aOffset out of range");
@@ -1628,17 +1629,18 @@ nsIFrame* nsContainerFrame::PullNextInFl
     mFrames.AppendFrame(this, frame);
     // AppendFrame has reparented the frame, we need
     // to reparent the frame view then.
     nsContainerFrame::ReparentFrameView(frame, nextInFlow, this);
   }
   return frame;
 }
 
-/* static */ void nsContainerFrame::ReparentFloatsForInlineChild(
+/* static */
+void nsContainerFrame::ReparentFloatsForInlineChild(
     nsIFrame* aOurLineContainer, nsIFrame* aFrame, bool aReparentSiblings,
     ReparentingDirection aDirection) {
   // XXXbz this would be better if it took a nsFrameList or a frame
   // list slice....
   NS_ASSERTION(aOurLineContainer->GetNextContinuation() ||
                    aOurLineContainer->GetPrevContinuation(),
                "Don't call this when we have no continuation, it's a waste");
   if (!aFrame) {
--- a/layout/generic/nsFirstLetterFrame.cpp
+++ b/layout/generic/nsFirstLetterFrame.cpp
@@ -87,38 +87,40 @@ nsresult nsFirstLetterFrame::GetChildFra
   } else {
     return nsFrame::GetChildFrameContainingOffset(
         inContentOffset, inHint, outFrameContentOffset, outChildFrame);
   }
 }
 
 // Needed for non-floating first-letter frames and for the continuations
 // following the first-letter that we also use nsFirstLetterFrame for.
-/* virtual */ void nsFirstLetterFrame::AddInlineMinISize(
+/* virtual */
+void nsFirstLetterFrame::AddInlineMinISize(
     gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
   DoInlineIntrinsicISize(aRenderingContext, aData, nsLayoutUtils::MIN_ISIZE);
 }
 
 // Needed for non-floating first-letter frames and for the continuations
 // following the first-letter that we also use nsFirstLetterFrame for.
-/* virtual */ void nsFirstLetterFrame::AddInlinePrefISize(
+/* virtual */
+void nsFirstLetterFrame::AddInlinePrefISize(
     gfxContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) {
   DoInlineIntrinsicISize(aRenderingContext, aData, nsLayoutUtils::PREF_ISIZE);
   aData->mLineIsEmpty = false;
 }
 
 // Needed for floating first-letter frames.
-/* virtual */ nscoord nsFirstLetterFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsFirstLetterFrame::GetMinISize(gfxContext* aRenderingContext) {
   return nsLayoutUtils::MinISizeFromInline(this, aRenderingContext);
 }
 
 // Needed for floating first-letter frames.
-/* virtual */ nscoord nsFirstLetterFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsFirstLetterFrame::GetPrefISize(gfxContext* aRenderingContext) {
   return nsLayoutUtils::PrefISizeFromInline(this, aRenderingContext);
 }
 
 /* virtual */
 LogicalSize nsFirstLetterFrame::ComputeSize(
     gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
     nscoord aAvailableISize, const LogicalSize& aMargin,
     const LogicalSize& aBorder, const LogicalSize& aPadding,
@@ -266,17 +268,18 @@ void nsFirstLetterFrame::Reflow(nsPresCo
                                             true);
       }
     }
   }
 
   NS_FRAME_SET_TRUNCATION(aReflowStatus, aReflowInput, aMetrics);
 }
 
-/* virtual */ bool nsFirstLetterFrame::CanContinueTextRun() const {
+/* virtual */
+bool nsFirstLetterFrame::CanContinueTextRun() const {
   // We can continue a text run through a first-letter frame.
   return true;
 }
 
 nsresult nsFirstLetterFrame::CreateContinuationForFloatingParent(
     nsPresContext* aPresContext, nsIFrame* aChild, nsIFrame** aContinuation,
     bool aIsFluid) {
   NS_ASSERTION(IsFloating(),
--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -1811,17 +1811,18 @@ nsFlexContainerFrame::MeasureAscentAndBS
 
   auto result =
       new CachedMeasuringReflowResult(aChildReflowInput, childDesiredSize);
 
   aItem.Frame()->SetProperty(CachedFlexMeasuringReflow(), result);
   return *result;
 }
 
-/* virtual */ void nsFlexContainerFrame::MarkIntrinsicISizesDirty() {
+/* virtual */
+void nsFlexContainerFrame::MarkIntrinsicISizesDirty() {
   mCachedMinISize = NS_INTRINSIC_WIDTH_UNKNOWN;
   mCachedPrefISize = NS_INTRINSIC_WIDTH_UNKNOWN;
 
   nsContainerFrame::MarkIntrinsicISizesDirty();
 }
 
 nscoord nsFlexContainerFrame::MeasureFlexItemContentBSize(
     nsPresContext* aPresContext, FlexItem& aFlexItem,
@@ -5193,31 +5194,31 @@ nscoord nsFlexContainerFrame::IntrinsicI
         containerISize = std::max(containerISize, childISize);
       }
     }
   }
 
   return containerISize;
 }
 
-/* virtual */ nscoord nsFlexContainerFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsFlexContainerFrame::GetMinISize(gfxContext* aRenderingContext) {
   DISPLAY_MIN_INLINE_SIZE(this, mCachedMinISize);
   if (mCachedMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
     mCachedMinISize =
         StyleDisplay()->IsContainSize()
             ? 0
             : IntrinsicISize(aRenderingContext, nsLayoutUtils::MIN_ISIZE);
   }
 
   return mCachedMinISize;
 }
 
-/* virtual */ nscoord nsFlexContainerFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsFlexContainerFrame::GetPrefISize(gfxContext* aRenderingContext) {
   DISPLAY_PREF_INLINE_SIZE(this, mCachedPrefISize);
   if (mCachedPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
     mCachedPrefISize =
         StyleDisplay()->IsContainSize()
             ? 0
             : IntrinsicISize(aRenderingContext, nsLayoutUtils::PREF_ISIZE);
   }
 
--- a/layout/generic/nsFloatManager.cpp
+++ b/layout/generic/nsFloatManager.cpp
@@ -1689,18 +1689,20 @@ void nsFloatManager::PolygonShapeInfo::T
   }
   for (nsRect& interval : mIntervals) {
     interval.MoveBy(aLineLeft, aBlockStart);
   }
   mBStart += aBlockStart;
   mBEnd += aBlockStart;
 }
 
-/* static */ nscoord nsFloatManager::PolygonShapeInfo::XInterceptAtY(
-    const nscoord aY, const nsPoint& aP1, const nsPoint& aP2) {
+/* static */
+nscoord nsFloatManager::PolygonShapeInfo::XInterceptAtY(const nscoord aY,
+                                                        const nsPoint& aP1,
+                                                        const nsPoint& aP2) {
   // Solve for x in the linear equation: x = x1 + (y-y1) * (x2-x1) / (y2-y1),
   // where aP1 = (x1, y1) and aP2 = (x2, y2).
 
   MOZ_ASSERT(aP1.y <= aY && aY <= aP2.y,
              "This function won't work if the horizontal line at aY and "
              "the line segment (aP1, aP2) do not intersect!");
 
   MOZ_ASSERT(aP1.y != aP2.y,
@@ -2431,17 +2433,18 @@ bool nsFloatManager::FloatInfo::MayNarro
   }
 
   return mShapeInfo->MayNarrowInBlockDirection();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // ShapeInfo
 
-/* static */ LogicalRect nsFloatManager::ShapeInfo::ComputeShapeBoxRect(
+/* static */
+LogicalRect nsFloatManager::ShapeInfo::ComputeShapeBoxRect(
     const StyleShapeSource& aShapeOutside, nsIFrame* const aFrame,
     const LogicalRect& aMarginRect, WritingMode aWM) {
   LogicalRect rect = aMarginRect;
 
   switch (aShapeOutside.GetReferenceBox()) {
     case StyleGeometryBox::ContentBox:
       rect.Deflate(aWM, aFrame->GetLogicalUsedPadding(aWM));
       MOZ_FALLTHROUGH;
@@ -2735,17 +2738,18 @@ nsFloatManager::ShapeInfo::CreateImageSh
   // NOTE: ImageShapeInfo constructor does not keep a persistent copy of
   // alphaPixels; it's only used during the constructor to compute pixel ranges.
   return MakeUnique<ImageShapeInfo>(alphaPixels, stride, contentSizeInDevPixels,
                                     appUnitsPerDevPixel, aShapeImageThreshold,
                                     aShapeMargin, contentRect, marginRect, aWM,
                                     aContainerSize);
 }
 
-/* static */ nscoord nsFloatManager::ShapeInfo::ComputeEllipseLineInterceptDiff(
+/* static */
+nscoord nsFloatManager::ShapeInfo::ComputeEllipseLineInterceptDiff(
     const nscoord aShapeBoxBStart, const nscoord aShapeBoxBEnd,
     const nscoord aBStartCornerRadiusL, const nscoord aBStartCornerRadiusB,
     const nscoord aBEndCornerRadiusL, const nscoord aBEndCornerRadiusB,
     const nscoord aBandBStart, const nscoord aBandBEnd) {
   // An example for the band intersecting with the top right corner of an
   // ellipse with writing-mode horizontal-tb.
   //
   //                             lineIntercept lineDiff
@@ -2802,24 +2806,27 @@ nsFloatManager::ShapeInfo::CreateImageSh
     nscoord lineIntercept =
         XInterceptAtY(b, aBEndCornerRadiusL, aBEndCornerRadiusB);
     lineDiff = aBEndCornerRadiusL - lineIntercept;
   }
 
   return lineDiff;
 }
 
-/* static */ nscoord nsFloatManager::ShapeInfo::XInterceptAtY(
-    const nscoord aY, const nscoord aRadiusX, const nscoord aRadiusY) {
+/* static */
+nscoord nsFloatManager::ShapeInfo::XInterceptAtY(const nscoord aY,
+                                                 const nscoord aRadiusX,
+                                                 const nscoord aRadiusY) {
   // Solve for x in the ellipse equation (x/radiusX)^2 + (y/radiusY)^2 = 1.
   MOZ_ASSERT(aRadiusY > 0);
   return aRadiusX * std::sqrt(1 - (aY * aY) / double(aRadiusY * aRadiusY));
 }
 
-/* static */ nsPoint nsFloatManager::ShapeInfo::ConvertToFloatLogical(
+/* static */
+nsPoint nsFloatManager::ShapeInfo::ConvertToFloatLogical(
     const nsPoint& aPoint, WritingMode aWM, const nsSize& aContainerSize) {
   LogicalPoint logicalPoint(aWM, aPoint, aContainerSize);
   return nsPoint(logicalPoint.LineRelative(aWM, aContainerSize),
                  logicalPoint.B(aWM));
 }
 
 /* static */ UniquePtr<nscoord[]>
 nsFloatManager::ShapeInfo::ConvertToFloatLogical(const nscoord aRadii[8],
@@ -2862,17 +2869,18 @@ nsFloatManager::ShapeInfo::ConvertToFloa
               logicalRadii[eCornerBottomRightX]);
     std::swap(logicalRadii[eCornerTopRightY],
               logicalRadii[eCornerBottomRightY]);
   }
 
   return logicalRadii;
 }
 
-/* static */ size_t nsFloatManager::ShapeInfo::MinIntervalIndexContainingY(
+/* static */
+size_t nsFloatManager::ShapeInfo::MinIntervalIndexContainingY(
     const nsTArray<nsRect>& aIntervals, const nscoord aTargetY) {
   // Perform a binary search to find the minimum index of an interval
   // that contains aTargetY. If no such interval exists, return a value
   // equal to the number of intervals.
   size_t startIdx = 0;
   size_t endIdx = aIntervals.Length();
   while (startIdx < endIdx) {
     size_t midIdx = startIdx + (endIdx - startIdx) / 2;
@@ -2885,19 +2893,21 @@ nsFloatManager::ShapeInfo::ConvertToFloa
     } else {
       endIdx = midIdx;
     }
   }
 
   return endIdx;
 }
 
-/* static */ nscoord nsFloatManager::ShapeInfo::LineEdge(
-    const nsTArray<nsRect>& aIntervals, const nscoord aBStart,
-    const nscoord aBEnd, bool aIsLineLeft) {
+/* static */
+nscoord nsFloatManager::ShapeInfo::LineEdge(const nsTArray<nsRect>& aIntervals,
+                                            const nscoord aBStart,
+                                            const nscoord aBEnd,
+                                            bool aIsLineLeft) {
   MOZ_ASSERT(aBStart <= aBEnd,
              "The band's block start is greater than its block end?");
 
   // Find all the intervals whose rects overlap the aBStart to
   // aBEnd range, and find the most constraining inline edge
   // depending on the value of aLeft.
 
   // Since the intervals are stored in block-axis order, we need
--- a/layout/generic/nsFontInflationData.cpp
+++ b/layout/generic/nsFontInflationData.cpp
@@ -29,17 +29,18 @@ NS_DECLARE_FRAME_PROPERTY_DELETABLE(Font
                "should have found a flow root");
   MOZ_ASSERT(aFrame->GetWritingMode().IsVertical() ==
                  bfc->GetWritingMode().IsVertical(),
              "current writing mode should match that of our flow root");
 
   return bfc->GetProperty(FontInflationDataProperty());
 }
 
-/* static */ bool nsFontInflationData::UpdateFontInflationDataISizeFor(
+/* static */
+bool nsFontInflationData::UpdateFontInflationDataISizeFor(
     const ReflowInput &aReflowInput) {
   nsIFrame *bfc = aReflowInput.mFrame;
   NS_ASSERTION(bfc->GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT,
                "should have been given a flow root");
   nsFontInflationData *data = bfc->GetProperty(FontInflationDataProperty());
   bool oldInflationEnabled;
   nscoord oldUsableISize;
   if (data) {
@@ -54,18 +55,18 @@ NS_DECLARE_FRAME_PROPERTY_DELETABLE(Font
 
   data->UpdateISize(aReflowInput);
 
   if (oldInflationEnabled != data->mInflationEnabled) return true;
 
   return oldInflationEnabled && oldUsableISize != data->mUsableISize;
 }
 
-/* static */ void nsFontInflationData::MarkFontInflationDataTextDirty(
-    nsIFrame *aBFCFrame) {
+/* static */
+void nsFontInflationData::MarkFontInflationDataTextDirty(nsIFrame *aBFCFrame) {
   NS_ASSERTION(aBFCFrame->GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT,
                "should have been given a flow root");
 
   nsFontInflationData *data =
       aBFCFrame->GetProperty(FontInflationDataProperty());
   if (data) {
     data->MarkTextDirty();
   }
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -244,17 +244,18 @@ void nsReflowStatus::UpdateTruncated(con
              aReflowInput.AvailableBSize() < aMetrics.BSize(containerWM) &&
              !aReflowInput.mFlags.mIsTopOfPage) {
     mTruncated = true;
   } else {
     mTruncated = false;
   }
 }
 
-/* static */ void nsIFrame::DestroyAnonymousContent(
+/* static */
+void nsIFrame::DestroyAnonymousContent(
     nsPresContext* aPresContext, already_AddRefed<nsIContent>&& aContent) {
   if (nsCOMPtr<nsIContent> content = aContent) {
     aPresContext->EventStateManager()->NativeAnonymousContentRemoved(content);
     aPresContext->PresShell()->NativeAnonymousContentRemoved(content);
     content->UnbindFromTree();
   }
 }
 
@@ -1027,18 +1028,18 @@ void nsIFrame::MarkNeedsDisplayItemRebui
         // for rebuild.
         i->Frame()->MarkNeedsDisplayItemRebuild();
       }
     }
   }
 }
 
 // Subclass hook for style post processing
-/* virtual */ void nsFrame::DidSetComputedStyle(
-    ComputedStyle* aOldComputedStyle) {
+/* virtual */
+void nsFrame::DidSetComputedStyle(ComputedStyle* aOldComputedStyle) {
   if (nsSVGUtils::IsInSVGTextSubtree(this)) {
     SVGTextFrame* svgTextFrame = static_cast<SVGTextFrame*>(
         nsLayoutUtils::GetClosestFrameOfType(this, LayoutFrameType::SVGText));
     nsIFrame* anonBlock = svgTextFrame->PrincipalChildList().FirstChild();
     // Just as in SVGTextFrame::DidSetComputedStyle, we need to ensure that
     // any non-display SVGTextFrames get reflowed when a child text frame
     // gets new style.
     //
@@ -1369,17 +1370,18 @@ const nsIFrame::ChildListID nsIFrame::kO
 const nsIFrame::ChildListID nsIFrame::kOverflowList;
 const nsIFrame::ChildListID nsIFrame::kOverflowOutOfFlowList;
 const nsIFrame::ChildListID nsIFrame::kPopupList;
 const nsIFrame::ChildListID nsIFrame::kPushedFloatsList;
 const nsIFrame::ChildListID nsIFrame::kSelectPopupList;
 const nsIFrame::ChildListID nsIFrame::kNoReflowPrincipalList;
 #endif
 
-/* virtual */ nsMargin nsIFrame::GetUsedMargin() const {
+/* virtual */
+nsMargin nsIFrame::GetUsedMargin() const {
   nsMargin margin(0, 0, 0, 0);
   if (((mState & NS_FRAME_FIRST_REFLOW) && !(mState & NS_FRAME_IN_REFLOW)) ||
       nsSVGUtils::IsInSVGTextSubtree(this))
     return margin;
 
   nsMargin* m = GetProperty(UsedMarginProperty());
   if (m) {
     margin = *m;
@@ -1389,17 +1391,18 @@ const nsIFrame::ChildListID nsIFrame::kN
       NS_ERROR(
           "Returning bogus 0-sized margin, because this margin "
           "depends on layout & isn't cached!");
     }
   }
   return margin;
 }
 
-/* virtual */ nsMargin nsIFrame::GetUsedBorder() const {
+/* virtual */
+nsMargin nsIFrame::GetUsedBorder() const {
   nsMargin border(0, 0, 0, 0);
   if (((mState & NS_FRAME_FIRST_REFLOW) && !(mState & NS_FRAME_IN_REFLOW)) ||
       nsSVGUtils::IsInSVGTextSubtree(this))
     return border;
 
   // Theme methods don't use const-ness.
   nsIFrame* mutable_this = const_cast<nsIFrame*>(this);
 
@@ -1417,17 +1420,18 @@ const nsIFrame::ChildListID nsIFrame::kN
   if (b) {
     border = *b;
   } else {
     border = StyleBorder()->GetComputedBorder();
   }
   return border;
 }
 
-/* virtual */ nsMargin nsIFrame::GetUsedPadding() const {
+/* virtual */
+nsMargin nsIFrame::GetUsedPadding() const {
   nsMargin padding(0, 0, 0, 0);
   if (((mState & NS_FRAME_FIRST_REFLOW) && !(mState & NS_FRAME_IN_REFLOW)) ||
       nsSVGUtils::IsInSVGTextSubtree(this))
     return padding;
 
   // Theme methods don't use const-ness.
   nsIFrame* mutable_this = const_cast<nsIFrame*>(this);
 
@@ -1716,29 +1720,29 @@ bool nsIFrame::ComputeBorderRadii(const 
   }
   if (ratio < 1.0) {
     NS_FOR_CSS_HALF_CORNERS(corner) { aRadii[corner] *= ratio; }
   }
 
   return haveRadius;
 }
 
-/* static */ void nsIFrame::InsetBorderRadii(nscoord aRadii[8],
-                                             const nsMargin& aOffsets) {
+/* static */
+void nsIFrame::InsetBorderRadii(nscoord aRadii[8], const nsMargin& aOffsets) {
   NS_FOR_CSS_SIDES(side) {
     nscoord offset = aOffsets.Side(side);
     uint32_t hc1 = SideToHalfCorner(side, false, false);
     uint32_t hc2 = SideToHalfCorner(side, true, false);
     aRadii[hc1] = std::max(0, aRadii[hc1] - offset);
     aRadii[hc2] = std::max(0, aRadii[hc2] - offset);
   }
 }
 
-/* static */ void nsIFrame::OutsetBorderRadii(nscoord aRadii[8],
-                                              const nsMargin& aOffsets) {
+/* static */
+void nsIFrame::OutsetBorderRadii(nscoord aRadii[8], const nsMargin& aOffsets) {
   auto AdjustOffset = [](const uint32_t aRadius, const nscoord aOffset) {
     // Implement the cubic formula to adjust offset when aOffset > 0 and
     // aRadius / aOffset < 1.
     // https://drafts.csswg.org/css-shapes/#valdef-shape-box-margin-box
     if (aOffset > 0) {
       const double ratio = aRadius / double(aOffset);
       if (ratio < 1.0) {
         return nscoord(aOffset * (1.0 + std::pow(ratio - 1, 3)));
@@ -1757,20 +1761,20 @@ bool nsIFrame::ComputeBorderRadii(const 
     }
     if (aRadii[hc2] > 0) {
       const nscoord offset2 = AdjustOffset(aRadii[hc2], offset);
       aRadii[hc2] = std::max(0, aRadii[hc2] + offset2);
     }
   }
 }
 
-/* virtual */ bool nsIFrame::GetBorderRadii(const nsSize& aFrameSize,
-                                            const nsSize& aBorderArea,
-                                            Sides aSkipSides,
-                                            nscoord aRadii[8]) const {
+/* virtual */
+bool nsIFrame::GetBorderRadii(const nsSize& aFrameSize,
+                              const nsSize& aBorderArea, Sides aSkipSides,
+                              nscoord aRadii[8]) const {
   if (!mMayHaveRoundedCorners) {
     memset(aRadii, 0, sizeof(nscoord) * 8);
     return false;
   }
 
   if (IsThemed()) {
     // When we're themed, the native theme code draws the border and
     // background, and therefore it doesn't make sense to tell other
@@ -5067,17 +5071,18 @@ nsresult nsFrame::GetCursor(const nsPoin
     aCursor.mCursor = StyleCursorKind::VerticalText;
   }
 
   return NS_OK;
 }
 
 // Resize and incremental reflow
 
-/* virtual */ void nsFrame::MarkIntrinsicISizesDirty() {
+/* virtual */
+void nsFrame::MarkIntrinsicISizesDirty() {
   // This version is meant only for what used to be box-to-block adaptors.
   // It should not be called by other derived classes.
   if (::IsXULBoxWrapped(this)) {
     nsBoxLayoutMetrics* metrics = BoxMetrics();
 
     SizeNeedsRecalc(metrics->mPrefSize);
     SizeNeedsRecalc(metrics->mMinSize);
     SizeNeedsRecalc(metrics->mMaxSize);
@@ -5094,37 +5099,41 @@ nsresult nsFrame::GetCursor(const nsPoin
     nsFlexContainerFrame::MarkCachedFlexMeasurementsDirty(this);
   }
 
   if (GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT) {
     nsFontInflationData::MarkFontInflationDataTextDirty(this);
   }
 }
 
-/* virtual */ nscoord nsFrame::GetMinISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result = 0;
   DISPLAY_MIN_INLINE_SIZE(this, result);
   return result;
 }
 
-/* virtual */ nscoord nsFrame::GetPrefISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nscoord result = 0;
   DISPLAY_PREF_INLINE_SIZE(this, result);
   return result;
 }
 
-/* virtual */ void nsFrame::AddInlineMinISize(
-    gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
+/* virtual */
+void nsFrame::AddInlineMinISize(gfxContext* aRenderingContext,
+                                nsIFrame::InlineMinISizeData* aData) {
   nscoord isize = nsLayoutUtils::IntrinsicForContainer(
       aRenderingContext, this, nsLayoutUtils::MIN_ISIZE);
   aData->DefaultAddInlineMinISize(this, isize);
 }
 
-/* virtual */ void nsFrame::AddInlinePrefISize(
-    gfxContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) {
+/* virtual */
+void nsFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
+                                 nsIFrame::InlinePrefISizeData* aData) {
   nscoord isize = nsLayoutUtils::IntrinsicForContainer(
       aRenderingContext, this, nsLayoutUtils::PREF_ISIZE);
   aData->DefaultAddInlinePrefISize(isize);
 }
 
 void nsIFrame::InlineMinISizeData::DefaultAddInlineMinISize(nsIFrame* aFrame,
                                                             nscoord aISize,
                                                             bool aAllowBreak) {
@@ -5347,21 +5356,23 @@ static nsIFrame::IntrinsicISizeOffsetDat
   return IntrinsicSizeOffsets(this, aPercentageBasis, true);
 }
 
 nsIFrame::IntrinsicISizeOffsetData nsIFrame::IntrinsicBSizeOffsets(
     nscoord aPercentageBasis) {
   return IntrinsicSizeOffsets(this, aPercentageBasis, false);
 }
 
-/* virtual */ IntrinsicSize nsFrame::GetIntrinsicSize() {
+/* virtual */
+IntrinsicSize nsFrame::GetIntrinsicSize() {
   return IntrinsicSize();  // default is width/height set to eStyleUnit_None
 }
 
-/* virtual */ nsSize nsFrame::GetIntrinsicRatio() { return nsSize(0, 0); }
+/* virtual */
+nsSize nsFrame::GetIntrinsicRatio() { return nsSize(0, 0); }
 
 /* virtual */
 LogicalSize nsFrame::ComputeSize(gfxContext* aRenderingContext, WritingMode aWM,
                                  const LogicalSize& aCBSize,
                                  nscoord aAvailableISize,
                                  const LogicalSize& aMargin,
                                  const LogicalSize& aBorder,
                                  const LogicalSize& aPadding,
@@ -6069,19 +6080,19 @@ nsRect nsFrame::ComputeSimpleTightBounds
       nsIFrame* child = childFrames.get();
       r.UnionRect(
           r, child->ComputeTightBounds(aDrawTarget) + child->GetPosition());
     }
   }
   return r;
 }
 
-/* virtual */ nsresult nsIFrame::GetPrefWidthTightBounds(gfxContext* aContext,
-                                                         nscoord* aX,
-                                                         nscoord* aXMost) {
+/* virtual */
+nsresult nsIFrame::GetPrefWidthTightBounds(gfxContext* aContext, nscoord* aX,
+                                           nscoord* aXMost) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 /* virtual */
 LogicalSize nsFrame::ComputeAutoSize(
     gfxContext* aRenderingContext, WritingMode aWM,
     const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize,
     const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder,
@@ -6260,17 +6271,18 @@ void nsFrame::PushDirtyBitToAbsoluteFram
     return;  // No dirty bit to push.
   }
   if (!HasAbsolutelyPositionedChildren()) {
     return;  // No absolute children to push to.
   }
   GetAbsoluteContainingBlock()->MarkAllFramesDirty();
 }
 
-/* virtual */ bool nsFrame::CanContinueTextRun() const {
+/* virtual */
+bool nsFrame::CanContinueTextRun() const {
   // By default, a frame will *not* allow a text run to be continued
   // through it.
   return false;
 }
 
 void nsFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
                      const ReflowInput& aReflowInput, nsReflowStatus& aStatus) {
   MarkInReflow();
@@ -6839,17 +6851,18 @@ void nsIFrame::InvalidateFrameWithRect(c
     rect = new nsRect();
     AddProperty(InvalidationRect(), rect);
     AddStateBits(NS_FRAME_HAS_INVALID_RECT);
   }
 
   *rect = rect->Union(aRect);
 }
 
-/*static*/ uint8_t nsIFrame::sLayerIsPrerenderedDataKey;
+/*static*/
+uint8_t nsIFrame::sLayerIsPrerenderedDataKey;
 
 static bool DoesLayerHaveOutOfDateFrameMetrics(Layer* aLayer) {
   for (uint32_t i = 0; i < aLayer->GetScrollMetadataCount(); i++) {
     const FrameMetrics& metrics = aLayer->GetFrameMetrics(i);
     if (!metrics.IsScrollable()) {
       continue;
     }
     nsIScrollableFrame* scrollableFrame =
@@ -7215,23 +7228,23 @@ bool nsIFrame::UpdateOverflow() {
     }
 
     return true;
   }
 
   return false;
 }
 
-/* virtual */ bool nsFrame::ComputeCustomOverflow(
-    nsOverflowAreas& aOverflowAreas) {
+/* virtual */
+bool nsFrame::ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) {
   return true;
 }
 
-/* virtual */ void nsFrame::UnionChildOverflow(
-    nsOverflowAreas& aOverflowAreas) {
+/* virtual */
+void nsFrame::UnionChildOverflow(nsOverflowAreas& aOverflowAreas) {
   if (!DoesClipChildren() &&
       !(IsXULCollapsed() && (IsXULBoxFrame() || ::IsXULBoxWrapped(this)))) {
     nsLayoutUtils::UnionChildOverflow(this, aOverflowAreas);
   }
 }
 
 // Define the MAX_FRAME_DEPTH to be the ContentSink's MAX_REFLOW_DEPTH plus
 // 4 for the frames above the document's frames:
@@ -7502,25 +7515,27 @@ void nsIFrame::RootFrameList(nsPresConte
 #endif
 
 bool nsIFrame::IsVisibleForPainting() { return StyleVisibility()->IsVisible(); }
 
 bool nsIFrame::IsVisibleOrCollapsedForPainting() {
   return StyleVisibility()->IsVisibleOrCollapsed();
 }
 
-/* virtual */ bool nsFrame::IsEmpty() { return false; }
+/* virtual */
+bool nsFrame::IsEmpty() { return false; }
 
 bool nsIFrame::CachedIsEmpty() {
   MOZ_ASSERT(!(GetStateBits() & NS_FRAME_IS_DIRTY),
              "Must only be called on reflowed lines");
   return IsEmpty();
 }
 
-/* virtual */ bool nsFrame::IsSelfEmpty() { return false; }
+/* virtual */
+bool nsFrame::IsSelfEmpty() { return false; }
 
 nsresult nsFrame::GetSelectionController(nsPresContext* aPresContext,
                                          nsISelectionController** aSelCon) {
   if (!aPresContext || !aSelCon) return NS_ERROR_INVALID_ARG;
 
   nsIFrame* frame = this;
   while (frame && (frame->GetStateBits() & NS_FRAME_INDEPENDENT_SELECTION)) {
     nsITextControlFrame* tcf = do_QueryFrame(frame);
@@ -8653,17 +8668,18 @@ nsView* nsIFrame::GetClosestView(nsPoint
     }
     offset += f->GetPosition();
   }
 
   MOZ_ASSERT_UNREACHABLE("No view on any parent?  How did that happen?");
   return nullptr;
 }
 
-/* virtual */ void nsFrame::ChildIsDirty(nsIFrame* aChild) {
+/* virtual */
+void nsFrame::ChildIsDirty(nsIFrame* aChild) {
   MOZ_ASSERT_UNREACHABLE(
       "should never be called on a frame that doesn't "
       "inherit from nsContainerFrame");
 }
 
 #ifdef ACCESSIBILITY
 a11y::AccType nsFrame::AccessibleType() {
   if (IsTableCaption() && !GetRect().IsEmpty()) {
@@ -9535,17 +9551,18 @@ void nsFrame::GetFirstLeaf(nsPresContext
   nsIFrame* child = *aFrame;
   while (1) {
     child = child->PrincipalChildList().FirstChild();
     if (!child) return;  // nothing to do
     *aFrame = child;
   }
 }
 
-/* virtual */ bool nsIFrame::IsFocusable(int32_t* aTabIndex, bool aWithMouse) {
+/* virtual */
+bool nsIFrame::IsFocusable(int32_t* aTabIndex, bool aWithMouse) {
   int32_t tabIndex = -1;
   if (aTabIndex) {
     *aTabIndex = -1;  // Default for early return is not focusable
   }
   bool isFocusable = false;
 
   if (mContent && mContent->IsElement() && IsVisibleConsideringAncestors() &&
       Style()->GetPseudoType() != PseudoStyleType::anonymousFlexItem &&
@@ -9765,17 +9782,18 @@ nsFrame::RefreshSizeCache(nsBoxLayoutSta
            metrics->mBlockPrefSize.width, metrics->mBlockPrefSize.height,
            metrics->mBlockAscent);
 #endif
   }
 
   return NS_OK;
 }
 
-/* virtual */ nsILineIterator* nsFrame::GetLineIterator() { return nullptr; }
+/* virtual */
+nsILineIterator* nsFrame::GetLineIterator() { return nullptr; }
 
 nsSize nsFrame::GetXULPrefSize(nsBoxLayoutState& aState) {
   nsSize size(0, 0);
   DISPLAY_PREF_SIZE(this, size);
   // If the size is cached, and there are no HTML constraints that we might
   // be depending on, then we just return the cached size.
   nsBoxLayoutMetrics* metrics = BoxMetrics();
   if (!DoesNeedRecalc(metrics->mPrefSize)) {
@@ -10252,17 +10270,18 @@ void nsIFrame::UpdateStyleOfChildAnonBox
 
   // We do need to handle block pseudo-elements here, though.  Especially list
   // bullets.
   if (nsBlockFrame* block = do_QueryFrame(aChildFrame)) {
     block->UpdatePseudoElementStyles(childrenState);
   }
 }
 
-/* static */ nsChangeHint nsIFrame::UpdateStyleOfOwnedChildFrame(
+/* static */
+nsChangeHint nsIFrame::UpdateStyleOfOwnedChildFrame(
     nsIFrame* aChildFrame, ComputedStyle* aNewComputedStyle,
     ServoRestyleState& aRestyleState,
     const Maybe<ComputedStyle*>& aContinuationComputedStyle) {
   MOZ_ASSERT(!aChildFrame->GetAdditionalComputedStyle(0),
              "We don't handle additional styles here");
 
   // Figure out whether we have an actual change.  It's important that we do
   // this, for several reasons:
@@ -10304,17 +10323,18 @@ void nsIFrame::UpdateStyleOfChildAnonBox
        kid = kid->GetNextContinuation()) {
     MOZ_ASSERT(!kid->GetAdditionalComputedStyle(0));
     kid->SetComputedStyle(continuationStyle);
   }
 
   return childHint;
 }
 
-/* static */ void nsIFrame::AddInPopupStateBitToDescendants(nsIFrame* aFrame) {
+/* static */
+void nsIFrame::AddInPopupStateBitToDescendants(nsIFrame* aFrame) {
   if (!aFrame->HasAnyStateBits(NS_FRAME_IN_POPUP) &&
       aFrame->TrackingVisibility()) {
     // Assume all frames in popups are visible.
     aFrame->IncApproximateVisibleCount();
   }
 
   aFrame->AddStateBits(NS_FRAME_IN_POPUP);
 
@@ -10325,18 +10345,18 @@ void nsIFrame::UpdateStyleOfChildAnonBox
   for (; !lists.IsDone(); lists.Next()) {
     nsFrameList::Enumerator childFrames(lists.CurrentList());
     for (; !childFrames.AtEnd(); childFrames.Next()) {
       AddInPopupStateBitToDescendants(childFrames.get());
     }
   }
 }
 
-/* static */ void nsIFrame::RemoveInPopupStateBitFromDescendants(
-    nsIFrame* aFrame) {
+/* static */
+void nsIFrame::RemoveInPopupStateBitFromDescendants(nsIFrame* aFrame) {
   if (!aFrame->HasAnyStateBits(NS_FRAME_IN_POPUP) ||
       nsLayoutUtils::IsPopup(aFrame)) {
     return;
   }
 
   aFrame->RemoveStateBits(NS_FRAME_IN_POPUP);
 
   if (aFrame->TrackingVisibility()) {
@@ -10614,18 +10634,18 @@ void nsIFrame::DoUpdateStyleOfOwnedAnonB
     if (box.mUpdateStyleFn) {
       box.mUpdateStyleFn(this, box.mAnonBoxFrame, aRestyleState);
     } else {
       UpdateStyleOfChildAnonBox(box.mAnonBoxFrame, aRestyleState);
     }
   }
 }
 
-/* virtual */ void nsIFrame::AppendDirectlyOwnedAnonBoxes(
-    nsTArray<OwnedAnonBox>& aResult) {
+/* virtual */
+void nsIFrame::AppendDirectlyOwnedAnonBoxes(nsTArray<OwnedAnonBox>& aResult) {
   MOZ_ASSERT(!(GetStateBits() & NS_FRAME_OWNS_ANON_BOXES));
   MOZ_ASSERT(false, "Why did this get called?");
 }
 
 void nsIFrame::DoAppendOwnedAnonBoxes(nsTArray<OwnedAnonBox>& aResult) {
   size_t i = aResult.Length();
   AppendDirectlyOwnedAnonBoxes(aResult);
 
@@ -11856,35 +11876,40 @@ void nsFrame::DisplayIntrinsicSizeExit(n
     char height[16];
     DR_state->PrettyUC(aResult.width, width, 16);
     DR_state->PrettyUC(aResult.height, height, 16);
     printf("Get%sSize=%s,%s\n", aType, width, height);
   }
   DR_state->DeleteTreeNode(*treeNode);
 }
 
-/* static */ void nsFrame::DisplayReflowStartup() { DR_state = new DR_State(); }
-
-/* static */ void nsFrame::DisplayReflowShutdown() {
+/* static */
+void nsFrame::DisplayReflowStartup() { DR_state = new DR_State(); }
+
+/* static */
+void nsFrame::DisplayReflowShutdown() {
   delete DR_state;
   DR_state = nullptr;
 }
 
 void DR_cookie::Change() const {
   DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)mValue;
   if (treeNode && treeNode->mDisplay) {
     DisplayReflowEnterPrint(mPresContext, mFrame, mReflowInput, *treeNode,
                             true);
   }
 }
 
-/* static */ void* ReflowInput::DisplayInitConstraintsEnter(
-    nsIFrame* aFrame, ReflowInput* aState, nscoord aContainingBlockWidth,
-    nscoord aContainingBlockHeight, const nsMargin* aBorder,
-    const nsMargin* aPadding) {
+/* static */
+void* ReflowInput::DisplayInitConstraintsEnter(nsIFrame* aFrame,
+                                               ReflowInput* aState,
+                                               nscoord aContainingBlockWidth,
+                                               nscoord aContainingBlockHeight,
+                                               const nsMargin* aBorder,
+                                               const nsMargin* aPadding) {
   MOZ_ASSERT(aFrame, "non-null frame required");
   MOZ_ASSERT(aState, "non-null state required");
 
   if (!DR_state->mInited) DR_state->Init();
   if (!DR_state->mActive) return nullptr;
 
   DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, aState);
   if (treeNode && treeNode->mDisplay) {
@@ -11905,19 +11930,20 @@ void DR_cookie::Change() const {
 
     DR_state->PrintMargin("b", aBorder);
     DR_state->PrintMargin("p", aPadding);
     putchar('\n');
   }
   return treeNode;
 }
 
-/* static */ void ReflowInput::DisplayInitConstraintsExit(nsIFrame* aFrame,
-                                                          ReflowInput* aState,
-                                                          void* aValue) {
+/* static */
+void ReflowInput::DisplayInitConstraintsExit(nsIFrame* aFrame,
+                                             ReflowInput* aState,
+                                             void* aValue) {
   MOZ_ASSERT(aFrame, "non-null frame required");
   MOZ_ASSERT(aState, "non-null state required");
 
   if (!DR_state->mActive) return;
   if (!aValue) return;
 
   DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aValue;
   if (treeNode->mDisplay) {
@@ -11932,17 +11958,18 @@ void DR_cookie::Change() const {
     printf("InitConstraints= cw=(%s <= %s <= %s) ch=(%s <= %s <= %s)", cmiw, cw,
            cmxw, cmih, ch, cmxh);
     DR_state->PrintMargin("co", &aState->ComputedPhysicalOffsets());
     putchar('\n');
   }
   DR_state->DeleteTreeNode(*treeNode);
 }
 
-/* static */ void* SizeComputationInput::DisplayInitOffsetsEnter(
+/* static */
+void* SizeComputationInput::DisplayInitOffsetsEnter(
     nsIFrame* aFrame, SizeComputationInput* aState, nscoord aPercentBasis,
     WritingMode aCBWritingMode, const nsMargin* aBorder,
     const nsMargin* aPadding) {
   MOZ_ASSERT(aFrame, "non-null frame required");
   MOZ_ASSERT(aState, "non-null state required");
 
   if (!DR_state->mInited) DR_state->Init();
   if (!DR_state->mActive) return nullptr;
@@ -11958,18 +11985,20 @@ void DR_cookie::Change() const {
 
     DR_state->PrintMargin("b", aBorder);
     DR_state->PrintMargin("p", aPadding);
     putchar('\n');
   }
   return treeNode;
 }
 
-/* static */ void SizeComputationInput::DisplayInitOffsetsExit(
-    nsIFrame* aFrame, SizeComputationInput* aState, void* aValue) {
+/* static */
+void SizeComputationInput::DisplayInitOffsetsExit(nsIFrame* aFrame,
+                                                  SizeComputationInput* aState,
+                                                  void* aValue) {
   MOZ_ASSERT(aFrame, "non-null frame required");
   MOZ_ASSERT(aState, "non-null state required");
 
   if (!DR_state->mActive) return;
   if (!aValue) return;
 
   DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aValue;
   if (treeNode->mDisplay) {
@@ -11978,31 +12007,32 @@ void DR_cookie::Change() const {
     DR_state->PrintMargin("m", &aState->ComputedPhysicalMargin());
     DR_state->PrintMargin("p", &aState->ComputedPhysicalPadding());
     DR_state->PrintMargin("p+b", &aState->ComputedPhysicalBorderPadding());
     putchar('\n');
   }
   DR_state->DeleteTreeNode(*treeNode);
 }
 
-/* static */ void* ReflowInput::DisplayInitFrameTypeEnter(nsIFrame* aFrame,
-                                                          ReflowInput* aState) {
+/* static */
+void* ReflowInput::DisplayInitFrameTypeEnter(nsIFrame* aFrame,
+                                             ReflowInput* aState) {
   MOZ_ASSERT(aFrame, "non-null frame required");
   MOZ_ASSERT(aState, "non-null state required");
 
   if (!DR_state->mInited) DR_state->Init();
   if (!DR_state->mActive) return nullptr;
 
   // we don't print anything here
   return DR_state->CreateTreeNode(aFrame, aState);
 }
 
-/* static */ void ReflowInput::DisplayInitFrameTypeExit(nsIFrame* aFrame,
-                                                        ReflowInput* aState,
-                                                        void* aValue) {
+/* static */
+void ReflowInput::DisplayInitFrameTypeExit(nsIFrame* aFrame,
+                                           ReflowInput* aState, void* aValue) {
   MOZ_ASSERT(aFrame, "non-null frame required");
   MOZ_ASSERT(aState, "non-null state required");
 
   if (!DR_state->mActive) return;
   if (!aValue) return;
 
   DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aValue;
   if (treeNode->mDisplay) {
--- a/layout/generic/nsFrameList.cpp
+++ b/layout/generic/nsFrameList.cpp
@@ -276,17 +276,18 @@ int32_t nsFrameList::GetLength() const {
 void nsFrameList::ApplySetParent(nsContainerFrame* aParent) const {
   NS_ASSERTION(aParent, "null ptr");
 
   for (nsIFrame* f = FirstChild(); f; f = f->GetNextSibling()) {
     f->SetParent(aParent);
   }
 }
 
-/* static */ void nsFrameList::UnhookFrameFromSiblings(nsIFrame* aFrame) {
+/* static */
+void nsFrameList::UnhookFrameFromSiblings(nsIFrame* aFrame) {
   MOZ_ASSERT(aFrame->GetPrevSibling() && aFrame->GetNextSibling());
   nsIFrame* const nextSibling = aFrame->GetNextSibling();
   nsIFrame* const prevSibling = aFrame->GetPrevSibling();
   aFrame->SetNextSibling(nullptr);
   prevSibling->SetNextSibling(nextSibling);
   MOZ_ASSERT(!aFrame->GetPrevSibling() && !aFrame->GetNextSibling());
 }
 
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -821,25 +821,25 @@ nscoord nsHTMLScrollFrame::GetIntrinsicV
   // just for scrollbars
   nsBoxLayoutState bls(PresContext(), aRenderingContext, 0);
   nsSize vScrollbarPrefSize(0, 0);
   GetScrollbarMetrics(bls, mHelper.mVScrollbarBox, nullptr,
                       &vScrollbarPrefSize);
   return vScrollbarPrefSize.width;
 }
 
-/* virtual */ nscoord nsHTMLScrollFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsHTMLScrollFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result = mHelper.mScrolledFrame->GetMinISize(aRenderingContext);
   DISPLAY_MIN_INLINE_SIZE(this, result);
   return result + GetIntrinsicVScrollbarWidth(aRenderingContext);
 }
 
-/* virtual */ nscoord nsHTMLScrollFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsHTMLScrollFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nscoord result = mHelper.mScrolledFrame->GetPrefISize(aRenderingContext);
   DISPLAY_PREF_INLINE_SIZE(this, result);
   return NSCoordSaturatingAdd(result,
                               GetIntrinsicVScrollbarWidth(aRenderingContext));
 }
 
 nsresult nsHTMLScrollFrame::GetXULPadding(nsMargin& aMargin) {
   // Our padding hangs out on the inside of the scrollframe, but XUL doesn't
@@ -2631,18 +2631,19 @@ static nsPoint ClampAndAlignWithLayerPix
       ClampAndAlignWithPixels(aPt.x, aBounds.x, aBounds.XMost(), aRange.x,
                               aRange.XMost(), aAppUnitsPerPixel, aScale.width,
                               aCurrent.x),
       ClampAndAlignWithPixels(aPt.y, aBounds.y, aBounds.YMost(), aRange.y,
                               aRange.YMost(), aAppUnitsPerPixel, aScale.height,
                               aCurrent.y));
 }
 
-/* static */ void ScrollFrameHelper::ScrollActivityCallback(nsITimer* aTimer,
-                                                            void* anInstance) {
+/* static */
+void ScrollFrameHelper::ScrollActivityCallback(nsITimer* aTimer,
+                                               void* anInstance) {
   ScrollFrameHelper* self = static_cast<ScrollFrameHelper*>(anInstance);
 
   // Fire the synth mouse move.
   self->mScrollActivityTimer->Cancel();
   self->mScrollActivityTimer = nullptr;
   self->mOuter->PresShell()->SynthesizeMouseMove(true);
 }
 
@@ -3151,23 +3152,29 @@ void ScrollFrameHelper::AppendScrollPart
           aBuilder, scrollTargetId, scrollDirection, createLayer);
 
       ::AppendToTop(aBuilder, aLists, partList.PositionedDescendants(),
                     scrollParts[i], appendToTopFlags);
     }
   }
 }
 
-/* static */ bool ScrollFrameHelper::sFrameVisPrefsCached = false;
-/* static */ uint32_t ScrollFrameHelper::sHorzExpandScrollPort = 0;
-/* static */ uint32_t ScrollFrameHelper::sVertExpandScrollPort = 1;
-/* static */ int32_t ScrollFrameHelper::sHorzScrollFraction = 2;
-/* static */ int32_t ScrollFrameHelper::sVertScrollFraction = 2;
-
-/* static */ void ScrollFrameHelper::EnsureFrameVisPrefsCached() {
+/* static */
+bool ScrollFrameHelper::sFrameVisPrefsCached = false;
+/* static */
+uint32_t ScrollFrameHelper::sHorzExpandScrollPort = 0;
+/* static */
+uint32_t ScrollFrameHelper::sVertExpandScrollPort = 1;
+/* static */
+int32_t ScrollFrameHelper::sHorzScrollFraction = 2;
+/* static */
+int32_t ScrollFrameHelper::sVertScrollFraction = 2;
+
+/* static */
+void ScrollFrameHelper::EnsureFrameVisPrefsCached() {
   if (!sFrameVisPrefsCached) {
     Preferences::AddUintVarCache(&sHorzExpandScrollPort,
                                  "layout.framevisibility.numscrollportwidths",
                                  (uint32_t)0);
     Preferences::AddUintVarCache(&sVertExpandScrollPort,
                                  "layout.framevisibility.numscrollportheights",
                                  1);
 
--- a/layout/generic/nsHTMLCanvasFrame.cpp
+++ b/layout/generic/nsHTMLCanvasFrame.cpp
@@ -259,43 +259,45 @@ nsIntSize nsHTMLCanvasFrame::GetCanvasSi
                "unsigned (non-negative) values");
   } else {
     MOZ_ASSERT_UNREACHABLE("couldn't get canvas size");
   }
 
   return size;
 }
 
-/* virtual */ nscoord nsHTMLCanvasFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsHTMLCanvasFrame::GetMinISize(gfxContext* aRenderingContext) {
   // XXX The caller doesn't account for constraints of the height,
   // min-height, and max-height properties.
   bool vertical = GetWritingMode().IsVertical();
   nscoord result = nsPresContext::CSSPixelsToAppUnits(
       vertical ? GetCanvasSize().height : GetCanvasSize().width);
   DISPLAY_MIN_INLINE_SIZE(this, result);
   return result;
 }
 
-/* virtual */ nscoord nsHTMLCanvasFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsHTMLCanvasFrame::GetPrefISize(gfxContext* aRenderingContext) {
   // XXX The caller doesn't account for constraints of the height,
   // min-height, and max-height properties.
   bool vertical = GetWritingMode().IsVertical();
   nscoord result = nsPresContext::CSSPixelsToAppUnits(
       vertical ? GetCanvasSize().height : GetCanvasSize().width);
   DISPLAY_PREF_INLINE_SIZE(this, result);
   return result;
 }
 
-/* virtual */ IntrinsicSize nsHTMLCanvasFrame::GetIntrinsicSize() {
+/* virtual */
+IntrinsicSize nsHTMLCanvasFrame::GetIntrinsicSize() {
   return IntrinsicSizeFromCanvasSize(GetCanvasSize());
 }
 
-/* virtual */ nsSize nsHTMLCanvasFrame::GetIntrinsicRatio() {
+/* virtual */
+nsSize nsHTMLCanvasFrame::GetIntrinsicRatio() {
   return IntrinsicRatioFromCanvasSize(GetCanvasSize());
 }
 
 /* virtual */
 LogicalSize nsHTMLCanvasFrame::ComputeSize(
     gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
     nscoord aAvailableISize, const LogicalSize& aMargin,
     const LogicalSize& aBorder, const LogicalSize& aPadding,
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -574,18 +574,19 @@ static bool HasAltText(const Element& aE
 
   MOZ_ASSERT(aElement.IsHTMLElement(nsGkAtoms::img));
   nsAutoString altText;
   return aElement.GetAttr(nsGkAtoms::alt, altText) && !altText.IsEmpty();
 }
 
 // Check if we want to use an image frame or just let the frame constructor make
 // us into an inline.
-/* static */ bool nsImageFrame::ShouldCreateImageFrameFor(
-    const Element& aElement, ComputedStyle& aStyle) {
+/* static */
+bool nsImageFrame::ShouldCreateImageFrameFor(const Element& aElement,
+                                             ComputedStyle& aStyle) {
   EventStates state = aElement.State();
   if (IMAGE_OK(state, HaveSpecifiedSize(aStyle.StylePosition()))) {
     // Image is fine; do the image frame thing
     return true;
   }
 
   if (aStyle.StyleUIReset()->mForceBrokenImageIcon) {
     return true;
@@ -940,49 +941,48 @@ nscoord nsImageFrame::GetContinuationOff
   nscoord offset = 0;
   for (nsIFrame* f = GetPrevInFlow(); f; f = f->GetPrevInFlow()) {
     offset += f->GetContentRect().height;
   }
   NS_ASSERTION(offset >= 0, "bogus GetContentRect");
   return offset;
 }
 
-/* virtual */ nscoord nsImageFrame::GetMinISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsImageFrame::GetMinISize(gfxContext* aRenderingContext) {
   // XXX The caller doesn't account for constraints of the block-size,
   // min-block-size, and max-block-size properties.
   DebugOnly<nscoord> result;
   DISPLAY_MIN_INLINE_SIZE(this, result);
   EnsureIntrinsicSizeAndRatio();
   const nsStyleCoord& iSize = GetWritingMode().IsVertical()
                                   ? mIntrinsicSize.height
                                   : mIntrinsicSize.width;
   return iSize.GetUnit() == eStyleUnit_Coord ? iSize.GetCoordValue() : 0;
 }
 
-/* virtual */ nscoord nsImageFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsImageFrame::GetPrefISize(gfxContext* aRenderingContext) {
   // XXX The caller doesn't account for constraints of the block-size,
   // min-block-size, and max-block-size properties.
   DebugOnly<nscoord> result;
   DISPLAY_PREF_INLINE_SIZE(this, result);
   EnsureIntrinsicSizeAndRatio();
   const nsStyleCoord& iSize = GetWritingMode().IsVertical()
                                   ? mIntrinsicSize.height
                                   : mIntrinsicSize.width;
   // convert from normal twips to scaled twips (printing...)
   return iSize.GetUnit() == eStyleUnit_Coord ? iSize.GetCoordValue() : 0;
 }
 
-/* virtual */ IntrinsicSize nsImageFrame::GetIntrinsicSize() {
-  return mIntrinsicSize;
-}
-
-/* virtual */ nsSize nsImageFrame::GetIntrinsicRatio() {
-  return mIntrinsicRatio;
-}
+/* virtual */
+IntrinsicSize nsImageFrame::GetIntrinsicSize() { return mIntrinsicSize; }
+
+/* virtual */
+nsSize nsImageFrame::GetIntrinsicRatio() { return mIntrinsicRatio; }
 
 void nsImageFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aMetrics,
                           const ReflowInput& aReflowInput,
                           nsReflowStatus& aStatus) {
   MarkInReflow();
   DO_GLOBAL_REFLOW_COUNT("nsImageFrame");
   DISPLAY_REFLOW(aPresContext, this, aReflowInput, aMetrics, aStatus);
   MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
@@ -1841,18 +1841,19 @@ LayerState nsDisplayImage::GetLayerState
   nsImageFrame* f = static_cast<nsImageFrame*>(mFrame);
   if (f->HasImageMap()) {
     return LAYER_NONE;
   }
 
   return LAYER_ACTIVE;
 }
 
-/* virtual */ nsRegion nsDisplayImage::GetOpaqueRegion(
-    nsDisplayListBuilder* aBuilder, bool* aSnap) const {
+/* virtual */
+nsRegion nsDisplayImage::GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
+                                         bool* aSnap) const {
   *aSnap = false;
   if (mImage && mImage->WillDrawOpaqueNow()) {
     const nsRect frameContentBox = GetBounds(aSnap);
     return GetDestRect().Intersect(frameContentBox);
   }
   return nsRegion();
 }
 
@@ -2622,15 +2623,16 @@ static bool IsInAutoWidthTableCellForQui
   if (ancestor->Style()->GetPseudoType() == PseudoStyleType::cellContent) {
     // Assume direct parent is a table cell frame.
     nsFrame* grandAncestor = static_cast<nsFrame*>(ancestor->GetParent());
     return grandAncestor && grandAncestor->StylePosition()->mWidth.IsAuto();
   }
   return false;
 }
 
-/* virtual */ void nsImageFrame::AddInlineMinISize(
-    gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
+/* virtual */
+void nsImageFrame::AddInlineMinISize(gfxContext* aRenderingContext,
+                                     nsIFrame::InlineMinISizeData* aData) {
   nscoord isize = nsLayoutUtils::IntrinsicForContainer(
       aRenderingContext, this, nsLayoutUtils::MIN_ISIZE);
   bool canBreak = !IsInAutoWidthTableCellForQuirk(this);
   aData->DefaultAddInlineMinISize(this, isize, canBreak);
 }
--- a/layout/generic/nsInlineFrame.cpp
+++ b/layout/generic/nsInlineFrame.cpp
@@ -75,17 +75,18 @@ void nsInlineFrame::InvalidateFrameWithR
                                             aRebuildDisplayItems);
 }
 
 static inline bool IsMarginZero(const LengthPercentageOrAuto& aLength) {
   return aLength.IsAuto() ||
          nsLayoutUtils::IsMarginZero(aLength.AsLengthPercentage());
 }
 
-/* virtual */ bool nsInlineFrame::IsSelfEmpty() {
+/* virtual */
+bool nsInlineFrame::IsSelfEmpty() {
 #if 0
   // I used to think inline frames worked this way, but it seems they
   // don't.  At least not in our codebase.
   if (GetPresContext()->CompatibilityMode() == eCompatibility_FullStandards) {
     return false;
   }
 #endif
   const nsStyleMargin* margin = StyleMargin();
@@ -221,23 +222,25 @@ void nsInlineFrame::BuildDisplayList(nsD
   if (!mFrames.FirstChild()) {
     DisplaySelectionOverlay(aBuilder, aLists.Content());
   }
 }
 
 //////////////////////////////////////////////////////////////////////
 // Reflow methods
 
-/* virtual */ void nsInlineFrame::AddInlineMinISize(
-    gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
+/* virtual */
+void nsInlineFrame::AddInlineMinISize(gfxContext* aRenderingContext,
+                                      nsIFrame::InlineMinISizeData* aData) {
   DoInlineIntrinsicISize(aRenderingContext, aData, nsLayoutUtils::MIN_ISIZE);
 }
 
-/* virtual */ void nsInlineFrame::AddInlinePrefISize(
-    gfxContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) {
+/* virtual */
+void nsInlineFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
+                                       nsIFrame::InlinePrefISizeData* aData) {
   DoInlineIntrinsicISize(aRenderingContext, aData, nsLayoutUtils::PREF_ISIZE);
   aData->mLineIsEmpty = false;
 }
 
 /* virtual */
 LogicalSize nsInlineFrame::ComputeSize(
     gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
     nscoord aAvailableISize, const LogicalSize& aMargin,
@@ -402,36 +405,39 @@ bool nsInlineFrame::DrainSelfOverflowLis
       restyleManager->ReparentComputedStyleForFirstLine(f);
       nsLayoutUtils::MarkDescendantsDirty(f);
     }
   }
   mFrames.AppendFrames(nullptr, *overflowFrames);
   return true;
 }
 
-/* virtual */ bool nsInlineFrame::DrainSelfOverflowList() {
+/* virtual */
+bool nsInlineFrame::DrainSelfOverflowList() {
   nsIFrame* lineContainer = nsLayoutUtils::FindNearestBlockAncestor(this);
   // Add the eInFirstLine flag if we have a ::first-line ancestor frame.
   // No need to look further than the nearest line container though.
   bool inFirstLine = false;
   for (nsIFrame* p = GetParent(); p != lineContainer; p = p->GetParent()) {
     if (p->IsLineFrame()) {
       inFirstLine = true;
       break;
     }
   }
   return DrainSelfOverflowListInternal(inFirstLine);
 }
 
-/* virtual */ bool nsInlineFrame::CanContinueTextRun() const {
+/* virtual */
+bool nsInlineFrame::CanContinueTextRun() const {
   // We can continue a text run through an inline frame
   return true;
 }
 
-/* virtual */ void nsInlineFrame::PullOverflowsFromPrevInFlow() {
+/* virtual */
+void nsInlineFrame::PullOverflowsFromPrevInFlow() {
   nsInlineFrame* prevInFlow = static_cast<nsInlineFrame*>(GetPrevInFlow());
   if (prevInFlow) {
     nsPresContext* presContext = PresContext();
     AutoFrameListPtr prevOverflowFrames(presContext,
                                         prevInFlow->StealOverflowFrames());
     if (prevOverflowFrames) {
       // Assume that our prev-in-flow has the same line container that we do.
       nsContainerFrame::ReparentFrameViewList(*prevOverflowFrames, prevInFlow,
@@ -635,17 +641,18 @@ void nsInlineFrame::ReflowFrames(nsPresC
 #ifdef NOISY_FINAL_SIZE
   ListTag(stdout);
   printf(": metrics=%d,%d ascent=%d\n", aMetrics.Width(), aMetrics.Height(),
          aMetrics.TopAscent());
 #endif
 }
 
 // Returns whether there's any remaining frame to pull.
-/* static */ bool nsInlineFrame::HasFramesToPull(nsInlineFrame* aNextInFlow) {
+/* static */
+bool nsInlineFrame::HasFramesToPull(nsInlineFrame* aNextInFlow) {
   while (aNextInFlow) {
     if (!aNextInFlow->mFrames.IsEmpty()) {
       return true;
     }
     if (const nsFrameList* overflow = aNextInFlow->GetOverflowFrames()) {
       if (!overflow->IsEmpty()) {
         return true;
       }
@@ -1047,33 +1054,35 @@ void nsFirstLineFrame::Reflow(nsPresCont
   ReflowFrames(aPresContext, aReflowInput, irs, aMetrics, aStatus);
   aReflowInput.mLineLayout->SetInFirstLine(false);
 
   ReflowAbsoluteFrames(aPresContext, aMetrics, aReflowInput, aStatus);
 
   // Note: the line layout code will properly compute our overflow state for us
 }
 
-/* virtual */ void nsFirstLineFrame::PullOverflowsFromPrevInFlow() {
+/* virtual */
+void nsFirstLineFrame::PullOverflowsFromPrevInFlow() {
   nsFirstLineFrame* prevInFlow =
       static_cast<nsFirstLineFrame*>(GetPrevInFlow());
   if (prevInFlow) {
     nsPresContext* presContext = PresContext();
     AutoFrameListPtr prevOverflowFrames(presContext,
                                         prevInFlow->StealOverflowFrames());
     if (prevOverflowFrames) {
       // Assume that our prev-in-flow has the same line container that we do.
       const nsFrameList::Slice& newFrames =
           mFrames.InsertFrames(this, nullptr, *prevOverflowFrames);
       ReparentChildListStyle(presContext, newFrames, this);
     }
   }
 }
 
-/* virtual */ bool nsFirstLineFrame::DrainSelfOverflowList() {
+/* virtual */
+bool nsFirstLineFrame::DrainSelfOverflowList() {
   AutoFrameListPtr overflowFrames(PresContext(), StealOverflowFrames());
   if (overflowFrames) {
     bool result = !overflowFrames->IsEmpty();
     const nsFrameList::Slice& newFrames =
         mFrames.AppendFrames(nullptr, *overflowFrames);
     ReparentChildListStyle(PresContext(), newFrames, this);
     return result;
   }
--- a/layout/generic/nsLeafFrame.cpp
+++ b/layout/generic/nsLeafFrame.cpp
@@ -8,24 +8,26 @@
 
 #include "nsLeafFrame.h"
 #include "nsPresContext.h"
 
 using namespace mozilla;
 
 nsLeafFrame::~nsLeafFrame() {}
 
-/* virtual */ nscoord nsLeafFrame::GetMinISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsLeafFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_MIN_INLINE_SIZE(this, result);
   result = GetIntrinsicISize();
   return result;
 }
 
-/* virtual */ nscoord nsLeafFrame::GetPrefISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsLeafFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_PREF_INLINE_SIZE(this, result);
   result = GetIntrinsicISize();
   return result;
 }
 
 /* virtual */
 LogicalSize nsLeafFrame::ComputeAutoSize(
--- a/layout/generic/nsLineBox.cpp
+++ b/layout/generic/nsLineBox.cpp
@@ -550,17 +550,18 @@ nsLineIterator::nsLineIterator() {
 }
 
 nsLineIterator::~nsLineIterator() {
   if (mLines != gDummyLines) {
     delete[] mLines;
   }
 }
 
-/* virtual */ void nsLineIterator::DisposeLineIterator() { delete this; }
+/* virtual */
+void nsLineIterator::DisposeLineIterator() { delete this; }
 
 nsresult nsLineIterator::Init(nsLineList& aLines, bool aRightToLeft) {
   mRightToLeft = aRightToLeft;
 
   // Count the lines
   int32_t numLines = aLines.size();
   if (0 == numLines) {
     // Use gDummyLines so that we don't need null pointer checks in
--- a/layout/generic/nsLineLayout.cpp
+++ b/layout/generic/nsLineLayout.cpp
@@ -2651,17 +2651,18 @@ struct nsLineLayout::JustificationComput
 static bool IsRubyAlignSpaceAround(nsIFrame* aRubyBase) {
   return aRubyBase->StyleText()->mRubyAlign == NS_STYLE_RUBY_ALIGN_SPACE_AROUND;
 }
 
 /**
  * Assign justification gaps for justification
  * opportunities across two frames.
  */
-/* static */ int nsLineLayout::AssignInterframeJustificationGaps(
+/* static */
+int nsLineLayout::AssignInterframeJustificationGaps(
     PerFrameData* aFrame, JustificationComputationState& aState) {
   PerFrameData* prev = aState.mLastParticipant;
   MOZ_ASSERT(prev);
 
   auto& assign = aFrame->mJustificationAssignment;
   auto& prevAssign = prev->mJustificationAssignment;
 
   if (aState.mLastExitedRubyBase || aState.mLastEnteredRubyBase) {
--- a/layout/generic/nsPlaceholderFrame.cpp
+++ b/layout/generic/nsPlaceholderFrame.cpp
@@ -36,55 +36,57 @@ nsPlaceholderFrame* NS_NewPlaceholderFra
 NS_IMPL_FRAMEARENA_HELPERS(nsPlaceholderFrame)
 
 #ifdef DEBUG
 NS_QUERYFRAME_HEAD(nsPlaceholderFrame)
   NS_QUERYFRAME_ENTRY(nsPlaceholderFrame)
 NS_QUERYFRAME_TAIL_INHERITING(nsFrame)
 #endif
 
-/* virtual */ nsSize nsPlaceholderFrame::GetXULMinSize(
-    nsBoxLayoutState& aBoxLayoutState) {
+/* virtual */
+nsSize nsPlaceholderFrame::GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) {
   nsSize size(0, 0);
   DISPLAY_MIN_SIZE(this, size);
   return size;
 }
 
-/* virtual */ nsSize nsPlaceholderFrame::GetXULPrefSize(
-    nsBoxLayoutState& aBoxLayoutState) {
+/* virtual */
+nsSize nsPlaceholderFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) {
   nsSize size(0, 0);
   DISPLAY_PREF_SIZE(this, size);
   return size;
 }
 
-/* virtual */ nsSize nsPlaceholderFrame::GetXULMaxSize(
-    nsBoxLayoutState& aBoxLayoutState) {
+/* virtual */
+nsSize nsPlaceholderFrame::GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) {
   nsSize size(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
   DISPLAY_MAX_SIZE(this, size);
   return size;
 }
 
-/* virtual */ void nsPlaceholderFrame::AddInlineMinISize(
+/* virtual */
+void nsPlaceholderFrame::AddInlineMinISize(
     gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
   // Override AddInlineMinWith so that *nothing* happens.  In
   // particular, we don't want to zero out |aData->mTrailingWhitespace|,
   // since nsLineLayout skips placeholders when trimming trailing
   // whitespace, and we don't want to set aData->mSkipWhitespace to
   // false.
 
   // ...but push floats onto the list
   if (mOutOfFlowFrame->IsFloating()) {
     nscoord floatWidth = nsLayoutUtils::IntrinsicForContainer(
         aRenderingContext, mOutOfFlowFrame, nsLayoutUtils::MIN_ISIZE);
     aData->mFloats.AppendElement(
         InlineIntrinsicISizeData::FloatInfo(mOutOfFlowFrame, floatWidth));
   }
 }
 
-/* virtual */ void nsPlaceholderFrame::AddInlinePrefISize(
+/* virtual */
+void nsPlaceholderFrame::AddInlinePrefISize(
     gfxContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) {
   // Override AddInlinePrefWith so that *nothing* happens.  In
   // particular, we don't want to zero out |aData->mTrailingWhitespace|,
   // since nsLineLayout skips placeholders when trimming trailing
   // whitespace, and we don't want to set aData->mSkipWhitespace to
   // false.
 
   // ...but push floats onto the list
@@ -180,17 +182,18 @@ void nsPlaceholderFrame::DestroyFrom(nsI
       fm->RemoveFrame(listId, oof);
     }
     // else oof will be destroyed by its parent
   }
 
   nsFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
 }
 
-/* virtual */ bool nsPlaceholderFrame::CanContinueTextRun() const {
+/* virtual */
+bool nsPlaceholderFrame::CanContinueTextRun() const {
   if (!mOutOfFlowFrame) {
     return false;
   }
   // first-letter frames can continue text runs, and placeholders for floated
   // first-letter frames can too
   return mOutOfFlowFrame->CanContinueTextRun();
 }
 
--- a/layout/generic/nsPluginFrame.cpp
+++ b/layout/generic/nsPluginFrame.cpp
@@ -197,18 +197,18 @@ void nsPluginFrame::DestroyFrom(nsIFrame
 
   if (mBackgroundSink) {
     mBackgroundSink->Destroy();
   }
 
   nsFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
 }
 
-/* virtual */ void nsPluginFrame::DidSetComputedStyle(
-    ComputedStyle* aOldComputedStyle) {
+/* virtual */
+void nsPluginFrame::DidSetComputedStyle(ComputedStyle* aOldComputedStyle) {
   if (HasView()) {
     nsView* view = GetView();
     nsViewManager* vm = view->GetViewManager();
     if (vm) {
       nsViewVisibility visibility =
           IsHidden() ? nsViewVisibility_kHide : nsViewVisibility_kShow;
       vm->SetViewVisibility(view, visibility);
     }
@@ -346,34 +346,34 @@ nsresult nsPluginFrame::PrepForDrawing(n
 #endif
 
   return NS_OK;
 }
 
 #define EMBED_DEF_WIDTH 240
 #define EMBED_DEF_HEIGHT 200
 
-/* virtual */ nscoord nsPluginFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsPluginFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result = 0;
 
   if (!IsHidden(false)) {
     if (mContent->IsHTMLElement(nsGkAtoms::embed)) {
       bool vertical = GetWritingMode().IsVertical();
       result = nsPresContext::CSSPixelsToAppUnits(vertical ? EMBED_DEF_HEIGHT
                                                            : EMBED_DEF_WIDTH);
     }
   }
 
   DISPLAY_MIN_INLINE_SIZE(this, result);
   return result;
 }
 
-/* virtual */ nscoord nsPluginFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsPluginFrame::GetPrefISize(gfxContext* aRenderingContext) {
   return nsPluginFrame::GetMinISize(aRenderingContext);
 }
 
 void nsPluginFrame::GetWidgetConfiguration(
     nsTArray<nsIWidget::Configuration>* aConfigurations) {
   if (!mWidget) {
     return;
   }
@@ -797,20 +797,19 @@ void nsPluginFrame::DidReflow(nsPresCont
     nsView* view = GetView();
     nsViewManager* vm = view->GetViewManager();
     if (vm)
       vm->SetViewVisibility(
           view, IsHidden() ? nsViewVisibility_kHide : nsViewVisibility_kShow);
   }
 }
 
-/* static */ void nsPluginFrame::PaintPrintPlugin(nsIFrame* aFrame,
-                                                  gfxContext* aCtx,
-                                                  const nsRect& aDirtyRect,
-                                                  nsPoint aPt) {
+/* static */
+void nsPluginFrame::PaintPrintPlugin(nsIFrame* aFrame, gfxContext* aCtx,
+                                     const nsRect& aDirtyRect, nsPoint aPt) {
   // Translate the context:
   nsPoint pt = aPt + aFrame->GetContentRectRelativeToSelf().TopLeft();
   gfxPoint devPixelPt = nsLayoutUtils::PointToGfxPoint(
       pt, aFrame->PresContext()->AppUnitsPerDevPixel());
 
   gfxContextMatrixAutoSaveRestore autoSR(aCtx);
   aCtx->SetMatrixDouble(aCtx->CurrentMatrixDouble().PreTranslate(devPixelPt));
 
@@ -1628,18 +1627,18 @@ nsIObjectFrame* nsPluginFrame::GetNextOb
 
     outFrame = GetNextObjectFrame(aPresContext, child);
     if (outFrame) return outFrame;
   }
 
   return nullptr;
 }
 
-/*static*/ void nsPluginFrame::BeginSwapDocShells(nsISupports* aSupports,
-                                                  void*) {
+/*static*/
+void nsPluginFrame::BeginSwapDocShells(nsISupports* aSupports, void*) {
   MOZ_ASSERT(aSupports, "null parameter");
   nsCOMPtr<nsIContent> content(do_QueryInterface(aSupports));
   if (!content) {
     return;
   }
 
   // This function is called from a document content enumerator so we need
   // to filter out the nsPluginFrames and ignore the rest.
@@ -1647,17 +1646,18 @@ nsIObjectFrame* nsPluginFrame::GetNextOb
   if (!obj) return;
 
   nsPluginFrame* objectFrame = static_cast<nsPluginFrame*>(obj);
   NS_ASSERTION(!objectFrame->mWidget || objectFrame->mWidget->GetParent(),
                "Plugin windows must not be toplevel");
   objectFrame->UnregisterPluginForGeometryUpdates();
 }
 
-/*static*/ void nsPluginFrame::EndSwapDocShells(nsISupports* aSupports, void*) {
+/*static*/
+void nsPluginFrame::EndSwapDocShells(nsISupports* aSupports, void*) {
   MOZ_ASSERT(aSupports, "null parameter");
   nsCOMPtr<nsIContent> content(do_QueryInterface(aSupports));
   if (!content) {
     return;
   }
 
   // This function is called from a document content enumerator so we need
   // to filter out the nsPluginFrames and ignore the rest.
--- a/layout/generic/nsRubyBaseContainerFrame.cpp
+++ b/layout/generic/nsRubyBaseContainerFrame.cpp
@@ -151,17 +151,18 @@ static nscoord CalculateColumnPrefISize(
     }
   }
   return max;
 }
 
 // FIXME Currently we use pref isize of ruby content frames for
 //       computing min isize of ruby frame, which may cause problem.
 //       See bug 1134945.
-/* virtual */ void nsRubyBaseContainerFrame::AddInlineMinISize(
+/* virtual */
+void nsRubyBaseContainerFrame::AddInlineMinISize(
     gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
   AutoRubyTextContainerArray textContainers(this);
 
   for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) {
     if (textContainers[i]->IsSpanContainer()) {
       // Since spans are not breakable internally, use our pref isize
       // directly if there is any span.
       nsIFrame::InlinePrefISizeData data;
@@ -203,17 +204,18 @@ static nscoord CalculateColumnPrefISize(
       aData->mCurrentLine += isize;
       if (isize > 0) {
         aData->mAtStartOfLine = false;
       }
     }
   }
 }
 
-/* virtual */ void nsRubyBaseContainerFrame::AddInlinePrefISize(
+/* virtual */
+void nsRubyBaseContainerFrame::AddInlinePrefISize(
     gfxContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) {
   AutoRubyTextContainerArray textContainers(this);
 
   nscoord sum = 0;
   for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
     RubyColumnEnumerator enumerator(
         static_cast<nsRubyBaseContainerFrame*>(frame), textContainers);
     for (; !enumerator.AtEnd(); enumerator.Next()) {
@@ -227,55 +229,58 @@ static nscoord CalculateColumnPrefISize(
       frame->AddInlinePrefISize(aRenderingContext, &data);
       MOZ_ASSERT(data.mPrevLines == 0, "Shouldn't have prev lines");
       sum = std::max(sum, data.mCurrentLine);
     }
   }
   aData->mCurrentLine += sum;
 }
 
-/* virtual */ bool nsRubyBaseContainerFrame::IsFrameOfType(
-    uint32_t aFlags) const {
+/* virtual */
+bool nsRubyBaseContainerFrame::IsFrameOfType(uint32_t aFlags) const {
   if (aFlags & (eSupportsCSSTransforms | eSupportsContainLayoutAndPaint)) {
     return false;
   }
   return nsContainerFrame::IsFrameOfType(aFlags &
                                          ~(nsIFrame::eLineParticipant));
 }
 
-/* virtual */ bool nsRubyBaseContainerFrame::CanContinueTextRun() const {
-  return true;
-}
+/* virtual */
+bool nsRubyBaseContainerFrame::CanContinueTextRun() const { return true; }
 
-/* virtual */ LogicalSize nsRubyBaseContainerFrame::ComputeSize(
+/* virtual */
+LogicalSize nsRubyBaseContainerFrame::ComputeSize(
     gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
     nscoord aAvailableISize, const LogicalSize& aMargin,
     const LogicalSize& aBorder, const LogicalSize& aPadding,
     ComputeSizeFlags aFlags) {
   // Ruby base container frame is inline,
   // hence don't compute size before reflow.
   return LogicalSize(aWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
 }
 
-/* virtual */ nscoord nsRubyBaseContainerFrame::GetLogicalBaseline(
+/* virtual */
+nscoord nsRubyBaseContainerFrame::GetLogicalBaseline(
     WritingMode aWritingMode) const {
   return mBaseline;
 }
 
 struct nsRubyBaseContainerFrame::RubyReflowInput {
   bool mAllowInitialLineBreak;
   bool mAllowLineBreak;
   const AutoRubyTextContainerArray& mTextContainers;
   const ReflowInput& mBaseReflowInput;
   const nsTArray<UniquePtr<ReflowInput>>& mTextReflowInputs;
 };
 
-/* virtual */ void nsRubyBaseContainerFrame::Reflow(
-    nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
-    const ReflowInput& aReflowInput, nsReflowStatus& aStatus) {
+/* virtual */
+void nsRubyBaseContainerFrame::Reflow(nsPresContext* aPresContext,
+                                      ReflowOutput& aDesiredSize,
+                                      const ReflowInput& aReflowInput,
+                                      nsReflowStatus& aStatus) {
   MarkInReflow();
   DO_GLOBAL_REFLOW_COUNT("nsRubyBaseContainerFrame");
   DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
   MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
 
   if (!aReflowInput.mLineLayout) {
     NS_ASSERTION(
         aReflowInput.mLineLayout,
--- a/layout/generic/nsRubyContentFrame.cpp
+++ b/layout/generic/nsRubyContentFrame.cpp
@@ -14,17 +14,18 @@
 
 using namespace mozilla;
 
 //----------------------------------------------------------------------
 
 // nsRubyContentFrame Method Implementations
 // ======================================
 
-/* virtual */ bool nsRubyContentFrame::IsFrameOfType(uint32_t aFlags) const {
+/* virtual */
+bool nsRubyContentFrame::IsFrameOfType(uint32_t aFlags) const {
   if (aFlags & eBidiInlineContainer) {
     return false;
   }
   return nsInlineFrame::IsFrameOfType(aFlags);
 }
 
 bool nsRubyContentFrame::IsIntraLevelWhitespace() const {
   auto pseudoType = Style()->GetPseudoType();
--- a/layout/generic/nsRubyFrame.cpp
+++ b/layout/generic/nsRubyFrame.cpp
@@ -35,41 +35,44 @@ nsContainerFrame* NS_NewRubyFrame(nsIPre
   return new (aPresShell) nsRubyFrame(aStyle, aPresShell->GetPresContext());
 }
 
 //----------------------------------------------------------------------
 
 // nsRubyFrame Method Implementations
 // ==================================
 
-/* virtual */ bool nsRubyFrame::IsFrameOfType(uint32_t aFlags) const {
+/* virtual */
+bool nsRubyFrame::IsFrameOfType(uint32_t aFlags) const {
   if (aFlags & eBidiInlineContainer) {
     return false;
   }
   return nsInlineFrame::IsFrameOfType(aFlags);
 }
 
 #ifdef DEBUG_FRAME_DUMP
 nsresult nsRubyFrame::GetFrameName(nsAString& aResult) const {
   return MakeFrameName(NS_LITERAL_STRING("Ruby"), aResult);
 }
 #endif
 
-/* virtual */ void nsRubyFrame::AddInlineMinISize(
-    gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
+/* virtual */
+void nsRubyFrame::AddInlineMinISize(gfxContext* aRenderingContext,
+                                    nsIFrame::InlineMinISizeData* aData) {
   for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
     for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd();
          e.Next()) {
       e.GetBaseContainer()->AddInlineMinISize(aRenderingContext, aData);
     }
   }
 }
 
-/* virtual */ void nsRubyFrame::AddInlinePrefISize(
-    gfxContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) {
+/* virtual */
+void nsRubyFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
+                                     nsIFrame::InlinePrefISizeData* aData) {
   for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
     for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd();
          e.Next()) {
       e.GetBaseContainer()->AddInlinePrefISize(aRenderingContext, aData);
     }
   }
   aData->mLineIsEmpty = false;
 }
@@ -81,20 +84,21 @@ static nsRubyBaseContainerFrame* FindRub
        ancestor = ancestor->GetParent()) {
     if (ancestor->IsRubyBaseContainerFrame()) {
       return static_cast<nsRubyBaseContainerFrame*>(ancestor);
     }
   }
   return nullptr;
 }
 
-/* virtual */ void nsRubyFrame::Reflow(nsPresContext* aPresContext,
-                                       ReflowOutput& aDesiredSize,
-                                       const ReflowInput& aReflowInput,
-                                       nsReflowStatus& aStatus) {
+/* virtual */
+void nsRubyFrame::Reflow(nsPresContext* aPresContext,
+                         ReflowOutput& aDesiredSize,
+                         const ReflowInput& aReflowInput,
+                         nsReflowStatus& aStatus) {
   MarkInReflow();
   DO_GLOBAL_REFLOW_COUNT("nsRubyFrame");
   DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
   MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
 
   if (!aReflowInput.mLineLayout) {
     NS_ASSERTION(aReflowInput.mLineLayout,
                  "No line layout provided to RubyFrame reflow method.");
--- a/layout/generic/nsRubyTextContainerFrame.cpp
+++ b/layout/generic/nsRubyTextContainerFrame.cpp
@@ -39,46 +39,51 @@ nsContainerFrame* NS_NewRubyTextContaine
 // ===============================================
 
 #ifdef DEBUG_FRAME_DUMP
 nsresult nsRubyTextContainerFrame::GetFrameName(nsAString& aResult) const {
   return MakeFrameName(NS_LITERAL_STRING("RubyTextContainer"), aResult);
 }
 #endif
 
-/* virtual */ bool nsRubyTextContainerFrame::IsFrameOfType(
-    uint32_t aFlags) const {
+/* virtual */
+bool nsRubyTextContainerFrame::IsFrameOfType(uint32_t aFlags) const {
   if (aFlags & (eSupportsCSSTransforms | eSupportsContainLayoutAndPaint)) {
     return false;
   }
   return nsContainerFrame::IsFrameOfType(aFlags);
 }
 
-/* virtual */ void nsRubyTextContainerFrame::SetInitialChildList(
-    ChildListID aListID, nsFrameList& aChildList) {
+/* virtual */
+void nsRubyTextContainerFrame::SetInitialChildList(ChildListID aListID,
+                                                   nsFrameList& aChildList) {
   nsContainerFrame::SetInitialChildList(aListID, aChildList);
   if (aListID == kPrincipalList) {
     UpdateSpanFlag();
   }
 }
 
-/* virtual */ void nsRubyTextContainerFrame::AppendFrames(
-    ChildListID aListID, nsFrameList& aFrameList) {
+/* virtual */
+void nsRubyTextContainerFrame::AppendFrames(ChildListID aListID,
+                                            nsFrameList& aFrameList) {
   nsContainerFrame::AppendFrames(aListID, aFrameList);
   UpdateSpanFlag();
 }
 
-/* virtual */ void nsRubyTextContainerFrame::InsertFrames(
-    ChildListID aListID, nsIFrame* aPrevFrame, nsFrameList& aFrameList) {
+/* virtual */
+void nsRubyTextContainerFrame::InsertFrames(ChildListID aListID,
+                                            nsIFrame* aPrevFrame,
+                                            nsFrameList& aFrameList) {
   nsContainerFrame::InsertFrames(aListID, aPrevFrame, aFrameList);
   UpdateSpanFlag();
 }
 
-/* virtual */ void nsRubyTextContainerFrame::RemoveFrame(ChildListID aListID,
-                                                         nsIFrame* aOldFrame) {
+/* virtual */
+void nsRubyTextContainerFrame::RemoveFrame(ChildListID aListID,
+                                           nsIFrame* aOldFrame) {
   nsContainerFrame::RemoveFrame(aListID, aOldFrame);
   UpdateSpanFlag();
 }
 
 void nsRubyTextContainerFrame::UpdateSpanFlag() {
   bool isSpan = false;
   // The continuation checks are safe here because spans never break.
   if (!GetPrevContinuation() && !GetNextContinuation()) {
@@ -92,19 +97,21 @@ void nsRubyTextContainerFrame::UpdateSpa
 
   if (isSpan) {
     AddStateBits(NS_RUBY_TEXT_CONTAINER_IS_SPAN);
   } else {
     RemoveStateBits(NS_RUBY_TEXT_CONTAINER_IS_SPAN);
   }
 }
 
-/* virtual */ void nsRubyTextContainerFrame::Reflow(
-    nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
-    const ReflowInput& aReflowInput, nsReflowStatus& aStatus) {
+/* virtual */
+void nsRubyTextContainerFrame::Reflow(nsPresContext* aPresContext,
+                                      ReflowOutput& aDesiredSize,
+                                      const ReflowInput& aReflowInput,
+                                      nsReflowStatus& aStatus) {
   MarkInReflow();
   DO_GLOBAL_REFLOW_COUNT("nsRubyTextContainerFrame");
   DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
   MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
 
   // Although a ruby text container may have continuations, returning
   // complete reflow status is still safe, since its parent, ruby frame,
   // ignores the status, and continuations of the ruby base container
--- a/layout/generic/nsRubyTextFrame.cpp
+++ b/layout/generic/nsRubyTextFrame.cpp
@@ -31,37 +31,40 @@ nsContainerFrame* NS_NewRubyTextFrame(ns
   return new (aPresShell) nsRubyTextFrame(aStyle, aPresShell->GetPresContext());
 }
 
 //----------------------------------------------------------------------
 
 // nsRubyTextFrame Method Implementations
 // ======================================
 
-/* virtual */ bool nsRubyTextFrame::CanContinueTextRun() const { return false; }
+/* virtual */
+bool nsRubyTextFrame::CanContinueTextRun() const { return false; }
 
 #ifdef DEBUG_FRAME_DUMP
 nsresult nsRubyTextFrame::GetFrameName(nsAString& aResult) const {
   return MakeFrameName(NS_LITERAL_STRING("RubyText"), aResult);
 }
 #endif
 
-/* virtual */ void nsRubyTextFrame::BuildDisplayList(
-    nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists) {
+/* virtual */
+void nsRubyTextFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                       const nsDisplayListSet& aLists) {
   if (IsAutoHidden()) {
     return;
   }
 
   nsRubyContentFrame::BuildDisplayList(aBuilder, aLists);
 }
 
-/* virtual */ void nsRubyTextFrame::Reflow(nsPresContext* aPresContext,
-                                           ReflowOutput& aDesiredSize,
-                                           const ReflowInput& aReflowInput,
-                                           nsReflowStatus& aStatus) {
+/* virtual */
+void nsRubyTextFrame::Reflow(nsPresContext* aPresContext,
+                             ReflowOutput& aDesiredSize,
+                             const ReflowInput& aReflowInput,
+                             nsReflowStatus& aStatus) {
   // Even if we want to hide this frame, we have to reflow it first.
   // If we leave it dirty, changes to its content will never be
   // propagated to the ancestors, then it won't be displayed even if
   // the content is no longer the same, until next reflow triggered by
   // some other change. In general, we always reflow all the frames we
   // created. There might be other problems if we don't do that.
   nsRubyContentFrame::Reflow(aPresContext, aDesiredSize, aReflowInput, aStatus);
 
--- a/layout/generic/nsSubDocumentFrame.cpp
+++ b/layout/generic/nsSubDocumentFrame.cpp
@@ -656,55 +656,57 @@ void nsSubDocumentFrame::List(FILE* out,
   }
 }
 
 nsresult nsSubDocumentFrame::GetFrameName(nsAString& aResult) const {
   return MakeFrameName(NS_LITERAL_STRING("FrameOuter"), aResult);
 }
 #endif
 
-/* virtual */ nscoord nsSubDocumentFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsSubDocumentFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_MIN_INLINE_SIZE(this, result);
 
   nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
   if (subDocRoot) {
     result = subDocRoot->GetMinISize(aRenderingContext);
   } else {
     result = GetIntrinsicISize();
   }
 
   return result;
 }
 
-/* virtual */ nscoord nsSubDocumentFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsSubDocumentFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_PREF_INLINE_SIZE(this, result);
 
   nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
   if (subDocRoot) {
     result = subDocRoot->GetPrefISize(aRenderingContext);
   } else {
     result = GetIntrinsicISize();
   }
 
   return result;
 }
 
-/* virtual */ IntrinsicSize nsSubDocumentFrame::GetIntrinsicSize() {
+/* virtual */
+IntrinsicSize nsSubDocumentFrame::GetIntrinsicSize() {
   nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
   if (subDocRoot) {
     return subDocRoot->GetIntrinsicSize();
   }
   return nsAtomicContainerFrame::GetIntrinsicSize();
 }
 
-/* virtual */ nsSize nsSubDocumentFrame::GetIntrinsicRatio() {
+/* virtual */
+nsSize nsSubDocumentFrame::GetIntrinsicRatio() {
   nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
   if (subDocRoot) {
     return subDocRoot->GetIntrinsicRatio();
   }
   return nsAtomicContainerFrame::GetIntrinsicRatio();
 }
 
 /* virtual */
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -4228,19 +4228,22 @@ void nsTextPaintStyle::InitSelectionStyl
   selectionStyle->mTextColor = foreColor;
   selectionStyle->mBGColor = backColor;
   selectionStyle->mUnderlineColor = lineColor;
   selectionStyle->mUnderlineStyle = lineStyle;
   selectionStyle->mUnderlineRelativeSize = relativeSize;
   selectionStyle->mInit = true;
 }
 
-/* static */ bool nsTextPaintStyle::GetSelectionUnderline(
-    nsPresContext* aPresContext, int32_t aIndex, nscolor* aLineColor,
-    float* aRelativeSize, uint8_t* aStyle) {
+/* static */
+bool nsTextPaintStyle::GetSelectionUnderline(nsPresContext* aPresContext,
+                                             int32_t aIndex,
+                                             nscolor* aLineColor,
+                                             float* aRelativeSize,
+                                             uint8_t* aStyle) {
   NS_ASSERTION(aPresContext, "aPresContext is null");
   NS_ASSERTION(aRelativeSize, "aRelativeSize is null");
   NS_ASSERTION(aStyle, "aStyle is null");
   NS_ASSERTION(aIndex >= 0 && aIndex < 5, "Index out of range");
 
   StyleIDs& styleID = SelectionStyleIDs[aIndex];
 
   nscolor color = LookAndFeel::GetColor(styleID.mLine);
@@ -4546,32 +4549,36 @@ nsIFrame* nsContinuingTextFrame::FirstCo
 // the advantage of avoiding the potential for incremental reflow bugs,
 // but depends on our maintining the frame tree in reasonable ways even
 // for edge cases (block-within-inline splits, nextBidi, etc.)
 
 // XXX We really need to make :first-letter happen during frame
 // construction.
 
 // Needed for text frames in XUL.
-/* virtual */ nscoord nsTextFrame::GetMinISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsTextFrame::GetMinISize(gfxContext* aRenderingContext) {
   return nsLayoutUtils::MinISizeFromInline(this, aRenderingContext);
 }
 
 // Needed for text frames in XUL.
-/* virtual */ nscoord nsTextFrame::GetPrefISize(gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsTextFrame::GetPrefISize(gfxContext* aRenderingContext) {
   return nsLayoutUtils::PrefISizeFromInline(this, aRenderingContext);
 }
 
-/* virtual */ void nsContinuingTextFrame::AddInlineMinISize(
-    gfxContext* aRenderingContext, InlineMinISizeData* aData) {
+/* virtual */
+void nsContinuingTextFrame::AddInlineMinISize(gfxContext* aRenderingContext,
+                                              InlineMinISizeData* aData) {
   // Do nothing, since the first-in-flow accounts for everything.
 }
 
-/* virtual */ void nsContinuingTextFrame::AddInlinePrefISize(
-    gfxContext* aRenderingContext, InlinePrefISizeData* aData) {
+/* virtual */
+void nsContinuingTextFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
+                                               InlinePrefISizeData* aData) {
   // Do nothing, since the first-in-flow accounts for everything.
 }
 
 //----------------------------------------------------------------------
 
 #if defined(DEBUG_rbs) || defined(DEBUG_bzbarsky)
 static void VerifyNotDirty(nsFrameState state) {
   bool isZero = state & NS_FRAME_FIRST_REFLOW;
@@ -8416,18 +8423,19 @@ void nsTextFrame::AddInlineMinISizeForFl
 }
 
 bool nsTextFrame::IsCurrentFontInflation(float aInflation) const {
   return fabsf(aInflation - GetFontSizeInflation()) < 1e-6;
 }
 
 // XXX Need to do something here to avoid incremental reflow bugs due to
 // first-line and first-letter changing min-width
-/* virtual */ void nsTextFrame::AddInlineMinISize(
-    gfxContext* aRenderingContext, nsIFrame::InlineMinISizeData* aData) {
+/* virtual */
+void nsTextFrame::AddInlineMinISize(gfxContext* aRenderingContext,
+                                    nsIFrame::InlineMinISizeData* aData) {
   float inflation = nsLayoutUtils::FontSizeInflationFor(this);
   TextRunType trtype = (inflation == 1.0f) ? eNotInflated : eInflated;
 
   if (trtype == eInflated && !IsCurrentFontInflation(inflation)) {
     // FIXME: Ideally, if we already have a text run, we'd move it to be
     // the uninflated text run.
     ClearTextRun(nullptr, nsTextFrame::eInflated);
     mFontMetrics = nullptr;
@@ -8566,18 +8574,19 @@ void nsTextFrame::AddInlinePrefISizeForF
     aData->mSkipWhitespace = IsTrimmableSpace(
         provider.GetFragment(),
         iter.ConvertSkippedToOriginal(flowEndInTextRun - 1), textStyle);
   }
 }
 
 // XXX Need to do something here to avoid incremental reflow bugs due to
 // first-line and first-letter changing pref-width
-/* virtual */ void nsTextFrame::AddInlinePrefISize(
-    gfxContext* aRenderingContext, nsIFrame::InlinePrefISizeData* aData) {
+/* virtual */
+void nsTextFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
+                                     nsIFrame::InlinePrefISizeData* aData) {
   float inflation = nsLayoutUtils::FontSizeInflationFor(this);
   TextRunType trtype = (inflation == 1.0f) ? eNotInflated : eInflated;
 
   if (trtype == eInflated && !IsCurrentFontInflation(inflation)) {
     // FIXME: Ideally, if we already have a text run, we'd move it to be
     // the uninflated text run.
     ClearTextRun(nullptr, nsTextFrame::eInflated);
     mFontMetrics = nullptr;
@@ -8657,18 +8666,19 @@ nsRect nsTextFrame::ComputeTightBounds(D
   if (mTextRun->IsVertical()) {
     // Swap line-relative textMetrics dimensions to physical coordinates.
     Swap(boundingBox.x, boundingBox.y);
     Swap(boundingBox.width, boundingBox.height);
   }
   return boundingBox;
 }
 
-/* virtual */ nsresult nsTextFrame::GetPrefWidthTightBounds(
-    gfxContext* aContext, nscoord* aX, nscoord* aXMost) {
+/* virtual */
+nsresult nsTextFrame::GetPrefWidthTightBounds(gfxContext* aContext, nscoord* aX,
+                                              nscoord* aXMost) {
   gfxSkipCharsIterator iter =
       const_cast<nsTextFrame*>(this)->EnsureTextRun(nsTextFrame::eInflated);
   if (!mTextRun) return NS_ERROR_FAILURE;
 
   PropertyProvider provider(const_cast<nsTextFrame*>(this), iter,
                             nsTextFrame::eInflated, mFontMetrics);
   provider.InitializeForMeasure();
 
@@ -9541,17 +9551,18 @@ void nsTextFrame::ReflowText(nsLineLayou
 
 #ifdef NOISY_REFLOW
   ListTag(stdout);
   printf(": desiredSize=%d,%d(b=%d) status=%x\n", aMetrics.Width(),
          aMetrics.Height(), aMetrics.BlockStartAscent(), aStatus);
 #endif
 }
 
-/* virtual */ bool nsTextFrame::CanContinueTextRun() const {
+/* virtual */
+bool nsTextFrame::CanContinueTextRun() const {
   // We can continue a text run through a text frame
   return true;
 }
 
 nsTextFrame::TrimOutput nsTextFrame::TrimTrailingWhiteSpace(
     DrawTarget* aDrawTarget) {
   MOZ_ASSERT(!HasAnyStateBits(NS_FRAME_IS_DIRTY | NS_FRAME_FIRST_REFLOW),
              "frame should have been reflowed");
@@ -9893,17 +9904,18 @@ nsIFrame::RenderedText nsTextFrame::GetR
 
   if (!haveOffsets) {
     result.mOffsetWithinNodeText = textFrag->GetLength();
     result.mOffsetWithinNodeRenderedText = offsetInRenderedString;
   }
   return result;
 }
 
-/* virtual */ bool nsTextFrame::IsEmpty() {
+/* virtual */
+bool nsTextFrame::IsEmpty() {
   NS_ASSERTION(!(mState & TEXT_IS_ONLY_WHITESPACE) ||
                    !(mState & TEXT_ISNOT_ONLY_WHITESPACE),
                "Invalid state");
 
   // XXXldb Should this check compatibility mode as well???
   const nsStyleText* textStyle = StyleText();
   if (textStyle->WhiteSpaceIsSignificant()) {
     // XXX shouldn't we return true if the length is zero?
--- a/layout/generic/nsTextFrameUtils.cpp
+++ b/layout/generic/nsTextFrameUtils.cpp
@@ -39,18 +39,18 @@ static bool IsSegmentBreak(char16_t aCh)
 
 static bool IsSpaceOrTab(char16_t aCh) { return aCh == ' ' || aCh == '\t'; }
 
 static bool IsSpaceOrTabOrSegmentBreak(char16_t aCh) {
   return IsSpaceOrTab(aCh) || IsSegmentBreak(aCh);
 }
 
 template <typename CharT>
-/* static */ bool nsTextFrameUtils::IsSkippableCharacterForTransformText(
-    CharT aChar) {
+/* static */
+bool nsTextFrameUtils::IsSkippableCharacterForTransformText(CharT aChar) {
   return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == CH_SHY ||
          (aChar > 0xFF && IsBidiControl(aChar));
 }
 
 #ifdef DEBUG
 template <typename CharT>
 static void AssertSkippedExpectedChars(const CharT* aText,
                                        const gfxSkipChars& aSkipChars,
--- a/layout/inspector/InspectorUtils.cpp
+++ b/layout/inspector/InspectorUtils.cpp
@@ -48,19 +48,20 @@
 
 using namespace mozilla;
 using namespace mozilla::css;
 using namespace mozilla::dom;
 
 namespace mozilla {
 namespace dom {
 
-/* static */ void InspectorUtils::GetAllStyleSheets(
-    GlobalObject& aGlobalObject, Document& aDocument, bool aDocumentOnly,
-    nsTArray<RefPtr<StyleSheet>>& aResult) {
+/* static */
+void InspectorUtils::GetAllStyleSheets(GlobalObject& aGlobalObject,
+                                       Document& aDocument, bool aDocumentOnly,
+                                       nsTArray<RefPtr<StyleSheet>>& aResult) {
   // Get the agent, then user and finally xbl sheets in the style set.
   nsIPresShell* presShell = aDocument.GetShell();
 
   if (presShell) {
     ServoStyleSet* styleSet = presShell->StyleSet();
 
     if (!aDocumentOnly) {
       SheetType sheetType = SheetType::Agent;
@@ -104,18 +105,19 @@ bool InspectorUtils::IsIgnorableWhitespa
   if (nsIFrame* frame = aDataNode.GetPrimaryFrame()) {
     return !frame->StyleText()->WhiteSpaceIsSignificant();
   }
 
   // empty inter-tag text node without frame, e.g., in between <table>\n<tr>
   return true;
 }
 
-/* static */ nsINode* InspectorUtils::GetParentForNode(
-    nsINode& aNode, bool aShowingAnonymousContent) {
+/* static */
+nsINode* InspectorUtils::GetParentForNode(nsINode& aNode,
+                                          bool aShowingAnonymousContent) {
   // First do the special cases -- document nodes and anonymous content
   nsINode* parent = nullptr;
 
   if (aNode.IsDocument()) {
     parent = inLayoutUtils::GetContainerFor(*aNode.AsDocument());
   } else if (aShowingAnonymousContent) {
     if (aNode.IsContent()) {
       parent = aNode.AsContent()->GetFlattenedTreeParent();
@@ -125,34 +127,36 @@ bool InspectorUtils::IsIgnorableWhitespa
   if (!parent) {
     // Ok, just get the normal DOM parent node
     return aNode.GetParentNode();
   }
 
   return parent;
 }
 
-/* static */ already_AddRefed<nsINodeList> InspectorUtils::GetChildrenForNode(
+/* static */
+already_AddRefed<nsINodeList> InspectorUtils::GetChildrenForNode(
     nsINode& aNode, bool aShowingAnonymousContent) {
   nsCOMPtr<nsINodeList> kids;
 
   if (aShowingAnonymousContent) {
     if (aNode.IsContent()) {
       kids = aNode.AsContent()->GetChildren(nsIContent::eAllChildren);
     }
   }
 
   if (!kids) {
     kids = aNode.ChildNodes();
   }
 
   return kids.forget();
 }
 
-/* static */ void InspectorUtils::GetCSSStyleRules(
+/* static */
+void InspectorUtils::GetCSSStyleRules(
     GlobalObject& aGlobalObject, Element& aElement, const nsAString& aPseudo,
     nsTArray<RefPtr<BindingStyleRule>>& aResult) {
   RefPtr<nsAtom> pseudoElt;
   if (!aPseudo.IsEmpty()) {
     pseudoElt = NS_Atomize(aPseudo);
   }
 
   RefPtr<ComputedStyle> computedStyle =
@@ -231,28 +235,30 @@ bool InspectorUtils::IsIgnorableWhitespa
       Servo_StyleRule_Debug(rawRule, &str);
       MOZ_CRASH_UNSAFE_PRINTF(
           "We should be able to map a raw rule to a rule: %s\n", str.get());
 #endif
     }
   }
 }
 
-/* static */ uint32_t InspectorUtils::GetRuleLine(GlobalObject& aGlobal,
-                                                  css::Rule& aRule) {
+/* static */
+uint32_t InspectorUtils::GetRuleLine(GlobalObject& aGlobal, css::Rule& aRule) {
   return aRule.GetLineNumber();
 }
 
-/* static */ uint32_t InspectorUtils::GetRuleColumn(GlobalObject& aGlobal,
-                                                    css::Rule& aRule) {
+/* static */
+uint32_t InspectorUtils::GetRuleColumn(GlobalObject& aGlobal,
+                                       css::Rule& aRule) {
   return aRule.GetColumnNumber();
 }
 
-/* static */ uint32_t InspectorUtils::GetRelativeRuleLine(GlobalObject& aGlobal,
-                                                          css::Rule& aRule) {
+/* static */
+uint32_t InspectorUtils::GetRelativeRuleLine(GlobalObject& aGlobal,
+                                             css::Rule& aRule) {
   uint32_t lineNumber = aRule.GetLineNumber();
 
   // If aRule was parsed along with its stylesheet, then it will
   // have an absolute lineNumber that we need to remap to its
   // containing node. But if aRule was added via CSSOM after parsing,
   // then it has a sort-of relative line number already:
   // Gecko gives all rules a 0 lineNumber.
   // Servo gives the first line of a rule a 0 lineNumber, and then
@@ -288,61 +294,67 @@ bool InspectorUtils::IsIgnorableWhitespa
         }
       }
     }
   }
 
   return lineNumber;
 }
 
-/* static */ bool InspectorUtils::HasRulesModifiedByCSSOM(GlobalObject& aGlobal,
-                                                          StyleSheet& aSheet) {
+/* static */
+bool InspectorUtils::HasRulesModifiedByCSSOM(GlobalObject& aGlobal,
+                                             StyleSheet& aSheet) {
   return aSheet.HasModifiedRules();
 }
 
-/* static */ uint32_t InspectorUtils::GetSelectorCount(
-    GlobalObject& aGlobal, BindingStyleRule& aRule) {
+/* static */
+uint32_t InspectorUtils::GetSelectorCount(GlobalObject& aGlobal,
+                                          BindingStyleRule& aRule) {
   return aRule.GetSelectorCount();
 }
 
-/* static */ void InspectorUtils::GetSelectorText(GlobalObject& aGlobal,
-                                                  BindingStyleRule& aRule,
-                                                  uint32_t aSelectorIndex,
-                                                  nsString& aText,
-                                                  ErrorResult& aRv) {
+/* static */
+void InspectorUtils::GetSelectorText(GlobalObject& aGlobal,
+                                     BindingStyleRule& aRule,
+                                     uint32_t aSelectorIndex, nsString& aText,
+                                     ErrorResult& aRv) {
   aRv = aRule.GetSelectorText(aSelectorIndex, aText);
 }
 
-/* static */ uint64_t InspectorUtils::GetSpecificity(GlobalObject& aGlobal,
-                                                     BindingStyleRule& aRule,
-                                                     uint32_t aSelectorIndex,
-                                                     ErrorResult& aRv) {
+/* static */
+uint64_t InspectorUtils::GetSpecificity(GlobalObject& aGlobal,
+                                        BindingStyleRule& aRule,
+                                        uint32_t aSelectorIndex,
+                                        ErrorResult& aRv) {
   uint64_t s;
   aRv = aRule.GetSpecificity(aSelectorIndex, &s);
   return s;
 }
 
-/* static */ bool InspectorUtils::SelectorMatchesElement(
+/* static */
+bool InspectorUtils::SelectorMatchesElement(
     GlobalObject& aGlobalObject, Element& aElement, BindingStyleRule& aRule,
     uint32_t aSelectorIndex, const nsAString& aPseudo, ErrorResult& aRv) {
   bool result = false;
   aRv =
       aRule.SelectorMatchesElement(&aElement, aSelectorIndex, aPseudo, &result);
   return result;
 }
 
-/* static */ bool InspectorUtils::IsInheritedProperty(
-    GlobalObject& aGlobalObject, const nsAString& aPropertyName) {
+/* static */
+bool InspectorUtils::IsInheritedProperty(GlobalObject& aGlobalObject,
+                                         const nsAString& aPropertyName) {
   NS_ConvertUTF16toUTF8 propName(aPropertyName);
   return Servo_Property_IsInherited(&propName);
 }
 
-/* static */ void InspectorUtils::GetCSSPropertyNames(
-    GlobalObject& aGlobalObject, const PropertyNamesOptions& aOptions,
-    nsTArray<nsString>& aResult) {
+/* static */
+void InspectorUtils::GetCSSPropertyNames(GlobalObject& aGlobalObject,
+                                         const PropertyNamesOptions& aOptions,
+                                         nsTArray<nsString>& aResult) {
   CSSEnabledState enabledState = aOptions.mIncludeExperimentals
                                      ? CSSEnabledState::eIgnoreEnabledState
                                      : CSSEnabledState::eForAllContent;
 
   auto appendProperty = [enabledState, &aResult](uint32_t prop) {
     nsCSSPropertyID cssProp = nsCSSPropertyID(prop);
     if (nsCSSProps::IsEnabled(cssProp, enabledState)) {
       aResult.AppendElement(
@@ -367,30 +379,33 @@ bool InspectorUtils::IsIgnorableWhitespa
   if (aOptions.mIncludeAliases) {
     for (prop = eCSSProperty_COUNT; prop < eCSSProperty_COUNT_with_aliases;
          ++prop) {
       appendProperty(prop);
     }
   }
 }
 
-/* static */ void InspectorUtils::GetCSSPropertyPrefs(
-    GlobalObject& aGlobalObject, nsTArray<PropertyPref>& aResult) {
+/* static */
+void InspectorUtils::GetCSSPropertyPrefs(GlobalObject& aGlobalObject,
+                                         nsTArray<PropertyPref>& aResult) {
   for (const auto* src = nsCSSProps::kPropertyPrefTable;
        src->mPropID != eCSSProperty_UNKNOWN; src++) {
     PropertyPref& dest = *aResult.AppendElement();
     dest.mName.Assign(
         NS_ConvertASCIItoUTF16(nsCSSProps::GetStringValue(src->mPropID)));
     dest.mPref.AssignASCII(src->mPref);
   }
 }
 
-/* static */ void InspectorUtils::GetSubpropertiesForCSSProperty(
-    GlobalObject& aGlobal, const nsAString& aProperty,
-    nsTArray<nsString>& aResult, ErrorResult& aRv) {
+/* static */
+void InspectorUtils::GetSubpropertiesForCSSProperty(GlobalObject& aGlobal,
+                                                    const nsAString& aProperty,
+                                                    nsTArray<nsString>& aResult,
+                                                    ErrorResult& aRv) {
   nsCSSPropertyID propertyID = nsCSSProps::LookupProperty(aProperty);
 
   if (propertyID == eCSSProperty_UNKNOWN) {
     aRv.Throw(NS_ERROR_FAILURE);
     return;
   }
 
   if (propertyID == eCSSPropertyExtra_variable) {
@@ -407,18 +422,20 @@ bool InspectorUtils::IsIgnorableWhitespa
   for (const nsCSSPropertyID* props =
            nsCSSProps::SubpropertyEntryFor(propertyID);
        *props != eCSSProperty_UNKNOWN; ++props) {
     nsString* name = aResult.AppendElement();
     CopyASCIItoUTF16(nsCSSProps::GetStringValue(*props), *name);
   }
 }
 
-/* static */ bool InspectorUtils::CssPropertyIsShorthand(
-    GlobalObject& aGlobalObject, const nsAString& aProperty, ErrorResult& aRv) {
+/* static */
+bool InspectorUtils::CssPropertyIsShorthand(GlobalObject& aGlobalObject,
+                                            const nsAString& aProperty,
+                                            ErrorResult& aRv) {
   NS_ConvertUTF16toUTF8 prop(aProperty);
   bool found;
   bool isShorthand = Servo_Property_IsShorthand(&prop, &found);
   if (!found) {
     aRv.Throw(NS_ERROR_FAILURE);
   }
   return isShorthand;
 }
@@ -431,63 +448,66 @@ bool InspectorUtils::CssPropertySupports
   bool result = Servo_Property_SupportsType(&property, aType, &found);
   if (!found) {
     aRv.Throw(NS_ERROR_FAILURE);
     return false;
   }
   return result;
 }
 
-/* static */ void InspectorUtils::GetCSSValuesForProperty(
-    GlobalObject& aGlobalObject, const nsAString& aProperty,
-    nsTArray<nsString>& aResult, ErrorResult& aRv) {
+/* static */
+void InspectorUtils::GetCSSValuesForProperty(GlobalObject& aGlobalObject,
+                                             const nsAString& aProperty,
+                                             nsTArray<nsString>& aResult,
+                                             ErrorResult& aRv) {
   NS_ConvertUTF16toUTF8 property(aProperty);
   bool found;
   Servo_Property_GetCSSValuesForProperty(&property, &found, &aResult);
   if (!found) {
     aRv.Throw(NS_ERROR_FAILURE);
   }
   return;
 }
 
-/* static */ void InspectorUtils::RgbToColorName(GlobalObject& aGlobalObject,
-                                                 uint8_t aR, uint8_t aG,
-                                                 uint8_t aB,
-                                                 nsAString& aColorName,
-                                                 ErrorResult& aRv) {
+/* static */
+void InspectorUtils::RgbToColorName(GlobalObject& aGlobalObject, uint8_t aR,
+                                    uint8_t aG, uint8_t aB,
+                                    nsAString& aColorName, ErrorResult& aRv) {
   const char* color = NS_RGBToColorName(NS_RGB(aR, aG, aB));
   if (!color) {
     aColorName.Truncate();
     aRv.Throw(NS_ERROR_INVALID_ARG);
     return;
   }
 
   aColorName.AssignASCII(color);
 }
 
-/* static */ void InspectorUtils::ColorToRGBA(
-    GlobalObject& aGlobalObject, const nsAString& aColorString,
-    Nullable<InspectorRGBATuple>& aResult) {
+/* static */
+void InspectorUtils::ColorToRGBA(GlobalObject& aGlobalObject,
+                                 const nsAString& aColorString,
+                                 Nullable<InspectorRGBATuple>& aResult) {
   nscolor color = NS_RGB(0, 0, 0);
 
   if (!ServoCSSParser::ComputeColor(nullptr, NS_RGB(0, 0, 0), aColorString,
                                     &color)) {
     aResult.SetNull();
     return;
   }
 
   InspectorRGBATuple& tuple = aResult.SetValue();
   tuple.mR = NS_GET_R(color);
   tuple.mG = NS_GET_G(color);
   tuple.mB = NS_GET_B(color);
   tuple.mA = nsStyleUtil::ColorComponentToFloat(NS_GET_A(color));
 }
 
-/* static */ bool InspectorUtils::IsValidCSSColor(
-    GlobalObject& aGlobalObject, const nsAString& aColorString) {
+/* static */
+bool InspectorUtils::IsValidCSSColor(GlobalObject& aGlobalObject,
+                                     const nsAString& aColorString) {
   return ServoCSSParser::IsValidCSSColor(aColorString);
 }
 
 void InspectorUtils::GetBindingURLs(GlobalObject& aGlobalObject,
                                     Element& aElement,
                                     nsTArray<nsString>& aResult) {
   nsXBLBinding* binding = aElement.GetXBLBinding();
 
@@ -496,33 +516,35 @@ void InspectorUtils::GetBindingURLs(Glob
     nsCOMPtr<nsIURI> bindingURI = binding->PrototypeBinding()->BindingURI();
     bindingURI->GetSpec(spec);
     nsString* resultURI = aResult.AppendElement();
     CopyASCIItoUTF16(spec, *resultURI);
     binding = binding->GetBaseBinding();
   }
 }
 
-/* static */ bool InspectorUtils::SetContentState(GlobalObject& aGlobalObject,
-                                                  Element& aElement,
-                                                  uint64_t aState,
-                                                  ErrorResult& aRv) {
+/* static */
+bool InspectorUtils::SetContentState(GlobalObject& aGlobalObject,
+                                     Element& aElement, uint64_t aState,
+                                     ErrorResult& aRv) {
   RefPtr<EventStateManager> esm =
       inLayoutUtils::GetEventStateManagerFor(aElement);
   if (!esm) {
     aRv.Throw(NS_ERROR_INVALID_ARG);
     return false;
   }
 
   return esm->SetContentState(&aElement, EventStates(aState));
 }
 
-/* static */ bool InspectorUtils::RemoveContentState(
-    GlobalObject& aGlobalObject, Element& aElement, uint64_t aState,
-    bool aClearActiveDocument, ErrorResult& aRv) {
+/* static */
+bool InspectorUtils::RemoveContentState(GlobalObject& aGlobalObject,
+                                        Element& aElement, uint64_t aState,
+                                        bool aClearActiveDocument,
+                                        ErrorResult& aRv) {
   RefPtr<EventStateManager> esm =
       inLayoutUtils::GetEventStateManagerFor(aElement);
   if (!esm) {
     aRv.Throw(NS_ERROR_INVALID_ARG);
     return false;
   }
 
   bool result = esm->SetContentState(nullptr, EventStates(aState));
@@ -533,26 +555,27 @@ void InspectorUtils::GetBindingURLs(Glob
     if (activeESM == esm) {
       EventStateManager::ClearGlobalActiveContent(nullptr);
     }
   }
 
   return result;
 }
 
-/* static */ uint64_t InspectorUtils::GetContentState(
-    GlobalObject& aGlobalObject, Element& aElement) {
+/* static */
+uint64_t InspectorUtils::GetContentState(GlobalObject& aGlobalObject,
+                                         Element& aElement) {
   // NOTE: if this method is removed,
   // please remove GetInternalValue from EventStates
   return aElement.State().GetInternalValue();
 }
 
-/* static */ already_AddRefed<ComputedStyle>
-InspectorUtils::GetCleanComputedStyleForElement(dom::Element* aElement,
-                                                nsAtom* aPseudo) {
+/* static */
+already_AddRefed<ComputedStyle> InspectorUtils::GetCleanComputedStyleForElement(
+    dom::Element* aElement, nsAtom* aPseudo) {
   MOZ_ASSERT(aElement);
 
   Document* doc = aElement->GetComposedDoc();
   if (!doc) {
     return nullptr;
   }
 
   nsIPresShell* presShell = doc->GetShell();
@@ -565,17 +588,18 @@ InspectorUtils::GetCleanComputedStyleFor
     return nullptr;
   }
 
   presContext->EnsureSafeToHandOutCSSRules();
 
   return nsComputedDOMStyle::GetComputedStyle(aElement, aPseudo);
 }
 
-/* static */ void InspectorUtils::GetUsedFontFaces(
+/* static */
+void InspectorUtils::GetUsedFontFaces(
     GlobalObject& aGlobalObject, nsRange& aRange, uint32_t aMaxRanges,
     bool aSkipCollapsedWhitespace,
     nsTArray<nsAutoPtr<InspectorFontFace>>& aResult, ErrorResult& aRv) {
   nsresult rv =
       aRange.GetUsedFontFaces(aResult, aMaxRanges, aSkipCollapsedWhitespace);
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
   }
@@ -584,71 +608,79 @@ InspectorUtils::GetCleanComputedStyleFor
 static EventStates GetStatesForPseudoClass(const nsAString& aStatePseudo) {
   if (aStatePseudo.IsEmpty() || aStatePseudo[0] != u':') {
     return EventStates();
   }
   NS_ConvertUTF16toUTF8 statePseudo(Substring(aStatePseudo, 1));
   return EventStates(Servo_PseudoClass_GetStates(&statePseudo));
 }
 
-/* static */ void InspectorUtils::GetCSSPseudoElementNames(
-    GlobalObject& aGlobalObject, nsTArray<nsString>& aResult) {
+/* static */
+void InspectorUtils::GetCSSPseudoElementNames(GlobalObject& aGlobalObject,
+                                              nsTArray<nsString>& aResult) {
   const auto kPseudoCount =
       static_cast<size_t>(PseudoStyleType::CSSPseudoElementsEnd);
   for (size_t i = 0; i < kPseudoCount; ++i) {
     PseudoStyleType type = static_cast<PseudoStyleType>(i);
     if (nsCSSPseudoElements::IsEnabled(type, CSSEnabledState::eForAllContent)) {
       nsAtom* atom = nsCSSPseudoElements::GetPseudoAtom(type);
       aResult.AppendElement(nsDependentAtomString(atom));
     }
   }
 }
 
-/* static */ void InspectorUtils::AddPseudoClassLock(
-    GlobalObject& aGlobalObject, Element& aElement,
-    const nsAString& aPseudoClass, bool aEnabled) {
+/* static */
+void InspectorUtils::AddPseudoClassLock(GlobalObject& aGlobalObject,
+                                        Element& aElement,
+                                        const nsAString& aPseudoClass,
+                                        bool aEnabled) {
   EventStates state = GetStatesForPseudoClass(aPseudoClass);
   if (state.IsEmpty()) {
     return;
   }
 
   aElement.LockStyleStates(state, aEnabled);
 }
 
-/* static */ void InspectorUtils::RemovePseudoClassLock(
-    GlobalObject& aGlobal, Element& aElement, const nsAString& aPseudoClass) {
+/* static */
+void InspectorUtils::RemovePseudoClassLock(GlobalObject& aGlobal,
+                                           Element& aElement,
+                                           const nsAString& aPseudoClass) {
   EventStates state = GetStatesForPseudoClass(aPseudoClass);
   if (state.IsEmpty()) {
     return;
   }
 
   aElement.UnlockStyleStates(state);
 }
 
-/* static */ bool InspectorUtils::HasPseudoClassLock(
-    GlobalObject& aGlobalObject, Element& aElement,
-    const nsAString& aPseudoClass) {
+/* static */
+bool InspectorUtils::HasPseudoClassLock(GlobalObject& aGlobalObject,
+                                        Element& aElement,
+                                        const nsAString& aPseudoClass) {
   EventStates state = GetStatesForPseudoClass(aPseudoClass);
   if (state.IsEmpty()) {
     return false;
   }
 
   EventStates locks = aElement.LockedStyleStates().mLocks;
   return locks.HasAllStates(state);
 }
 
-/* static */ void InspectorUtils::ClearPseudoClassLocks(
-    GlobalObject& aGlobalObject, Element& aElement) {
+/* static */
+void InspectorUtils::ClearPseudoClassLocks(GlobalObject& aGlobalObject,
+                                           Element& aElement) {
   aElement.ClearStyleStateLocks();
 }
 
-/* static */ void InspectorUtils::ParseStyleSheet(GlobalObject& aGlobalObject,
-                                                  StyleSheet& aSheet,
-                                                  const nsAString& aInput,
-                                                  ErrorResult& aRv) {
+/* static */
+void InspectorUtils::ParseStyleSheet(GlobalObject& aGlobalObject,
+                                     StyleSheet& aSheet,
+                                     const nsAString& aInput,
+                                     ErrorResult& aRv) {
   aRv = aSheet.ReparseSheet(aInput);
 }
 
 void InspectorUtils::ScrollElementIntoView(GlobalObject& aGlobalObject,
                                            Element& aElement) {
   nsIPresShell* presShell = aElement.OwnerDoc()->GetShell();
   if (!presShell) {
     return;
--- a/layout/ipc/VsyncParent.cpp
+++ b/layout/ipc/VsyncParent.cpp
@@ -15,17 +15,18 @@
 #include "VsyncSource.h"
 
 namespace mozilla {
 
 using namespace ipc;
 
 namespace layout {
 
-/*static*/ already_AddRefed<VsyncParent> VsyncParent::Create() {
+/*static*/
+already_AddRefed<VsyncParent> VsyncParent::Create() {
   AssertIsOnBackgroundThread();
   RefPtr<gfx::VsyncSource> vsyncSource =
       gfxPlatform::GetPlatform()->GetHardwareVsync();
   RefPtr<VsyncParent> vsyncParent = new VsyncParent();
   vsyncParent->mVsyncDispatcher = vsyncSource->GetRefreshTimerVsyncDispatcher();
   return vsyncParent.forget();
 }
 
--- a/layout/mathml/nsMathMLContainerFrame.cpp
+++ b/layout/mathml/nsMathMLContainerFrame.cpp
@@ -111,26 +111,28 @@ void nsDisplayMathMLError::Paint(nsDispl
 static bool IsForeignChild(const nsIFrame* aFrame) {
   // This counts nsMathMLmathBlockFrame as a foreign child, because it
   // uses block reflow
   return !(aFrame->IsFrameOfType(nsIFrame::eMathML)) || aFrame->IsBlockFrame();
 }
 
 NS_DECLARE_FRAME_PROPERTY_DELETABLE(HTMLReflowOutputProperty, ReflowOutput)
 
-/* static */ void nsMathMLContainerFrame::SaveReflowAndBoundingMetricsFor(
+/* static */
+void nsMathMLContainerFrame::SaveReflowAndBoundingMetricsFor(
     nsIFrame* aFrame, const ReflowOutput& aReflowOutput,
     const nsBoundingMetrics& aBoundingMetrics) {
   ReflowOutput* reflowOutput = new ReflowOutput(aReflowOutput);
   reflowOutput->mBoundingMetrics = aBoundingMetrics;
   aFrame->SetProperty(HTMLReflowOutputProperty(), reflowOutput);
 }
 
 // helper method to facilitate getting the reflow and bounding metrics
-/* static */ void nsMathMLContainerFrame::GetReflowAndBoundingMetricsFor(
+/* static */
+void nsMathMLContainerFrame::GetReflowAndBoundingMetricsFor(
     nsIFrame* aFrame, ReflowOutput& aReflowOutput,
     nsBoundingMetrics& aBoundingMetrics, eMathMLFrameType* aMathMLFrameType) {
   MOZ_ASSERT(aFrame, "null arg");
 
   ReflowOutput* reflowOutput = aFrame->GetProperty(HTMLReflowOutputProperty());
 
   // IMPORTANT: This function is only meant to be called in Place() methods
   // where it is assumed that SaveReflowAndBoundingMetricsFor has recorded the
@@ -546,17 +548,18 @@ nsresult nsMathMLContainerFrame::Finaliz
  * nsIMathMLFrame - support methods for scripting elements (nested frames
  * within msub, msup, msubsup, munder, mover, munderover, mmultiscripts,
  * mfrac, mroot, mtable).
  * =============================================================================
  */
 
 // helper to let the update of presentation data pass through
 // a subtree that may contain non-mathml container frames
-/* static */ void nsMathMLContainerFrame::PropagatePresentationDataFor(
+/* static */
+void nsMathMLContainerFrame::PropagatePresentationDataFor(
     nsIFrame* aFrame, uint32_t aFlagsValues, uint32_t aFlagsToUpdate) {
   if (!aFrame || !aFlagsToUpdate) return;
   nsIMathMLFrame* mathMLFrame = do_QueryFrame(aFrame);
   if (mathMLFrame) {
     // update
     mathMLFrame->UpdatePresentationData(aFlagsValues, aFlagsToUpdate);
     // propagate using the base method to make sure that the control
     // is passed on to MathML frames that may be overloading the method
@@ -565,17 +568,18 @@ nsresult nsMathMLContainerFrame::Finaliz
   } else {
     // propagate down the subtrees
     for (nsIFrame* childFrame : aFrame->PrincipalChildList()) {
       PropagatePresentationDataFor(childFrame, aFlagsValues, aFlagsToUpdate);
     }
   }
 }
 
-/* static */ void nsMathMLContainerFrame::PropagatePresentationDataFromChildAt(
+/* static */
+void nsMathMLContainerFrame::PropagatePresentationDataFromChildAt(
     nsIFrame* aParentFrame, int32_t aFirstChildIndex, int32_t aLastChildIndex,
     uint32_t aFlagsValues, uint32_t aFlagsToUpdate) {
   if (!aParentFrame || !aFlagsToUpdate) return;
   int32_t index = 0;
   for (nsIFrame* childFrame : aParentFrame->PrincipalChildList()) {
     if ((index >= aFirstChildIndex) &&
         ((aLastChildIndex <= 0) ||
          ((aLastChildIndex > 0) && (index <= aLastChildIndex)))) {
@@ -614,17 +618,18 @@ void nsMathMLContainerFrame::BuildDispla
   // in the Init() of your sub-class
   DisplayBoundingMetrics(aBuilder, this, mReference, mBoundingMetrics, aLists);
 #endif
 }
 
 // Note that this method re-builds the automatic data in the children -- not
 // in aParentFrame itself (except for those particular operations that the
 // parent frame may do in its TransmitAutomaticData()).
-/* static */ void nsMathMLContainerFrame::RebuildAutomaticDataForChildren(
+/* static */
+void nsMathMLContainerFrame::RebuildAutomaticDataForChildren(
     nsIFrame* aParentFrame) {
   // 1. As we descend the tree, make each child frame inherit data from
   // the parent
   // 2. As we ascend the tree, transmit any specific change that we want
   // down the subtrees
   for (nsIFrame* childFrame : aParentFrame->PrincipalChildList()) {
     nsIMathMLFrame* childMathMLFrame = do_QueryFrame(childFrame);
     if (childMathMLFrame) {
@@ -633,18 +638,18 @@ void nsMathMLContainerFrame::BuildDispla
     RebuildAutomaticDataForChildren(childFrame);
   }
   nsIMathMLFrame* mathMLFrame = do_QueryFrame(aParentFrame);
   if (mathMLFrame) {
     mathMLFrame->TransmitAutomaticData();
   }
 }
 
-/* static */ nsresult nsMathMLContainerFrame::ReLayoutChildren(
-    nsIFrame* aParentFrame) {
+/* static */
+nsresult nsMathMLContainerFrame::ReLayoutChildren(nsIFrame* aParentFrame) {
   if (!aParentFrame) return NS_OK;
 
   // walk-up to the first frame that is a MathML frame, stop if we reach <math>
   nsIFrame* frame = aParentFrame;
   while (1) {
     nsIFrame* parent = frame->GetParent();
     if (!parent || !parent->GetContent()) break;
 
@@ -900,17 +905,18 @@ void nsMathMLContainerFrame::Reflow(nsPr
   FinalizeReflow(drawTarget, aDesiredSize);
 
   NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
 }
 
 static nscoord AddInterFrameSpacingToSize(ReflowOutput& aDesiredSize,
                                           nsMathMLContainerFrame* aFrame);
 
-/* virtual */ void nsMathMLContainerFrame::MarkIntrinsicISizesDirty() {
+/* virtual */
+void nsMathMLContainerFrame::MarkIntrinsicISizesDirty() {
   mIntrinsicWidth = NS_INTRINSIC_WIDTH_UNKNOWN;
   nsContainerFrame::MarkIntrinsicISizesDirty();
 }
 
 void nsMathMLContainerFrame::UpdateIntrinsicWidth(
     gfxContext* aRenderingContext) {
   if (mIntrinsicWidth == NS_INTRINSIC_WIDTH_UNKNOWN) {
     ReflowOutput desiredSize(GetWritingMode());
@@ -918,35 +924,36 @@ void nsMathMLContainerFrame::UpdateIntri
 
     // Include the additional width added by FixInterFrameSpacing to ensure
     // consistent width calculations.
     AddInterFrameSpacingToSize(desiredSize, this);
     mIntrinsicWidth = desiredSize.ISize(GetWritingMode());
   }
 }
 
-/* virtual */ nscoord nsMathMLContainerFrame::GetMinISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsMathMLContainerFrame::GetMinISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_MIN_INLINE_SIZE(this, result);
   UpdateIntrinsicWidth(aRenderingContext);
   result = mIntrinsicWidth;
   return result;
 }
 
-/* virtual */ nscoord nsMathMLContainerFrame::GetPrefISize(
-    gfxContext* aRenderingContext) {
+/* virtual */
+nscoord nsMathMLContainerFrame::GetPrefISize(gfxContext* aRenderingContext) {
   nscoord result;
   DISPLAY_PREF_INLINE_SIZE(this, result);
   UpdateIntrinsicWidth(aRenderingContext);
   result = mIntrinsicWidth;
   return result;
 }
 
-/* virtual */ void nsMathMLContainerFrame::GetIntrinsicISizeMetrics(
+/* virtual */
+void nsMathMLContainerFrame::GetIntrinsicISizeMetrics(
     gfxContext* aRenderingContext, ReflowOutput& aDesiredSize) {
   // Get child widths
   nsIFrame* childFrame = mFrames.FirstChild();
   while (childFrame) {
     ReflowOutput childDesiredSize(GetWritingMode());  // ???
 
     nsMathMLContainerFrame* containerFrame = do_QueryFrame(childFrame);
     if (containerFrame) {
@@ -983,18 +990,19 @@ void nsMathMLContainerFrame::UpdateIntri
       MeasureForWidth(aRenderingContext->GetDrawTarget(), aDesiredSize);
   if (NS_FAILED(rv)) {
     ReflowError(aRenderingContext->GetDrawTarget(), aDesiredSize);
   }
 
   ClearSavedChildMetrics();
 }
 
-/* virtual */ nsresult nsMathMLContainerFrame::MeasureForWidth(
-    DrawTarget* aDrawTarget, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLContainerFrame::MeasureForWidth(DrawTarget* aDrawTarget,
+                                                 ReflowOutput& aDesiredSize) {
   return Place(aDrawTarget, false, aDesiredSize);
 }
 
 // see spacing table in Chapter 18, TeXBook (p.170)
 // Our table isn't quite identical to TeX because operators have
 // built-in values for lspace & rspace in the Operator Dictionary.
 static int32_t
     kInterFrameSpacingTable[eMathMLFrameType_COUNT][eMathMLFrameType_COUNT] = {
@@ -1186,18 +1194,20 @@ class nsMathMLContainerFrame::RowChildFr
     }
     // add left correction -- this fixes the problem of the italic 'f'
     // e.g., <mo>q</mo> <mi>f</mi> <mo>I</mo>
     mX += leftCorrection;
     mItalicCorrection = rightCorrection;
   }
 };
 
-/* virtual */ nsresult nsMathMLContainerFrame::Place(
-    DrawTarget* aDrawTarget, bool aPlaceOrigin, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLContainerFrame::Place(DrawTarget* aDrawTarget,
+                                       bool aPlaceOrigin,
+                                       ReflowOutput& aDesiredSize) {
   // This is needed in case this frame is empty (i.e., no child frames)
   mBoundingMetrics = nsBoundingMetrics();
 
   RowChildFrameIterator child(this);
   nscoord ascent = 0, descent = 0;
   while (child.Frame()) {
     if (descent < child.Descent()) descent = child.Descent();
     if (ascent < child.Ascent()) ascent = child.Ascent();
@@ -1315,18 +1325,19 @@ nscoord nsMathMLContainerFrame::FixInter
     while (childFrame) {
       childFrame->SetPosition(childFrame->GetPosition() + nsPoint(gap, 0));
       childFrame = childFrame->GetNextSibling();
     }
   }
   return gap;
 }
 
-/* static */ void nsMathMLContainerFrame::DidReflowChildren(nsIFrame* aFirst,
-                                                            nsIFrame* aStop)
+/* static */
+void nsMathMLContainerFrame::DidReflowChildren(nsIFrame* aFirst,
+                                               nsIFrame* aStop)
 
 {
   if (MOZ_UNLIKELY(!aFirst)) return;
 
   for (nsIFrame* frame = aFirst; frame != aStop;
        frame = frame->GetNextSibling()) {
     NS_ASSERTION(frame, "aStop isn't a sibling");
     if (frame->GetStateBits() & NS_FRAME_IN_REFLOW) {
@@ -1405,18 +1416,19 @@ nsresult nsMathMLContainerFrame::Transmi
   if (childFrame || embellishedOpFound) {
     // The element is not space-like
     mPresentationData.flags &= ~NS_MATHML_SPACE_LIKE;
   }
 
   return NS_OK;
 }
 
-/*static*/ void nsMathMLContainerFrame::PropagateFrameFlagFor(
-    nsIFrame* aFrame, nsFrameState aFlags) {
+/*static*/
+void nsMathMLContainerFrame::PropagateFrameFlagFor(nsIFrame* aFrame,
+                                                   nsFrameState aFlags) {
   if (!aFrame || !aFlags) return;
 
   aFrame->AddStateBits(aFlags);
   for (nsIFrame* childFrame : aFrame->PrincipalChildList()) {
     PropagateFrameFlagFor(childFrame, aFlags);
   }
 }
 
--- a/layout/mathml/nsMathMLFrame.cpp
+++ b/layout/mathml/nsMathMLFrame.cpp
@@ -84,29 +84,32 @@ nsMathMLFrame::UpdatePresentationData(ui
   }
   return NS_OK;
 }
 
 // Helper to give a ComputedStyle suitable for doing the stretching of
 // a MathMLChar. Frame classes that use this should ensure that the
 // extra leaf ComputedStyle given to the MathMLChars are accessible to
 // the Style System via the Get/Set AdditionalComputedStyle() APIs.
-/* static */ void nsMathMLFrame::ResolveMathMLCharStyle(
-    nsPresContext* aPresContext, nsIContent* aContent,
-    ComputedStyle* aParentComputedStyle, nsMathMLChar* aMathMLChar) {
+/* static */
+void nsMathMLFrame::ResolveMathMLCharStyle(nsPresContext* aPresContext,
+                                           nsIContent* aContent,
+                                           ComputedStyle* aParentComputedStyle,
+                                           nsMathMLChar* aMathMLChar) {
   PseudoStyleType pseudoType = PseudoStyleType::mozMathAnonymous;  // savings
   RefPtr<ComputedStyle> newComputedStyle;
   newComputedStyle = aPresContext->StyleSet()->ResolvePseudoElementStyle(
       aContent->AsElement(), pseudoType, aParentComputedStyle, nullptr);
 
   aMathMLChar->SetComputedStyle(newComputedStyle);
 }
 
-/* static */ void nsMathMLFrame::GetEmbellishDataFrom(
-    nsIFrame* aFrame, nsEmbellishData& aEmbellishData) {
+/* static */
+void nsMathMLFrame::GetEmbellishDataFrom(nsIFrame* aFrame,
+                                         nsEmbellishData& aEmbellishData) {
   // initialize OUT params
   aEmbellishData.flags = 0;
   aEmbellishData.coreFrame = nullptr;
   aEmbellishData.direction = NS_STRETCH_DIRECTION_UNSUPPORTED;
   aEmbellishData.leadingSpace = 0;
   aEmbellishData.trailingSpace = 0;
 
   if (aFrame && aFrame->IsFrameOfType(nsIFrame::eMathML)) {
@@ -114,17 +117,18 @@ nsMathMLFrame::UpdatePresentationData(ui
     if (mathMLFrame) {
       mathMLFrame->GetEmbellishData(aEmbellishData);
     }
   }
 }
 
 // helper to get the presentation data of a frame, by possibly walking up
 // the frame hierarchy if we happen to be surrounded by non-MathML frames.
-/* static */ void nsMathMLFrame::GetPresentationDataFrom(
+/* static */
+void nsMathMLFrame::GetPresentationDataFrom(
     nsIFrame* aFrame, nsPresentationData& aPresentationData, bool aClimbTree) {
   // initialize OUT params
   aPresentationData.flags = 0;
   aPresentationData.baseFrame = nullptr;
 
   nsIFrame* frame = aFrame;
   while (frame) {
     if (frame->IsFrameOfType(nsIFrame::eMathML)) {
@@ -149,33 +153,35 @@ nsMathMLFrame::UpdatePresentationData(ui
     }
     frame = frame->GetParent();
   }
   NS_WARNING_ASSERTION(
       frame && frame->GetContent(),
       "bad MathML markup - could not find the top <math> element");
 }
 
-/* static */ void nsMathMLFrame::GetRuleThickness(DrawTarget* aDrawTarget,
-                                                  nsFontMetrics* aFontMetrics,
-                                                  nscoord& aRuleThickness) {
+/* static */
+void nsMathMLFrame::GetRuleThickness(DrawTarget* aDrawTarget,
+                                     nsFontMetrics* aFontMetrics,
+                                     nscoord& aRuleThickness) {
   nscoord xHeight = aFontMetrics->XHeight();
   char16_t overBar = 0x00AF;
   nsBoundingMetrics bm = nsLayoutUtils::AppUnitBoundsOfString(
       &overBar, 1, *aFontMetrics, aDrawTarget);
   aRuleThickness = bm.ascent + bm.descent;
   if (aRuleThickness <= 0 || aRuleThickness >= xHeight) {
     // fall-back to the other version
     GetRuleThickness(aFontMetrics, aRuleThickness);
   }
 }
 
-/* static */ void nsMathMLFrame::GetAxisHeight(DrawTarget* aDrawTarget,
-                                               nsFontMetrics* aFontMetrics,
-                                               nscoord& aAxisHeight) {
+/* static */
+void nsMathMLFrame::GetAxisHeight(DrawTarget* aDrawTarget,
+                                  nsFontMetrics* aFontMetrics,
+                                  nscoord& aAxisHeight) {
   gfxFont* mathFont = aFontMetrics->GetThebesFontGroup()->GetFirstMathFont();
   if (mathFont) {
     aAxisHeight = mathFont->MathTable()->Constant(
         gfxMathTable::AxisHeight, aFontMetrics->AppUnitsPerDevPixel());
     return;
   }
 
   nscoord xHeight = aFontMetrics->XHeight();
@@ -184,20 +190,21 @@ nsMathMLFrame::UpdatePresentationData(ui
       &minus, 1, *aFontMetrics, aDrawTarget);
   aAxisHeight = bm.ascent - (bm.ascent + bm.descent) / 2;
   if (aAxisHeight <= 0 || aAxisHeight >= xHeight) {
     // fall-back to the other version
     GetAxisHeight(aFontMetrics, aAxisHeight);
   }
 }
 
-/* static */ nscoord nsMathMLFrame::CalcLength(nsPresContext* aPresContext,
-                                               ComputedStyle* aComputedStyle,
-                                               const nsCSSValue& aCSSValue,
-                                               float aFontSizeInflation) {
+/* static */
+nscoord nsMathMLFrame::CalcLength(nsPresContext* aPresContext,
+                                  ComputedStyle* aComputedStyle,
+                                  const nsCSSValue& aCSSValue,
+                                  float aFontSizeInflation) {
   NS_ASSERTION(aCSSValue.IsLengthUnit(), "not a length unit");
 
   if (aCSSValue.IsPixelLengthUnit()) {
     return aCSSValue.GetPixelLength();
   }
 
   nsCSSUnit unit = aCSSValue.GetUnit();
 
@@ -212,20 +219,22 @@ nsMathMLFrame::UpdatePresentationData(ui
     return NSToCoordRound(aCSSValue.GetFloatValue() * (float)xHeight);
   }
 
   // MathML doesn't specify other CSS units such as rem or ch
   NS_ERROR("Unsupported unit");
   return 0;
 }
 
-/* static */ void nsMathMLFrame::ParseNumericValue(
-    const nsString& aString, nscoord* aLengthValue, uint32_t aFlags,
-    nsPresContext* aPresContext, ComputedStyle* aComputedStyle,
-    float aFontSizeInflation) {
+/* static */
+void nsMathMLFrame::ParseNumericValue(const nsString& aString,
+                                      nscoord* aLengthValue, uint32_t aFlags,
+                                      nsPresContext* aPresContext,
+                                      ComputedStyle* aComputedStyle,
+                                      float aFontSizeInflation) {
   nsCSSValue cssValue;
 
   if (!nsMathMLElement::ParseNumericValue(aString, cssValue, aFlags,
                                           aPresContext->Document())) {
     // Invalid attribute value. aLengthValue remains unchanged, so the default
     // length value is used.
     return;
   }
--- a/layout/mathml/nsMathMLOperators.cpp
+++ b/layout/mathml/nsMathMLOperators.cpp
@@ -390,29 +390,30 @@ void nsMathMLOperators::LookupOperators(
     if (found) {
       aFlags[NS_MATHML_OPERATOR_FORM_PREFIX] = found->mFlags;
       aLeadingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = found->mLeadingSpace;
       aTrailingSpace[NS_MATHML_OPERATOR_FORM_PREFIX] = found->mTrailingSpace;
     }
   }
 }
 
-/* static */ bool nsMathMLOperators::IsMirrorableOperator(
-    const nsString& aOperator) {
+/* static */
+bool nsMathMLOperators::IsMirrorableOperator(const nsString& aOperator) {
   // LookupOperator will search infix, postfix and prefix forms of aOperator and
   // return the first form found. It is assumed that all these forms have same
   // mirrorability.
   nsOperatorFlags flags = 0;
   float dummy;
   nsMathMLOperators::LookupOperator(aOperator, NS_MATHML_OPERATOR_FORM_INFIX,
                                     &flags, &dummy, &dummy);
   return NS_MATHML_OPERATOR_IS_MIRRORABLE(flags);
 }
 
-/* static */ nsStretchDirection nsMathMLOperators::GetStretchyDirection(
+/* static */
+nsStretchDirection nsMathMLOperators::GetStretchyDirection(
     const nsString& aOperator) {
   // LookupOperator will search infix, postfix and prefix forms of aOperator and
   // return the first form found. It is assumed that all these forms have same
   // direction.
   nsOperatorFlags flags = 0;
   float dummy;
   nsMathMLOperators::LookupOperator(aOperator, NS_MATHML_OPERATOR_FORM_INFIX,
                                     &flags, &dummy, &dummy);
--- a/layout/mathml/nsMathMLSelectedFrame.cpp
+++ b/layout/mathml/nsMathMLSelectedFrame.cpp
@@ -128,18 +128,20 @@ void nsMathMLSelectedFrame::Reflow(nsPre
                                     aDesiredSize.mBoundingMetrics);
     mBoundingMetrics = aDesiredSize.mBoundingMetrics;
   }
   FinalizeReflow(aReflowInput.mRenderingContext->GetDrawTarget(), aDesiredSize);
   NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
 }
 
 // Only place the selected child ...
-/* virtual */ nsresult nsMathMLSelectedFrame::Place(
-    DrawTarget* aDrawTarget, bool aPlaceOrigin, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLSelectedFrame::Place(DrawTarget* aDrawTarget,
+                                      bool aPlaceOrigin,
+                                      ReflowOutput& aDesiredSize) {
   nsIFrame* childFrame = GetSelectedFrame();
 
   if (mInvalidMarkup) {
     return ReflowError(aDrawTarget, aDesiredSize);
   }
 
   aDesiredSize.ClearSize();
   aDesiredSize.SetBlockStartAscent(0);
--- a/layout/mathml/nsMathMLTokenFrame.cpp
+++ b/layout/mathml/nsMathMLTokenFrame.cpp
@@ -138,19 +138,19 @@ void nsMathMLTokenFrame::Reflow(nsPresCo
 
   aStatus.Reset();  // This type of frame can't be split.
   NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
 }
 
 // For token elements, mBoundingMetrics is computed at the ReflowToken
 // pass, it is not computed here because our children may be text frames
 // that do not implement the GetBoundingMetrics() interface.
-/* virtual */ nsresult nsMathMLTokenFrame::Place(DrawTarget* aDrawTarget,
-                                                 bool aPlaceOrigin,
-                                                 ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLTokenFrame::Place(DrawTarget* aDrawTarget, bool aPlaceOrigin,
+                                   ReflowOutput& aDesiredSize) {
   mBoundingMetrics = nsBoundingMetrics();
   for (nsIFrame* childFrame : PrincipalChildList()) {
     ReflowOutput childSize(aDesiredSize.GetWritingMode());
     GetReflowAndBoundingMetricsFor(childFrame, childSize,
                                    childSize.mBoundingMetrics, nullptr);
     // compute and cache the bounding metrics
     mBoundingMetrics += childSize.mBoundingMetrics;
   }
--- a/layout/mathml/nsMathMLmencloseFrame.cpp
+++ b/layout/mathml/nsMathMLmencloseFrame.cpp
@@ -290,29 +290,34 @@ void nsMathMLmencloseFrame::BuildDisplay
 
   if (IsToDraw(NOTATION_VERTICALSTRIKE)) {
     nsRect rect(mencloseRect.width / 2 - mRuleThickness / 2, 0, mRuleThickness,
                 mencloseRect.height);
     DisplayBar(aBuilder, this, rect, aLists, NOTATION_VERTICALSTRIKE);
   }
 }
 
-/* virtual */ nsresult nsMathMLmencloseFrame::MeasureForWidth(
-    DrawTarget* aDrawTarget, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLmencloseFrame::MeasureForWidth(DrawTarget* aDrawTarget,
+                                                ReflowOutput& aDesiredSize) {
   return PlaceInternal(aDrawTarget, false, aDesiredSize, true);
 }
 
-/* virtual */ nsresult nsMathMLmencloseFrame::Place(
-    DrawTarget* aDrawTarget, bool aPlaceOrigin, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLmencloseFrame::Place(DrawTarget* aDrawTarget,
+                                      bool aPlaceOrigin,
+                                      ReflowOutput& aDesiredSize) {
   return PlaceInternal(aDrawTarget, aPlaceOrigin, aDesiredSize, false);
 }
 
-/* virtual */ nsresult nsMathMLmencloseFrame::PlaceInternal(
-    DrawTarget* aDrawTarget, bool aPlaceOrigin, ReflowOutput& aDesiredSize,
-    bool aWidthOnly) {
+/* virtual */
+nsresult nsMathMLmencloseFrame::PlaceInternal(DrawTarget* aDrawTarget,
+                                              bool aPlaceOrigin,
+                                              ReflowOutput& aDesiredSize,
+                                              bool aWidthOnly) {
   ///////////////
   // Measure the size of our content using the base class to format like an
   // inferred mrow.
   ReflowOutput baseSize(aDesiredSize.GetWritingMode());
   nsresult rv = nsMathMLContainerFrame::Place(aDrawTarget, false, baseSize);
 
   if (NS_MATHML_HAS_ERROR(mPresentationData.flags) || NS_FAILED(rv)) {
     DidReflowChildren(PrincipalChildList().FirstChild());
--- a/layout/mathml/nsMathMLmfencedFrame.cpp
+++ b/layout/mathml/nsMathMLmfencedFrame.cpp
@@ -505,20 +505,20 @@ nsresult nsMathMLmfencedFrame::ReflowCha
     // x-origin is used to store lspace ...
     // y-origin is used to stored the ascent ...
     aMathMLChar->SetRect(nsRect(leftSpace, charSize.ascent, charSize.width,
                                 charSize.ascent + charSize.descent));
   }
   return NS_OK;
 }
 
-/*static*/ void nsMathMLmfencedFrame::PlaceChar(nsMathMLChar* aMathMLChar,
-                                                nscoord aDesiredAscent,
-                                                nsBoundingMetrics& bm,
-                                                nscoord& dx) {
+/*static*/
+void nsMathMLmfencedFrame::PlaceChar(nsMathMLChar* aMathMLChar,
+                                     nscoord aDesiredAscent,
+                                     nsBoundingMetrics& bm, nscoord& dx) {
   aMathMLChar->GetBoundingMetrics(bm);
 
   // the char's x-origin was used to store lspace ...
   // the char's y-origin was used to store the ascent ...
   // the char's width was used to store the advance with (with spacing) ...
   nsRect rect;
   aMathMLChar->GetRect(rect);
 
@@ -553,17 +553,18 @@ static nscoord GetMaxCharWidth(nsIFrame*
     GetCharSpacing(aMathMLChar, aForm, aScriptLevel, em, leftSpace, rightSpace);
 
     width += leftSpace + rightSpace;
   }
 
   return width;
 }
 
-/* virtual */ void nsMathMLmfencedFrame::GetIntrinsicISizeMetrics(
+/* virtual */
+void nsMathMLmfencedFrame::GetIntrinsicISizeMetrics(
     gfxContext* aRenderingContext, ReflowOutput& aDesiredSize) {
   nscoord width = 0;
 
   const nsStyleFont* font = StyleFont();
   float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
   RefPtr<nsFontMetrics> fm =
       nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
   nscoord em;
--- a/layout/mathml/nsMathMLmfracFrame.cpp
+++ b/layout/mathml/nsMathMLmfracFrame.cpp
@@ -155,32 +155,33 @@ nsresult nsMathMLmfracFrame::AttributeCh
                                               int32_t aModType) {
   if (nsGkAtoms::linethickness_ == aAttribute) {
     InvalidateFrame();
   }
   return nsMathMLContainerFrame::AttributeChanged(aNameSpaceID, aAttribute,
                                                   aModType);
 }
 
-/* virtual */ nsresult nsMathMLmfracFrame::MeasureForWidth(
-    DrawTarget* aDrawTarget, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLmfracFrame::MeasureForWidth(DrawTarget* aDrawTarget,
+                                             ReflowOutput& aDesiredSize) {
   return PlaceInternal(aDrawTarget, false, aDesiredSize, true);
 }
 
 nscoord nsMathMLmfracFrame::FixInterFrameSpacing(ReflowOutput& aDesiredSize) {
   nscoord gap = nsMathMLContainerFrame::FixInterFrameSpacing(aDesiredSize);
   if (!gap) return 0;
 
   mLineRect.MoveBy(gap, 0);
   return gap;
 }
 
-/* virtual */ nsresult nsMathMLmfracFrame::Place(DrawTarget* aDrawTarget,
-                                                 bool aPlaceOrigin,
-                                                 ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLmfracFrame::Place(DrawTarget* aDrawTarget, bool aPlaceOrigin,
+                                   ReflowOutput& aDesiredSize) {
   return PlaceInternal(aDrawTarget, aPlaceOrigin, aDesiredSize, false);
 }
 
 nsresult nsMathMLmfracFrame::PlaceInternal(DrawTarget* aDrawTarget,
                                            bool aPlaceOrigin,
                                            ReflowOutput& aDesiredSize,
                                            bool aWidthOnly) {
   ////////////////////////////////////
--- a/layout/mathml/nsMathMLmmultiscriptsFrame.cpp
+++ b/layout/mathml/nsMathMLmmultiscriptsFrame.cpp
@@ -79,18 +79,20 @@ nsMathMLmmultiscriptsFrame::TransmitAuto
     childFrame = subScriptFrames[i];
     PropagatePresentationDataFor(childFrame, NS_MATHML_COMPRESSED,
                                  NS_MATHML_COMPRESSED);
   }
 
   return NS_OK;
 }
 
-/* virtual */ nsresult nsMathMLmmultiscriptsFrame::Place(
-    DrawTarget* aDrawTarget, bool aPlaceOrigin, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLmmultiscriptsFrame::Place(DrawTarget* aDrawTarget,
+                                           bool aPlaceOrigin,
+                                           ReflowOutput& aDesiredSize) {
   nscoord subScriptShift = 0;
   nscoord supScriptShift = 0;
   float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
 
   // subscriptshift
   //
   // "Specifies the minimum amount to shift the baseline of subscript down; the
   // default is for the rendering agent to use its own positioning rules."
--- a/layout/mathml/nsMathMLmoFrame.cpp
+++ b/layout/mathml/nsMathMLmoFrame.cpp
@@ -963,17 +963,18 @@ nsresult nsMathMLmoFrame::Place(DrawTarg
         aDesiredSize.BlockStartAscent() +
         std::max(mBoundingMetrics.descent, newMetrics.descent);
     aDesiredSize.Width() = newMetrics.width;
     mBoundingMetrics = newMetrics;
   }
   return NS_OK;
 }
 
-/* virtual */ void nsMathMLmoFrame::MarkIntrinsicISizesDirty() {
+/* virtual */
+void nsMathMLmoFrame::MarkIntrinsicISizesDirty() {
   // if we get this, it may mean that something changed in the text
   // content. So blow away everything an re-build the automatic data
   // from the parent of our outermost embellished container (we ensure
   // that we are the core, not just a sibling of the core)
 
   ProcessTextData();
 
   nsIFrame* target = this;
@@ -986,18 +987,19 @@ nsresult nsMathMLmoFrame::Place(DrawTarg
   // we have automatic data to update in the children of the target frame
   // XXXldb This should really be marking dirty rather than rebuilding
   // so that we don't rebuild multiple times for the same change.
   RebuildAutomaticDataForChildren(target);
 
   nsMathMLContainerFrame::MarkIntrinsicISizesDirty();
 }
 
-/* virtual */ void nsMathMLmoFrame::GetIntrinsicISizeMetrics(
-    gfxContext* aRenderingContext, ReflowOutput& aDesiredSize) {
+/* virtual */
+void nsMathMLmoFrame::GetIntrinsicISizeMetrics(gfxContext* aRenderingContext,
+                                               ReflowOutput& aDesiredSize) {
   ProcessOperatorData();
   if (UseMathMLChar()) {
     uint32_t stretchHint =
         GetStretchHint(mFlags, mPresentationData, true, StyleFont());
     aDesiredSize.Width() = mMathMLChar.GetMaxWidth(
         this, aRenderingContext->GetDrawTarget(),
         nsLayoutUtils::FontSizeInflationFor(this), stretchHint);
   } else {
--- a/layout/mathml/nsMathMLmpaddedFrame.cpp
+++ b/layout/mathml/nsMathMLmpaddedFrame.cpp
@@ -304,19 +304,19 @@ void nsMathMLmpaddedFrame::Reflow(nsPres
 
   ///////////////
   // Let the base class format our content like an inferred mrow
   nsMathMLContainerFrame::Reflow(aPresContext, aDesiredSize, aReflowInput,
                                  aStatus);
   // NS_ASSERTION(aStatus.IsComplete(), "bad status");
 }
 
-/* virtual */ nsresult nsMathMLmpaddedFrame::Place(DrawTarget* aDrawTarget,
-                                                   bool aPlaceOrigin,
-                                                   ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLmpaddedFrame::Place(DrawTarget* aDrawTarget, bool aPlaceOrigin,
+                                     ReflowOutput& aDesiredSize) {
   nsresult rv = nsMathMLContainerFrame::Place(aDrawTarget, false, aDesiredSize);
   if (NS_MATHML_HAS_ERROR(mPresentationData.flags) || NS_FAILED(rv)) {
     DidReflowChildren(PrincipalChildList().FirstChild());
     return rv;
   }
 
   nscoord height = aDesiredSize.BlockStartAscent();
   nscoord depth = aDesiredSize.Height() - aDesiredSize.BlockStartAscent();
@@ -426,13 +426,14 @@ void nsMathMLmpaddedFrame::Reflow(nsPres
   if (aPlaceOrigin) {
     // Finish reflowing child frames, positioning their origins.
     PositionRowChildFrames(dx, aDesiredSize.BlockStartAscent() - voffset);
   }
 
   return NS_OK;
 }
 
-/* virtual */ nsresult nsMathMLmpaddedFrame::MeasureForWidth(
-    DrawTarget* aDrawTarget, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLmpaddedFrame::MeasureForWidth(DrawTarget* aDrawTarget,
+                                               ReflowOutput& aDesiredSize) {
   ProcessAttributes();
   return Place(aDrawTarget, false, aDesiredSize);
 }
--- a/layout/mathml/nsMathMLmrootFrame.cpp
+++ b/layout/mathml/nsMathMLmrootFrame.cpp
@@ -334,18 +334,19 @@ void nsMathMLmrootFrame::Reflow(nsPresCo
                     0);
 
   mReference.x = 0;
   mReference.y = aDesiredSize.BlockStartAscent();
 
   NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
 }
 
-/* virtual */ void nsMathMLmrootFrame::GetIntrinsicISizeMetrics(
-    gfxContext* aRenderingContext, ReflowOutput& aDesiredSize) {
+/* virtual */
+void nsMathMLmrootFrame::GetIntrinsicISizeMetrics(gfxContext* aRenderingContext,
+                                                  ReflowOutput& aDesiredSize) {
   nsIFrame* baseFrame = mFrames.FirstChild();
   nsIFrame* indexFrame = nullptr;
   if (baseFrame) indexFrame = baseFrame->GetNextSibling();
   if (!indexFrame || indexFrame->GetNextSibling()) {
     ReflowError(aRenderingContext->GetDrawTarget(), aDesiredSize);
     return;
   }
 
--- a/layout/mathml/nsMathMLmrowFrame.cpp
+++ b/layout/mathml/nsMathMLmrowFrame.cpp
@@ -48,17 +48,18 @@ nsresult nsMathMLmrowFrame::AttributeCha
     }
     MOZ_ASSERT_UNREACHABLE("mtable wrapper without the real table frame");
   }
 
   return nsMathMLContainerFrame::AttributeChanged(aNameSpaceID, aAttribute,
                                                   aModType);
 }
 
-/* virtual */ eMathMLFrameType nsMathMLmrowFrame::GetMathMLFrameType() {
+/* virtual */
+eMathMLFrameType nsMathMLmrowFrame::GetMathMLFrameType() {
   if (!IsMrowLike()) {
     nsIMathMLFrame* child = do_QueryFrame(mFrames.FirstChild());
     if (child) {
       // We only have one child, so we return the frame type of that child as if
       // we didn't exist.
       return child->GetMathMLFrameType();
     }
   }
--- a/layout/mathml/nsMathMLmspaceFrame.cpp
+++ b/layout/mathml/nsMathMLmspaceFrame.cpp
@@ -104,17 +104,18 @@ void nsMathMLmspaceFrame::Reflow(nsPresC
   aDesiredSize.Width() = std::max(0, mBoundingMetrics.width);
   aDesiredSize.Height() = aDesiredSize.BlockStartAscent() + mDepth;
   // Also return our bounding metrics
   aDesiredSize.mBoundingMetrics = mBoundingMetrics;
 
   NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
 }
 
-/* virtual */ nsresult nsMathMLmspaceFrame::MeasureForWidth(
-    DrawTarget* aDrawTarget, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLmspaceFrame::MeasureForWidth(DrawTarget* aDrawTarget,
+                                              ReflowOutput& aDesiredSize) {
   ProcessAttributes(PresContext());
   mBoundingMetrics = nsBoundingMetrics();
   mBoundingMetrics.width = mWidth;
   aDesiredSize.Width() = std::max(0, mBoundingMetrics.width);
   aDesiredSize.mBoundingMetrics = mBoundingMetrics;
   return NS_OK;
 }
--- a/layout/mathml/nsMathMLmtableFrame.cpp
+++ b/layout/mathml/nsMathMLmtableFrame.cpp
@@ -1214,13 +1214,14 @@ const nsStyleText* nsMathMLmtdInnerFrame
     else
       alignment = alignmentList->ElementAt(alignmentList->Length() - 1);
   }
 
   mUniqueStyleText->mTextAlign = alignment;
   return mUniqueStyleText.get();
 }
 
-/* virtual */ void nsMathMLmtdInnerFrame::DidSetComputedStyle(
+/* virtual */
+void nsMathMLmtdInnerFrame::DidSetComputedStyle(
     ComputedStyle* aOldComputedStyle) {
   nsBlockFrame::DidSetComputedStyle(aOldComputedStyle);
   mUniqueStyleText = MakeUnique<nsStyleText>(*StyleText());
 }
--- a/layout/mathml/nsMathMLmunderoverFrame.cpp
+++ b/layout/mathml/nsMathMLmunderoverFrame.cpp
@@ -349,18 +349,20 @@ i.e.,:
      StyleFont()->mMathDisplay == NS_MATHML_DISPLAYSTYLE_INLINE) {
   // place like subscript-superscript pair
  }
  else {
   // place like underscript-overscript pair
  }
 */
 
-/* virtual */ nsresult nsMathMLmunderoverFrame::Place(
-    DrawTarget* aDrawTarget, bool aPlaceOrigin, ReflowOutput& aDesiredSize) {
+/* virtual */
+nsresult nsMathMLmunderoverFrame::Place(DrawTarget* aDrawTarget,
+                                        bool aPlaceOrigin,
+                                        ReflowOutput& aDesiredSize) {
   float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
   if (NS_MATHML_EMBELLISH_IS_MOVABLELIMITS(mEmbellishData.flags) &&
       StyleFont()->mMathDisplay == NS_MATHML_DISPLAYSTYLE_INLINE) {
     // place like sub sup or subsup
     if (mContent->IsMathMLElement(nsGkAtoms::munderover_)) {
       return nsMathMLmmultiscriptsFrame::PlaceMultiScript(
           PresContext(), aDrawTarget, aPlaceOrigin, aDesiredSize, this, 0, 0,
           fontSizeInflation);
--- a/layout/painting/ActiveLayerTracker.cpp
+++ b/layout/painting/ActiveLayerTracker.cpp
@@ -224,35 +224,37 @@ static LayerActivity* GetLayerActivityFo
   }
   return layerActivity;
 }
 
 static void IncrementMutationCount(uint8_t* aCount) {
   *aCount = uint8_t(std::min(0xFF, *aCount + 1));
 }
 
-/* static */ void ActiveLayerTracker::TransferActivityToContent(
-    nsIFrame* aFrame, nsIContent* aContent) {
+/* static */
+void ActiveLayerTracker::TransferActivityToContent(nsIFrame* aFrame,
+                                                   nsIContent* aContent) {
   if (!aFrame->HasAnyStateBits(NS_FRAME_HAS_LAYER_ACTIVITY_PROPERTY)) {
     return;
   }
   LayerActivity* layerActivity =
       aFrame->RemoveProperty(LayerActivityProperty());
   aFrame->RemoveStateBits(NS_FRAME_HAS_LAYER_ACTIVITY_PROPERTY);
   if (!layerActivity) {
     return;
   }
   layerActivity->mFrame = nullptr;
   layerActivity->mContent = aContent;
   aContent->SetProperty(nsGkAtoms::LayerActivity, layerActivity,
                         nsINode::DeleteProperty<LayerActivity>, true);
 }
 
-/* static */ void ActiveLayerTracker::TransferActivityToFrame(
-    nsIContent* aContent, nsIFrame* aFrame) {
+/* static */
+void ActiveLayerTracker::TransferActivityToFrame(nsIContent* aContent,
+                                                 nsIFrame* aFrame) {
   LayerActivity* layerActivity = static_cast<LayerActivity*>(
       aContent->UnsetProperty(nsGkAtoms::LayerActivity));
   if (!layerActivity) {
     return;
   }
   layerActivity->mContent = nullptr;
   layerActivity->mFrame = aFrame;
   aFrame->AddStateBits(NS_FRAME_HAS_LAYER_ACTIVITY_PROPERTY);
@@ -294,55 +296,60 @@ static void IncrementScaleRestyleCountIf
     return;  // Nothing changed.
   }
 
   aActivity->mPreviousTransformScale = Some(scale);
   IncrementMutationCount(
       &aActivity->mRestyleCounts[LayerActivity::ACTIVITY_SCALE]);
 }
 
-/* static */ void ActiveLayerTracker::NotifyRestyle(nsIFrame* aFrame,
-                                                    nsCSSPropertyID aProperty) {
+/* static */
+void ActiveLayerTracker::NotifyRestyle(nsIFrame* aFrame,
+                                       nsCSSPropertyID aProperty) {
   LayerActivity* layerActivity = GetLayerActivityForUpdate(aFrame);
   uint8_t& mutationCount = layerActivity->RestyleCountForProperty(aProperty);
   IncrementMutationCount(&mutationCount);
 
   if (nsCSSPropertyIDSet::TransformLikeProperties().HasProperty(aProperty)) {
     IncrementScaleRestyleCountIfNeeded(aFrame, layerActivity);
   }
 }
 
-/* static */ void ActiveLayerTracker::NotifyOffsetRestyle(nsIFrame* aFrame) {
+/* static */
+void ActiveLayerTracker::NotifyOffsetRestyle(nsIFrame* aFrame) {
   LayerActivity* layerActivity = GetLayerActivityForUpdate(aFrame);
   IncrementMutationCount(
       &layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_LEFT]);
   IncrementMutationCount(
       &layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_TOP]);
   IncrementMutationCount(
       &layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_RIGHT]);
   IncrementMutationCount(
       &layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_BOTTOM]);
 }
 
-/* static */ void ActiveLayerTracker::NotifyAnimated(
-    nsIFrame* aFrame, nsCSSPropertyID aProperty, const nsAString& aNewValue,
-    nsDOMCSSDeclaration* aDOMCSSDecl) {
+/* static */
+void ActiveLayerTracker::NotifyAnimated(nsIFrame* aFrame,
+                                        nsCSSPropertyID aProperty,
+                                        const nsAString& aNewValue,
+                                        nsDOMCSSDeclaration* aDOMCSSDecl) {
   LayerActivity* layerActivity = GetLayerActivityForUpdate(aFrame);
   uint8_t& mutationCount = layerActivity->RestyleCountForProperty(aProperty);
   if (mutationCount != 0xFF) {
     nsAutoString oldValue;
     aDOMCSSDecl->GetPropertyValue(aProperty, oldValue);
     if (aNewValue != oldValue) {
       // We know this is animated, so just hack the mutation count.
       mutationCount = 0xFF;
     }
   }
 }
 
-/* static */ void ActiveLayerTracker::NotifyAnimatedFromScrollHandler(
+/* static */
+void ActiveLayerTracker::NotifyAnimatedFromScrollHandler(
     nsIFrame* aFrame, nsCSSPropertyID aProperty, nsIFrame* aScrollFrame) {
   if (aFrame->PresContext() != aScrollFrame->PresContext()) {
     // Don't allow cross-document dependencies.
     return;
   }
   LayerActivity* layerActivity = GetLayerActivityForUpdate(aFrame);
   LayerActivity::ActivityIndex activityIndex =
       LayerActivity::GetActivityIndexForProperty(aProperty);
@@ -363,31 +370,33 @@ static bool IsPresContextInScriptAnimati
     return true;
   }
   // Treat timeouts/setintervals as scripted animation callbacks for our
   // purposes.
   nsPIDOMWindowInner* win = aPresContext->Document()->GetInnerWindow();
   return win && win->IsRunningTimeout();
 }
 
-/* static */ void ActiveLayerTracker::NotifyInlineStyleRuleModified(
+/* static */
+void ActiveLayerTracker::NotifyInlineStyleRuleModified(
     nsIFrame* aFrame, nsCSSPropertyID aProperty, const nsAString& aNewValue,
     nsDOMCSSDeclaration* aDOMCSSDecl) {
   if (IsPresContextInScriptAnimationCallback(aFrame->PresContext())) {
     NotifyAnimated(aFrame, aProperty, aNewValue, aDOMCSSDecl);
   }
   if (gLayerActivityTracker &&
       gLayerActivityTracker->mCurrentScrollHandlerFrame.IsAlive()) {
     NotifyAnimatedFromScrollHandler(
         aFrame, aProperty,
         gLayerActivityTracker->mCurrentScrollHandlerFrame.GetFrame());
   }
 }
 
-/* static */ void ActiveLayerTracker::NotifyNeedsRepaint(nsIFrame* aFrame) {
+/* static */
+void ActiveLayerTracker::NotifyNeedsRepaint(nsIFrame* aFrame) {
   LayerActivity* layerActivity = GetLayerActivityForUpdate(aFrame);
   if (IsPresContextInScriptAnimationCallback(aFrame->PresContext())) {
     // This is mirroring NotifyInlineStyleRuleModified's NotifyAnimated logic.
     // Just max out the restyle count if we're in an animation callback.
     layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_TRIGGERED_REPAINT] =
         0xFF;
   } else {
     IncrementMutationCount(
@@ -412,17 +421,18 @@ static bool CheckScrollInducedActivity(
 
   // The scroll frame has been destroyed or has become inactive. Clear it from
   // the layer activity so that it can expire.
   aLayerActivity->mAnimatingScrollHandlerFrame = nullptr;
   aLayerActivity->mScrollHandlerInducedActivity.clear();
   return false;
 }
 
-/* static */ bool ActiveLayerTracker::IsBackgroundPositionAnimated(
+/* static */
+bool ActiveLayerTracker::IsBackgroundPositionAnimated(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame) {
   LayerActivity* layerActivity = GetLayerActivity(aFrame);
   if (layerActivity) {
     LayerActivity::ActivityIndex activityIndex =
         LayerActivity::ActivityIndex::ACTIVITY_BACKGROUND_POSITION;
     if (layerActivity->mRestyleCounts[activityIndex] >= 2) {
       // If the frame needs to be repainted frequently, we probably don't get
       // much from treating the property as animated, *unless* this frame's
@@ -439,29 +449,31 @@ static bool CheckScrollInducedActivity(
     }
   }
   return nsLayoutUtils::HasEffectiveAnimation(
              aFrame, eCSSProperty_background_position_x) ||
          nsLayoutUtils::HasEffectiveAnimation(
              aFrame, eCSSProperty_background_position_y);
 }
 
-/* static */ bool ActiveLayerTracker::IsTransformAnimated(
-    nsDisplayListBuilder* aBuilder, nsIFrame* aFrame) {
+/* static */
+bool ActiveLayerTracker::IsTransformAnimated(nsDisplayListBuilder* aBuilder,
+                                             nsIFrame* aFrame) {
   return IsStyleAnimated(aBuilder, aFrame,
                          nsCSSPropertyIDSet::TransformLikeProperties());
 }
 
-/* static */ bool ActiveLayerTracker::IsTransformMaybeAnimated(
-    nsIFrame* aFrame) {
+/* static */
+bool ActiveLayerTracker::IsTransformMaybeAnimated(nsIFrame* aFrame) {
   return IsStyleAnimated(nullptr, aFrame,
                          nsCSSPropertyIDSet::TransformLikeProperties());
 }
 
-/* static */ bool ActiveLayerTracker::IsStyleAnimated(
+/* static */
+bool ActiveLayerTracker::IsStyleAnimated(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
     const nsCSSPropertyIDSet& aPropertySet) {
   MOZ_ASSERT(
       aPropertySet.Intersect(nsCSSPropertyIDSet::TransformLikeProperties())
               .Equals(aPropertySet) ||
           aPropertySet.Intersect(nsCSSPropertyIDSet::OpacityProperties())
               .Equals(aPropertySet),
       "Only subset of opacity or transform-like properties set calls this");
@@ -507,17 +519,18 @@ static bool CheckScrollInducedActivity(
   }
   if (aPropertySet.Intersects(transformSet) &&
       aFrame->Combines3DTransformWithAncestors()) {
     return IsStyleAnimated(aBuilder, aFrame->GetParent(), aPropertySet);
   }
   return nsLayoutUtils::HasEffectiveAnimation(aFrame, aPropertySet);
 }
 
-/* static */ bool ActiveLayerTracker::IsOffsetStyleAnimated(nsIFrame* aFrame) {
+/* static */
+bool ActiveLayerTracker::IsOffsetStyleAnimated(nsIFrame* aFrame) {
   LayerActivity* layerActivity = GetLayerActivity(aFrame);
   if (layerActivity) {
     if (layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_LEFT] >= 2 ||
         layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_TOP] >= 2 ||
         layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_RIGHT] >= 2 ||
         layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_BOTTOM] >= 2) {
       return true;
     }
@@ -525,18 +538,18 @@ static bool CheckScrollInducedActivity(
   // We should also check for running CSS animations of these properties once
   // bug 1009693 is fixed. Until that happens, layerization isn't useful for
   // animations of these properties because we'll invalidate the layer contents
   // on every change anyway.
   // See bug 1151346 for a patch that adds a check for CSS animations.
   return false;
 }
 
-/* static */ bool ActiveLayerTracker::IsScaleSubjectToAnimation(
-    nsIFrame* aFrame) {
+/* static */
+bool ActiveLayerTracker::IsScaleSubjectToAnimation(nsIFrame* aFrame) {
   // Check whether JavaScript is animating this frame's scale.
   LayerActivity* layerActivity = GetLayerActivity(aFrame);
   if (layerActivity &&
       layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_SCALE] >= 2) {
     return true;
   }
 
   // Check if any animations, transitions, etc. associated with this frame may
@@ -545,33 +558,36 @@ static bool CheckScrollInducedActivity(
   if (effects &&
       AnimationUtils::EffectSetContainsAnimatedScale(*effects, aFrame)) {
     return true;
   }
 
   return false;
 }
 
-/* static */ void ActiveLayerTracker::NotifyContentChange(nsIFrame* aFrame) {
+/* static */
+void ActiveLayerTracker::NotifyContentChange(nsIFrame* aFrame) {
   LayerActivity* layerActivity = GetLayerActivityForUpdate(aFrame);
   layerActivity->mContentActive = true;
 }
 
-/* static */ bool ActiveLayerTracker::IsContentActive(nsIFrame* aFrame) {
+/* static */
+bool ActiveLayerTracker::IsContentActive(nsIFrame* aFrame) {
   LayerActivity* layerActivity = GetLayerActivity(aFrame);
   return layerActivity && layerActivity->mContentActive;
 }
 
-/* static */ void ActiveLayerTracker::SetCurrentScrollHandlerFrame(
-    nsIFrame* aFrame) {
+/* static */
+void ActiveLayerTracker::SetCurrentScrollHandlerFrame(nsIFrame* aFrame) {
   if (!gLayerActivityTracker) {
     gLayerActivityTracker = new LayerActivityTracker(
         SystemGroup::EventTargetFor(TaskCategory::Other));
   }
   gLayerActivityTracker->mCurrentScrollHandlerFrame = aFrame;
 }
 
-/* static */ void ActiveLayerTracker::Shutdown() {
+/* static */
+void ActiveLayerTracker::Shutdown() {
   delete gLayerActivityTracker;
   gLayerActivityTracker = nullptr;
 }
 
 }  // namespace mozilla
--- a/layout/painting/DisplayItemClipChain.cpp
+++ b/layout/painting/DisplayItemClipChain.cpp
@@ -57,17 +57,18 @@ uint32_t DisplayItemClipChain::Hash(cons
     if (!rect.IsEmpty()) {
       hash = AddToHash(hash, rect.x, rect.y, rect.width, rect.height);
     }
   }
 
   return hash;
 }
 
-/* static */ nsCString DisplayItemClipChain::ToString(
+/* static */
+nsCString DisplayItemClipChain::ToString(
     const DisplayItemClipChain* aClipChain) {
   nsAutoCString str;
   for (auto* sc = aClipChain; sc; sc = sc->mParent) {
     if (sc->mASR) {
       str.AppendPrintf("0x%p <%s> [0x%p]", sc, sc->mClip.ToString().get(),
                        sc->mASR->mScrollableFrame);
     } else {
       str.AppendPrintf("0x%p <%s> [root asr]", sc, sc->mClip.ToString().get());
--- a/layout/painting/FrameLayerBuilder.cpp
+++ b/layout/painting/FrameLayerBuilder.cpp
@@ -465,18 +465,18 @@ class LayerManagerData : public LayerUse
   LayerManager* mLayerManager;
 #ifdef DEBUG_DISPLAY_ITEM_DATA
   LayerManagerData* mParent;
 #endif
   std::vector<RefPtr<DisplayItemData>> mDisplayItems;
   bool mInvalidateAllLayers;
 };
 
-/* static */ void FrameLayerBuilder::DestroyDisplayItemDataFor(
-    nsIFrame* aFrame) {
+/* static */
+void FrameLayerBuilder::DestroyDisplayItemDataFor(nsIFrame* aFrame) {
   RemoveFrameFromLayerManager(aFrame, aFrame->DisplayItemData());
   aFrame->DisplayItemData().Clear();
 
   // Destroying a WebRenderUserDataTable can cause destruction of other objects
   // which can remove frame properties in their destructor. If we delete a frame
   // property it runs the destructor of the stored object in the middle of
   // updating the frame property table, so if the destruction of that object
   // causes another update to the frame property table it would leave the frame
@@ -485,17 +485,16 @@ class LayerManagerData : public LayerUse
   WebRenderUserDataTable* userDataTable =
       aFrame->RemoveProperty(WebRenderUserDataProperty::Key());
   if (userDataTable) {
     for (auto iter = userDataTable->Iter(); !iter.Done(); iter.Next()) {
       iter.UserData()->RemoveFromTable();
     }
     delete userDataTable;
   }
-
 }
 
 /**
  * We keep a stack of these to represent the PaintedLayers that are
  * currently available to have display items added to.
  * We use a stack here because as much as possible we want to
  * assign display items to existing PaintedLayers, and to the lowest
  * PaintedLayer in z-order. This reduces the number of layers and
@@ -2058,17 +2057,18 @@ class MaskImageData {
 };
 
 static PaintedDisplayItemLayerUserData* GetPaintedDisplayItemLayerUserData(
     Layer* aLayer) {
   return static_cast<PaintedDisplayItemLayerUserData*>(
       aLayer->GetUserData(&gPaintedDisplayItemLayerUserData));
 }
 
-/* static */ void FrameLayerBuilder::Shutdown() {
+/* static */
+void FrameLayerBuilder::Shutdown() {
   if (gMaskLayerImageCache) {
     delete gMaskLayerImageCache;
     gMaskLayerImageCache = nullptr;
   }
 }
 
 void FrameLayerBuilder::Init(nsDisplayListBuilder* aBuilder,
                              LayerManager* aManager,
@@ -2193,17 +2193,18 @@ static nsIntPoint GetTranslationForPaint
  * the layer manager destroys the LayerManagerData and calls into
  * the DisplayItemData destructor. If the inner layer manager had any
  * items with the same frame, then we attempt to retrieve properties
  * from the deleted frame.
  *
  * Cache the destroyed frame pointer here so we can avoid crashing in this case.
  */
 
-/* static */ void FrameLayerBuilder::RemoveFrameFromLayerManager(
+/* static */
+void FrameLayerBuilder::RemoveFrameFromLayerManager(
     const nsIFrame* aFrame, SmallPointerArray<DisplayItemData>& aArray) {
   MOZ_RELEASE_ASSERT(!sDestroyedFrame);
   sDestroyedFrame = aFrame;
 
   // Hold a reference to all the items so that they don't get
   // deleted from under us.
   nsTArray<RefPtr<DisplayItemData>> arrayCopy;
   for (DisplayItemData* data : aArray) {
@@ -2325,17 +2326,18 @@ void FrameLayerBuilder::WillEndTransacti
       ComputeGeometryChangeForItem(did);
       iter++;
     }
   }
 
   data->mInvalidateAllLayers = false;
 }
 
-/* static */ DisplayItemData* FrameLayerBuilder::GetDisplayItemDataForManager(
+/* static */
+DisplayItemData* FrameLayerBuilder::GetDisplayItemDataForManager(
     nsDisplayItem* aItem, LayerManager* aManager) {
   const SmallPointerArray<DisplayItemData>& array =
       aItem->Frame()->DisplayItemData();
   for (uint32_t i = 0; i < array.Length(); i++) {
     DisplayItemData* item =
         DisplayItemData::AssertDisplayItemData(array.ElementAt(i));
     if (item->mDisplayItemKey == aItem->GetPerFrameKey() &&
         item->mLayer->Manager() == aManager) {
@@ -2399,18 +2401,18 @@ Layer* FrameLayerBuilder::GetOldLayerFor
       *aOldClip = &oldData->mClip;
     }
     return oldData->mLayer;
   }
 
   return nullptr;
 }
 
-/* static */ DisplayItemData* FrameLayerBuilder::GetOldDataFor(
-    nsDisplayItem* aItem) {
+/* static */
+DisplayItemData* FrameLayerBuilder::GetOldDataFor(nsDisplayItem* aItem) {
   const SmallPointerArray<DisplayItemData>& array =
       aItem->Frame()->DisplayItemData();
 
   for (uint32_t i = 0; i < array.Length(); i++) {
     DisplayItemData* data =
         DisplayItemData::AssertDisplayItemData(array.ElementAt(i));
 
     if (data->mDisplayItemKey == aItem->GetPerFrameKey()) {
@@ -6026,22 +6028,22 @@ static nsSize ComputeDesiredDisplaySizeF
   if (widget) {
     return LayoutDevicePixel::ToAppUnits(widget->GetClientSize(),
                                          presContext->AppUnitsPerDevPixel());
   }
 
   return presContext->GetVisibleArea().Size();
 }
 
-/* static */ Size FrameLayerBuilder::ChooseScale(nsIFrame* aContainerFrame,
-                                                 nsDisplayItem* aContainerItem,
-                                                 const nsRect& aVisibleRect,
-                                                 float aXScale, float aYScale,
-                                                 const Matrix& aTransform2d,
-                                                 bool aCanDraw2D) {
+/* static */
+Size FrameLayerBuilder::ChooseScale(nsIFrame* aContainerFrame,
+                                    nsDisplayItem* aContainerItem,
+                                    const nsRect& aVisibleRect, float aXScale,
+                                    float aYScale, const Matrix& aTransform2d,
+                                    bool aCanDraw2D) {
   Size scale;
   // XXX Should we do something for 3D transforms?
   if (aCanDraw2D && !aContainerFrame->Combines3DTransformWithAncestors() &&
       !aContainerFrame->HasPerspective()) {
     // If the container's transform is animated off main thread, fix a suitable
     // scale size for animation
     if (aContainerItem &&
         aContainerItem->GetType() == DisplayItemType::TYPE_TRANSFORM &&
@@ -6362,27 +6364,27 @@ Layer* FrameLayerBuilder::GetLeafLayerFo
     // display item. The display item should not use it for its own
     // layer rendering.
     return nullptr;
   }
   ResetLayerStateForRecycling(layer);
   return layer;
 }
 
-/* static */ void FrameLayerBuilder::InvalidateAllLayers(
-    LayerManager* aManager) {
+/* static */
+void FrameLayerBuilder::InvalidateAllLayers(LayerManager* aManager) {
   LayerManagerData* data = static_cast<LayerManagerData*>(
       aManager->GetUserData(&gLayerManagerUserData));
   if (data) {
     data->mInvalidateAllLayers = true;
   }
 }
 
-/* static */ void FrameLayerBuilder::InvalidateAllLayersForFrame(
-    nsIFrame* aFrame) {
+/* static */
+void FrameLayerBuilder::InvalidateAllLayersForFrame(nsIFrame* aFrame) {
   const SmallPointerArray<DisplayItemData>& array = aFrame->DisplayItemData();
 
   for (uint32_t i = 0; i < array.Length(); i++) {
     DisplayItemData::AssertDisplayItemData(array.ElementAt(i))
         ->mParent->mInvalidateAllLayers = true;
   }
 }
 
@@ -6414,17 +6416,18 @@ Layer* FrameLayerBuilder::GetDedicatedLa
           !layer->HasUserData(&gPaintedDisplayItemLayerUserData)) {
         return layer;
       }
     }
   }
   return nullptr;
 }
 
-/* static */ void FrameLayerBuilder::EnumerateGenerationForDedicatedLayers(
+/* static */
+void FrameLayerBuilder::EnumerateGenerationForDedicatedLayers(
     const nsIFrame* aFrame,
     const CompositorAnimatableDisplayItemTypes& aDisplayItemTypes,
     const AnimationGenerationCallback& aCallback) {
   std::bitset<static_cast<uint32_t>(DisplayItemType::TYPE_MAX)> notFoundTypes;
   for (auto displayItem : aDisplayItemTypes) {
     notFoundTypes.set(static_cast<uint32_t>(displayItem));
   }
 
@@ -6534,17 +6537,18 @@ static void DebugPaintItem(DrawTarget& a
   DumpPaintedImage(aItem, surface);
 
   aDrawTarget.DrawSurface(surface, bounds, Rect(Point(0, 0), bounds.Size()));
 
   aItem->SetPainted();
 }
 #endif
 
-/* static */ void FrameLayerBuilder::RecomputeVisibilityForItems(
+/* static */
+void FrameLayerBuilder::RecomputeVisibilityForItems(
     std::vector<AssignedDisplayItem>& aItems, nsDisplayListBuilder* aBuilder,
     const nsIntRegion& aRegionToDraw, nsRect& aPreviousRectToDraw,
     const nsIntPoint& aOffset, int32_t aAppUnitsPerDevPixel, float aXScale,
     float aYScale) {
   uint32_t i;
   // Update visible regions. We perform visibility analysis to take account
   // of occlusion culling.
   nsRegion visible = aRegionToDraw.ToAppUnits(aAppUnitsPerDevPixel);
@@ -7123,21 +7127,24 @@ static void DrawForcedBackgroundColor(Dr
  * similar issues already arise when we snap cliprects to nearest pixels.
  * Note that if the rendering of the content is snapped to nearest pixels ---
  * which it often is --- then the content is actually rendered at
  * [snap(x + r), snap(xmost + r)). It turns out that floor(x) <= snap(x + r)
  * and ceil(xmost) >= snap(xmost + r), so the rendering of snapped content
  * always falls within the visible region we computed.
  */
 
-/* static */ void FrameLayerBuilder::DrawPaintedLayer(
-    PaintedLayer* aLayer, gfxContext* aContext,
-    const nsIntRegion& aRegionToDraw, const nsIntRegion& aDirtyRegion,
-    DrawRegionClip aClip, const nsIntRegion& aRegionToInvalidate,
-    void* aCallbackData) {
+/* static */
+void FrameLayerBuilder::DrawPaintedLayer(PaintedLayer* aLayer,
+                                         gfxContext* aContext,
+                                         const nsIntRegion& aRegionToDraw,
+                                         const nsIntRegion& aDirtyRegion,
+                                         DrawRegionClip aClip,
+                                         const nsIntRegion& aRegionToInvalidate,
+                                         void* aCallbackData) {
   DrawTarget& aDrawTarget = *aContext->GetDrawTarget();
 
   AUTO_PROFILER_LABEL("FrameLayerBuilder::DrawPaintedLayer",
                       GRAPHICS_Rasterization);
 
   nsDisplayListBuilder* builder =
       static_cast<nsDisplayListBuilder*>(aCallbackData);
 
@@ -7252,18 +7259,20 @@ static void DrawForcedBackgroundColor(Dr
     }
   }
 
   if (!aRegionToInvalidate.IsEmpty()) {
     aLayer->AddInvalidRect(aRegionToInvalidate.GetBounds());
   }
 }
 
-/* static */ void FrameLayerBuilder::DumpRetainedLayerTree(
-    LayerManager* aManager, std::stringstream& aStream, bool aDumpHtml) {
+/* static */
+void FrameLayerBuilder::DumpRetainedLayerTree(LayerManager* aManager,
+                                              std::stringstream& aStream,
+                                              bool aDumpHtml) {
   aManager->Dump(aStream, "", aDumpHtml);
 }
 
 nsDisplayItemGeometry* FrameLayerBuilder::GetMostRecentGeometry(
     nsDisplayItem* aItem) {
   typedef SmallPointerArray<DisplayItemData> DataArray;
 
   // Retrieve the array of DisplayItemData associated with our frame.
--- a/layout/painting/nsCSSRendering.cpp
+++ b/layout/painting/nsCSSRendering.cpp
@@ -551,35 +551,37 @@ static nsRect JoinBoxesForSlice(nsIFrame
     return (aOrder == eForBorder
                 ? gInlineBGData->GetBorderContinuousRect(aFrame, aBorderArea)
                 : gInlineBGData->GetContinuousRect(aFrame)) +
            aBorderArea.TopLeft();
   }
   return JoinBoxesForBlockAxisSlice(aFrame, aBorderArea);
 }
 
-/* static */ bool nsCSSRendering::IsBoxDecorationSlice(
-    const nsStyleBorder& aStyleBorder) {
+/* static */
+bool nsCSSRendering::IsBoxDecorationSlice(const nsStyleBorder& aStyleBorder) {
   return aStyleBorder.mBoxDecorationBreak == StyleBoxDecorationBreak::Slice;
 }
 
-/* static */ nsRect nsCSSRendering::BoxDecorationRectForBorder(
+/* static */
+nsRect nsCSSRendering::BoxDecorationRectForBorder(
     nsIFrame* aFrame, const nsRect& aBorderArea, Sides aSkipSides,
     const nsStyleBorder* aStyleBorder) {
   if (!aStyleBorder) {
     aStyleBorder = aFrame->StyleBorder();
   }
   // If aSkipSides.IsEmpty() then there are no continuations, or it's
   // a ::first-letter that wants all border sides on the first continuation.
   return IsBoxDecorationSlice(*aStyleBorder) && !aSkipSides.IsEmpty()
              ? ::JoinBoxesForSlice(aFrame, aBorderArea, eForBorder)
              : aBorderArea;
 }
 
-/* static */ nsRect nsCSSRendering::BoxDecorationRectForBackground(
+/* static */
+nsRect nsCSSRendering::BoxDecorationRectForBackground(
     nsIFrame* aFrame, const nsRect& aBorderArea, Sides aSkipSides,
     const nsStyleBorder* aStyleBorder) {
   if (!aStyleBorder) {
     aStyleBorder = aFrame->StyleBorder();
   }
   // If aSkipSides.IsEmpty() then there are no continuations, or it's
   // a ::first-letter that wants all border sides on the first continuation.
   return IsBoxDecorationSlice(*aStyleBorder) && !aSkipSides.IsEmpty()
@@ -589,19 +591,20 @@ static nsRect JoinBoxesForSlice(nsIFrame
 
 //----------------------------------------------------------------------
 // Thebes Border Rendering Code Start
 
 /*
  * Compute the float-pixel radii that should be used for drawing
  * this border/outline, given the various input bits.
  */
-/* static */ void nsCSSRendering::ComputePixelRadii(
-    const nscoord* aAppUnitsRadii, nscoord aAppUnitsPerPixel,
-    RectCornerRadii* oBorderRadii) {
+/* static */
+void nsCSSRendering::ComputePixelRadii(const nscoord* aAppUnitsRadii,
+                                       nscoord aAppUnitsPerPixel,
+                                       RectCornerRadii* oBorderRadii) {
   Float radii[8];
   NS_FOR_CSS_HALF_CORNERS(corner)
   radii[corner] = Float(aAppUnitsRadii[corner]) / aAppUnitsPerPixel;
 
   (*oBorderRadii)[C_TL] = Size(radii[eCornerTopLeftX], radii[eCornerTopLeftY]);
   (*oBorderRadii)[C_TR] =
       Size(radii[eCornerTopRightX], radii[eCornerTopRightY]);
   (*oBorderRadii)[C_BR] =
@@ -2016,17 +2019,18 @@ bool nsCSSRendering::ImageLayerClipState
 
   if (mHasRoundedCorners == mClippedRadii.IsEmpty()) {
     return false;
   }
 
   return true;
 }
 
-/* static */ void nsCSSRendering::GetImageLayerClip(
+/* static */
+void nsCSSRendering::GetImageLayerClip(
     const nsStyleImageLayers::Layer& aLayer, nsIFrame* aForFrame,
     const nsStyleBorder& aBorder, const nsRect& aBorderArea,
     const nsRect& aCallerDirtyRect, bool aWillPaintBorder,
     nscoord aAppUnitsPerPixel,
     /* out */ ImageLayerClipState* aClipState) {
   StyleGeometryBox layerClip = ComputeBoxValue(aForFrame, aLayer.mClip);
   if (IsSVGStyleGeometryBox(layerClip)) {
     MOZ_ASSERT(aForFrame->IsFrameOfType(nsIFrame::eSVG) &&
@@ -2803,18 +2807,19 @@ nsRect nsCSSRendering::ComputeImageLayer
       }
     }
   }
   *aAttachedToFrame = attachedToFrame;
 
   return positionArea;
 }
 
-/* static */ nscoord nsCSSRendering::ComputeRoundedSize(
-    nscoord aCurrentSize, nscoord aPositioningSize) {
+/* static */
+nscoord nsCSSRendering::ComputeRoundedSize(nscoord aCurrentSize,
+                                           nscoord aPositioningSize) {
   float repeatCount = NS_roundf(float(aPositioningSize) / float(aCurrentSize));
   if (repeatCount < 1.0f) {
     return aPositioningSize;
   }
   return nscoord(NS_lround(float(aPositioningSize) / repeatCount));
 }
 
 // Apply the CSS image sizing algorithm as it applies to background images.
@@ -2918,18 +2923,20 @@ static nscoord ComputeSpacedRepeatSize(n
     aRepeat = false;
     return aImageDimension;
   }
 
   aRepeat = true;
   return (aAvailableSpace - aImageDimension) / (NSToIntFloor(ratio) - 1);
 }
 
-/* static */ nscoord nsCSSRendering::ComputeBorderSpacedRepeatSize(
-    nscoord aImageDimension, nscoord aAvailableSpace, nscoord& aSpace) {
+/* static */
+nscoord nsCSSRendering::ComputeBorderSpacedRepeatSize(nscoord aImageDimension,
+                                                      nscoord aAvailableSpace,
+                                                      nscoord& aSpace) {
   int32_t count = aImageDimension ? (aAvailableSpace / aImageDimension) : 0;
   aSpace = (aAvailableSpace - aImageDimension * count) / (count + 1);
   return aSpace + aImageDimension;
 }
 
 nsBackgroundLayerState nsCSSRendering::PrepareImageLayer(
     nsPresContext* aPresContext, nsIFrame* aForFrame, uint32_t aFlags,
     const nsRect& aBorderArea, const nsRect& aBGClipRect,
@@ -4262,27 +4269,29 @@ void nsContextBoxBlur::DoPaint() {
     mDestinationCtx->SetMatrix(Matrix());
   }
 
   mAlphaBoxBlur.Paint(mDestinationCtx);
 }
 
 gfxContext* nsContextBoxBlur::GetContext() { return mContext; }
 
-/* static */ nsMargin nsContextBoxBlur::GetBlurRadiusMargin(
-    nscoord aBlurRadius, int32_t aAppUnitsPerDevPixel) {
+/* static */
+nsMargin nsContextBoxBlur::GetBlurRadiusMargin(nscoord aBlurRadius,
+                                               int32_t aAppUnitsPerDevPixel) {
   IntSize blurRadius = ComputeBlurRadius(aBlurRadius, aAppUnitsPerDevPixel);
 
   nsMargin result;
   result.top = result.bottom = blurRadius.height * aAppUnitsPerDevPixel;
   result.left = result.right = blurRadius.width * aAppUnitsPerDevPixel;
   return result;
 }
 
-/* static */ void nsContextBoxBlur::BlurRectangle(
+/* static */
+void nsContextBoxBlur::BlurRectangle(
     gfxContext* aDestinationCtx, const nsRect& aRect,
     int32_t aAppUnitsPerDevPixel, RectCornerRadii* aCornerRadii,
     nscoord aBlurRadius, const Color& aShadowColor, const nsRect& aDirtyRect,
     const gfxRect& aSkipRect) {
   DrawTarget& aDestDrawTarget = *aDestinationCtx->GetDrawTarget();
 
   if (aRect.IsEmpty()) {
     return;
@@ -4336,17 +4345,18 @@ gfxContext* nsContextBoxBlur::GetContext
     aCornerRadii->Scale(scaleX, scaleY);
   }
 
   gfxAlphaBoxBlur::BlurRectangle(aDestinationCtx, shadowThebesRect,
                                  aCornerRadii, blurStdDev, aShadowColor,
                                  dirtyRect, skipRect);
 }
 
-/* static */ void nsContextBoxBlur::GetBlurAndSpreadRadius(
+/* static */
+void nsContextBoxBlur::GetBlurAndSpreadRadius(
     DrawTarget* aDestDrawTarget, int32_t aAppUnitsPerDevPixel,
     nscoord aBlurRadius, nscoord aSpreadRadius, IntSize& aOutBlurRadius,
     IntSize& aOutSpreadRadius, bool aConstrainSpreadRadius) {
   // Do blurs in device space when possible.
   // Chrome/Skia always does the blurs in device space
   // and will sometimes get incorrect results (e.g. rotated blurs)
   Matrix transform = aDestDrawTarget->GetTransform();
   // XXX: we could probably handle negative scales but for now it's easier just
@@ -4371,17 +4381,18 @@ gfxContext* nsContextBoxBlur::GetContext
   if (aConstrainSpreadRadius) {
     aOutSpreadRadius.width =
         std::min(aOutSpreadRadius.width, int32_t(MAX_SPREAD_RADIUS));
     aOutSpreadRadius.height =
         std::min(aOutSpreadRadius.height, int32_t(MAX_SPREAD_RADIUS));
   }
 }
 
-/* static */ bool nsContextBoxBlur::InsetBoxBlur(
+/* static */
+bool nsContextBoxBlur::InsetBoxBlur(
     gfxContext* aDestinationCtx, Rect aDestinationRect, Rect aShadowClipRect,
     Color& aShadowColor, nscoord aBlurRadiusAppUnits,
     nscoord aSpreadDistanceAppUnits, int32_t aAppUnitsPerDevPixel,
     bool aHasBorderRadius, RectCornerRadii& aInnerClipRectRadii, Rect aSkipRect,
     Point aShadowOffset) {
   if (aDestinationRect.IsEmpty()) {
     mContext = nullptr;
     return false;
--- a/layout/painting/nsCSSRenderingBorders.cpp
+++ b/layout/painting/nsCSSRenderingBorders.cpp
@@ -97,18 +97,18 @@ static Color ComputeColorForLine(uint32_
 static bool CheckFourFloatsEqual(const Float* vals, Float k) {
   return (vals[0] == k && vals[1] == k && vals[2] == k && vals[3] == k);
 }
 
 static bool IsZeroSize(const Size& sz) {
   return sz.width == 0.0 || sz.height == 0.0;
 }
 
-/* static */ bool nsCSSBorderRenderer::AllCornersZeroSize(
-    const RectCornerRadii& corners) {
+/* static */
+bool nsCSSBorderRenderer::AllCornersZeroSize(const RectCornerRadii& corners) {
   return IsZeroSize(corners[eCornerTopLeft]) &&
          IsZeroSize(corners[eCornerTopRight]) &&
          IsZeroSize(corners[eCornerBottomRight]) &&
          IsZeroSize(corners[eCornerBottomLeft]);
 }
 
 static mozilla::Side GetHorizontalSide(Corner aCorner) {
   return (aCorner == C_TL || aCorner == C_TR) ? eSideTop : eSideBottom;
@@ -177,19 +177,20 @@ nsCSSBorderRenderer::nsCSSBorderRenderer
 
   mOneUnitBorder = CheckFourFloatsEqual(mBorderWidths, 1.0);
   mNoBorderRadius = AllCornersZeroSize(mBorderRadii);
   mAllBordersSameStyle = AreBorderSideFinalStylesSame(eSideBitsAll);
   mAllBordersSameWidth = AllBordersSameWidth();
   mAvoidStroke = false;
 }
 
-/* static */ void nsCSSBorderRenderer::ComputeInnerRadii(
-    const RectCornerRadii& aRadii, const Float* aBorderSizes,
-    RectCornerRadii* aInnerRadiiRet) {
+/* static */
+void nsCSSBorderRenderer::ComputeInnerRadii(const RectCornerRadii& aRadii,
+                                            const Float* aBorderSizes,
+                                            RectCornerRadii* aInnerRadiiRet) {
   RectCornerRadii& iRadii = *aInnerRadiiRet;
 
   iRadii[C_TL].width =
       std::max(0.f, aRadii[C_TL].width - aBorderSizes[eSideLeft]);
   iRadii[C_TL].height =
       std::max(0.f, aRadii[C_TL].height - aBorderSizes[eSideTop]);
 
   iRadii[C_TR].width =
@@ -203,19 +204,20 @@ nsCSSBorderRenderer::nsCSSBorderRenderer
       std::max(0.f, aRadii[C_BR].height - aBorderSizes[eSideBottom]);
 
   iRadii[C_BL].width =
       std::max(0.f, aRadii[C_BL].width - aBorderSizes[eSideLeft]);
   iRadii[C_BL].height =
       std::max(0.f, aRadii[C_BL].height - aBorderSizes[eSideBottom]);
 }
 
-/* static */ void nsCSSBorderRenderer::ComputeOuterRadii(
-    const RectCornerRadii& aRadii, const Float* aBorderSizes,
-    RectCornerRadii* aOuterRadiiRet) {
+/* static */
+void nsCSSBorderRenderer::ComputeOuterRadii(const RectCornerRadii& aRadii,
+                                            const Float* aBorderSizes,
+                                            RectCornerRadii* aOuterRadiiRet) {
   RectCornerRadii& oRadii = *aOuterRadiiRet;
 
   // default all corners to sharp corners
   oRadii = RectCornerRadii(0.f);
 
   // round the edges that have radii > 0.0 to start with
   if (aRadii[C_TL].width > 0.f && aRadii[C_TL].height > 0.f) {
     oRadii[C_TL].width =
@@ -3324,17 +3326,18 @@ void nsCSSBorderRenderer::CreateWebRende
 
   Range<const wr::BorderSide> wrsides(side, 4);
   aBuilder.PushBorder(roundedRect, clipRect, mBackfaceIsVisible,
                       wr::ToBorderWidths(mBorderWidths[0], mBorderWidths[1],
                                          mBorderWidths[2], mBorderWidths[3]),
                       wrsides, borderRadius);
 }
 
-/* static */ Maybe<nsCSSBorderImageRenderer>
+/* static */
+Maybe<nsCSSBorderImageRenderer>
 nsCSSBorderImageRenderer::CreateBorderImageRenderer(
     nsPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aBorderArea,
     const nsStyleBorder& aStyleBorder, const nsRect& aDirtyRect,
     Sides aSkipSides, uint32_t aFlags, ImgDrawResult* aDrawResult) {
   MOZ_ASSERT(aDrawResult);
 
   if (aDirtyRect.IsEmpty()) {
     *aDrawResult = ImgDrawResult::SUCCESS;
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -137,19 +137,19 @@ void AssertUniqueItem(nsDisplayItem* aIt
         continue;
       }
       MOZ_DIAGNOSTIC_ASSERT(false, "Duplicate display item!");
     }
   }
 }
 #endif
 
-/* static */ bool ActiveScrolledRoot::IsAncestor(
-    const ActiveScrolledRoot* aAncestor,
-    const ActiveScrolledRoot* aDescendant) {
+/* static */
+bool ActiveScrolledRoot::IsAncestor(const ActiveScrolledRoot* aAncestor,
+                                    const ActiveScrolledRoot* aDescendant) {
   if (!aAncestor) {
     // nullptr is the root
     return true;
   }
   if (Depth(aAncestor) > Depth(aDescendant)) {
     return false;
   }
   const ActiveScrolledRoot* asr = aDescendant;
@@ -157,17 +157,18 @@ void AssertUniqueItem(nsDisplayItem* aIt
     if (asr == aAncestor) {
       return true;
     }
     asr = asr->mParent;
   }
   return false;
 }
 
-/* static */ nsCString ActiveScrolledRoot::ToString(
+/* static */
+nsCString ActiveScrolledRoot::ToString(
     const ActiveScrolledRoot* aActiveScrolledRoot) {
   nsAutoCString str;
   for (auto* asr = aActiveScrolledRoot; asr; asr = asr->mParent) {
     str.AppendPrintf("<0x%p>", asr->mScrollableFrame);
     if (asr->mParent) {
       str.AppendLiteral(", ");
     }
   }
@@ -791,17 +792,18 @@ static bool GenerateAndPushTextMask(nsIF
   // blend with it.
   RefPtr<SourceSurface> maskSurface = maskDT->Snapshot();
   sourceCtx->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, 1.0,
                                    maskSurface, maskTransform);
 
   return true;
 }
 
-/* static */ void nsDisplayListBuilder::AddAnimationsAndTransitionsToLayer(
+/* static */
+void nsDisplayListBuilder::AddAnimationsAndTransitionsToLayer(
     Layer* aLayer, nsDisplayListBuilder* aBuilder, nsDisplayItem* aItem,
     nsIFrame* aFrame, nsCSSPropertyID aProperty) {
   MOZ_ASSERT(
       nsCSSProps::PropHasFlags(aProperty, CSSPropFlags::CanAnimateOnCompositor),
       "inconsistent property flags");
 
   // This function can be called in two ways:  from
   // nsDisplay*::BuildLayer while constructing a layer (with all
@@ -928,18 +930,18 @@ void nsDisplayListBuilder::AutoCurrentAc
         descendantASR->mParent = asr;
       }
     }
   }
 
   mUsed = true;
 }
 
-/* static */ nsRect
-nsDisplayListBuilder::OutOfFlowDisplayData::ComputeVisibleRectForFrame(
+/* static */
+nsRect nsDisplayListBuilder::OutOfFlowDisplayData::ComputeVisibleRectForFrame(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
     const nsRect& aVisibleRect, const nsRect& aDirtyRect,
     nsRect* aOutDirtyRect) {
   nsRect visible = aVisibleRect;
   nsRect dirtyRectRelativeToDirtyFrame = aDirtyRect;
 
 #ifdef MOZ_WIDGET_ANDROID
   if (nsLayoutUtils::IsFixedPosFrameInDisplayPort(aFrame) &&
@@ -3059,17 +3061,18 @@ nsDisplayItem::nsDisplayItem(nsDisplayLi
 
   // The visible rect is for mCurrentFrame, so we have to use
   // mCurrentOffsetToReferenceFrame
   nsRect visible = aBuilder->GetVisibleRect() +
                    aBuilder->GetCurrentFrameOffsetToReferenceFrame();
   SetBuildingRect(visible);
 }
 
-/* static */ bool nsDisplayItem::ForceActiveLayers() {
+/* static */
+bool nsDisplayItem::ForceActiveLayers() {
   static bool sForce = false;
   static bool sForceCached = false;
 
   if (!sForceCached) {
     Preferences::AddBoolVarCache(&sForce, "layers.force-active", false);
     sForceCached = true;
   }
 
@@ -3505,17 +3508,18 @@ static bool SpecialCutoutRegionCase(nsDi
   region.Sub(aBackgroundRect, *static_cast<nsRegion*>(cutoutRegion));
   region.MoveBy(aBuilder->ToReferenceFrame(aFrame));
   aList->AppendToTop(MakeDisplayItem<nsDisplaySolidColorRegion>(
       aBuilder, aFrame, region, aColor));
 
   return true;
 }
 
-/*static*/ bool nsDisplayBackgroundImage::AppendBackgroundItemsToTop(
+/*static*/
+bool nsDisplayBackgroundImage::AppendBackgroundItemsToTop(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
     const nsRect& aBackgroundRect, nsDisplayList* aList,
     bool aAllowWillPaintBorderOptimization, ComputedStyle* aComputedStyle,
     const nsRect& aBackgroundOriginRect, nsIFrame* aSecondaryReferenceFrame) {
   ComputedStyle* bgSC = aComputedStyle;
   const nsStyleBackground* bg = nullptr;
   nsRect bgRect = aBackgroundRect + aBuilder->ToReferenceFrame(aFrame);
   nsRect bgOriginRect = bgRect;
@@ -4009,17 +4013,18 @@ bool nsDisplayBackgroundImage::ComputeVi
   }
 
   // Return false if the background was propagated away from this
   // frame. We don't want this display item to show up and confuse
   // anything.
   return mBackgroundStyle;
 }
 
-/* static */ nsRegion nsDisplayBackgroundImage::GetInsideClipRegion(
+/* static */
+nsRegion nsDisplayBackgroundImage::GetInsideClipRegion(
     const nsDisplayItem* aItem, StyleGeometryBox aClip, const nsRect& aRect,
     const nsRect& aBackgroundRect) {
   nsRegion result;
   if (aRect.IsEmpty()) return result;
 
   nsIFrame* frame = aItem->Frame();
 
   nsRect clipRect = aBackgroundRect;
@@ -5360,18 +5365,18 @@ bool nsDisplayBoxShadowInner::CanCreateW
   // input buttons.
   if (nativeTheme) {
     return false;
   }
 
   return true;
 }
 
-/* static */ void
-nsDisplayBoxShadowInner::CreateInsetBoxShadowWebRenderCommands(
+/* static */
+void nsDisplayBoxShadowInner::CreateInsetBoxShadowWebRenderCommands(
     mozilla::wr::DisplayListBuilder& aBuilder, const StackingContextHelper& aSc,
     nsRegion& aVisibleRegion, nsIFrame* aFrame, const nsRect& aBorderRect) {
   if (!nsCSSRendering::ShouldPaintBoxShadowInner(aFrame)) {
     return;
   }
 
   int32_t appUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
 
@@ -5819,19 +5824,20 @@ static bool IsItemTooSmallForActiveLayer
   nsIntRect visibleDevPixels =
       aFrame->GetVisualOverflowRectRelativeToSelf().ToOutsidePixels(
           aFrame->PresContext()->AppUnitsPerDevPixel());
   return visibleDevPixels.Size() <
          nsIntSize(gfxPrefs::LayoutMinActiveLayerSize(),
                    gfxPrefs::LayoutMinActiveLayerSize());
 }
 
-/* static */ bool nsDisplayOpacity::NeedsActiveLayer(
-    nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
-    bool aEnforceMinimumSize) {
+/* static */
+bool nsDisplayOpacity::NeedsActiveLayer(nsDisplayListBuilder* aBuilder,
+                                        nsIFrame* aFrame,
+                                        bool aEnforceMinimumSize) {
   if (EffectCompositor::HasAnimationsForCompositor(aFrame,
                                                    eCSSProperty_opacity) ||
       (ActiveLayerTracker::IsStyleAnimated(
            aBuilder, aFrame, nsCSSPropertyIDSet::OpacityProperties()) &&
        !(aEnforceMinimumSize && IsItemTooSmallForActiveLayer(aFrame)))) {
     return true;
   }
   return false;
@@ -6164,26 +6170,26 @@ bool nsDisplayBlendMode::CanMerge(const 
   if (item->mIndex != 0 || mIndex != 0) {
     // Don't merge background-blend-mode items
     return false;
   }
 
   return true;
 }
 
-/* static */ nsDisplayBlendContainer*
-nsDisplayBlendContainer::CreateForMixBlendMode(
+/* static */
+nsDisplayBlendContainer* nsDisplayBlendContainer::CreateForMixBlendMode(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, nsDisplayList* aList,
     const ActiveScrolledRoot* aActiveScrolledRoot) {
   return MakeDisplayItem<nsDisplayBlendContainer>(aBuilder, aFrame, aList,
                                                   aActiveScrolledRoot, false);
 }
 
-/* static */ nsDisplayBlendContainer*
-nsDisplayBlendContainer::CreateForBackgroundBlendMode(
+/* static */
+nsDisplayBlendContainer* nsDisplayBlendContainer::CreateForBackgroundBlendMode(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, nsDisplayList* aList,
     const ActiveScrolledRoot* aActiveScrolledRoot) {
   return MakeDisplayItem<nsDisplayBlendContainer>(aBuilder, aFrame, aList,
                                                   aActiveScrolledRoot, true);
 }
 
 nsDisplayBlendContainer::nsDisplayBlendContainer(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, nsDisplayList* aList,
@@ -6231,17 +6237,18 @@ bool nsDisplayBlendContainer::CreateWebR
       wr::WrStackingContextClip::ClipChain(aBuilder.CurrentClipChainId());
   StackingContextHelper sc(aSc, GetActiveScrolledRoot(), mFrame, this, aBuilder,
                            params);
 
   return nsDisplayWrapList::CreateWebRenderCommands(
       aBuilder, aResources, sc, aManager, aDisplayListBuilder);
 }
 
-/* static */ nsDisplayTableBlendContainer*
+/* static */
+nsDisplayTableBlendContainer*
 nsDisplayTableBlendContainer::CreateForBackgroundBlendMode(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, nsDisplayList* aList,
     const ActiveScrolledRoot* aActiveScrolledRoot, nsIFrame* aAncestorFrame) {
   return MakeDisplayItem<nsDisplayTableBlendContainer>(
       aBuilder, aFrame, aList, aActiveScrolledRoot, true, aAncestorFrame);
 }
 
 nsDisplayOwnLayer::nsDisplayOwnLayer(
@@ -6624,18 +6631,18 @@ nsDisplayFixedPosition::nsDisplayFixedPo
 
 void nsDisplayFixedPosition::Init(nsDisplayListBuilder* aBuilder) {
   mAnimatedGeometryRootForScrollMetadata = mAnimatedGeometryRoot;
   if (ShouldFixToViewport(aBuilder)) {
     mAnimatedGeometryRoot = aBuilder->FindAnimatedGeometryRootFor(this);
   }
 }
 
-/* static */ nsDisplayFixedPosition*
-nsDisplayFixedPosition::CreateForFixedBackground(
+/* static */
+nsDisplayFixedPosition* nsDisplayFixedPosition::CreateForFixedBackground(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
     nsDisplayBackgroundImage* aImage, uint32_t aIndex) {
   nsDisplayList temp;
   temp.AppendToTop(aImage);
 
   return MakeDisplayItem<nsDisplayFixedPosition>(aBuilder, aFrame, &temp,
                                                  aIndex + 1);
 }
@@ -6761,17 +6768,18 @@ nsDisplayTableFixedPosition::nsDisplayTa
     : nsDisplayFixedPosition(aBuilder, aFrame, aList, aIndex),
       mAncestorFrame(aAncestorFrame),
       mTableType(GetTableTypeFromFrame(aAncestorFrame)) {
   if (aBuilder->IsRetainingDisplayList()) {
     mAncestorFrame->AddDisplayItem(this);
   }
 }
 
-/* static */ nsDisplayTableFixedPosition*
+/* static */
+nsDisplayTableFixedPosition*
 nsDisplayTableFixedPosition::CreateForFixedBackground(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
     nsDisplayBackgroundImage* aImage, uint32_t aIndex,
     nsIFrame* aAncestorFrame) {
   nsDisplayList temp;
   temp.AppendToTop(aImage);
 
   return MakeDisplayItem<nsDisplayTableFixedPosition>(
@@ -7344,17 +7352,18 @@ bool nsDisplayTransform::ShouldFlattenAw
   return mShouldFlatten;
 }
 
 /* Returns the delta specified by the transform-origin property.
  * This is a positive delta, meaning that it indicates the direction to move
  * to get from (0, 0) of the frame to the transform origin.  This function is
  * called off the main thread.
  */
-/* static */ Point3D nsDisplayTransform::GetDeltaToTransformOrigin(
+/* static */
+Point3D nsDisplayTransform::GetDeltaToTransformOrigin(
     const nsIFrame* aFrame, float aAppUnitsPerPixel,
     const nsRect* aBoundsOverride) {
   MOZ_ASSERT(aFrame, "Can't get delta for a null frame!");
   MOZ_ASSERT(aFrame->IsTransformed() || aFrame->BackfaceIsHidden() ||
                  aFrame->Combines3DTransformWithAncestors(),
              "Shouldn't get a delta for an untransformed frame!");
 
   if (!aFrame->IsTransformed()) {
@@ -7388,18 +7397,20 @@ bool nsDisplayTransform::ShouldFlattenAw
     origin.y += CSSPixel::FromAppUnits(refBox.Y());
   }
 
   float scale = mozilla::AppUnitsPerCSSPixel() / float(aAppUnitsPerPixel);
   float z = transformOrigin.depth._0;
   return Point3D(origin.x * scale, origin.y * scale, z * scale);
 }
 
-/* static */ bool nsDisplayTransform::ComputePerspectiveMatrix(
-    const nsIFrame* aFrame, float aAppUnitsPerPixel, Matrix4x4& aOutMatrix) {
+/* static */
+bool nsDisplayTransform::ComputePerspectiveMatrix(const nsIFrame* aFrame,
+                                                  float aAppUnitsPerPixel,
+                                                  Matrix4x4& aOutMatrix) {
   MOZ_ASSERT(aFrame, "Can't get delta for a null frame!");
   MOZ_ASSERT(aFrame->IsTransformed() || aFrame->BackfaceIsHidden() ||
                  aFrame->Combines3DTransformWithAncestors(),
              "Shouldn't get a delta for an untransformed frame!");
   MOZ_ASSERT(aOutMatrix.IsIdentity(), "Must have a blank output matrix");
 
   if (!aFrame->IsTransformed()) {
     return false;
@@ -7621,17 +7632,18 @@ bool nsDisplayTransform::CanUseAsyncAnim
 
 bool nsDisplayBackgroundColor::CanUseAsyncAnimations(
     nsDisplayListBuilder* aBuilder) {
   LayerManager* layerManager = aBuilder->GetWidgetLayerManager();
   return layerManager &&
          layerManager->GetBackendType() != layers::LayersBackend::LAYERS_WR;
 }
 
-/* static */ auto nsDisplayTransform::ShouldPrerenderTransformedContent(
+/* static */
+auto nsDisplayTransform::ShouldPrerenderTransformedContent(
     nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, nsRect* aDirtyRect)
     -> PrerenderDecision {
   // Elements whose transform has been modified recently, or which
   // have a compositor-animated transform, can be prerendered. An element
   // might have only just had its transform animated in which case
   // the ActiveLayerManager may not have been notified yet.
   if (!ActiveLayerTracker::IsTransformMaybeAnimated(aFrame) &&
       !EffectCompositor::HasAnimationsForCompositor(aFrame,
--- a/layout/painting/nsImageRenderer.cpp
+++ b/layout/painting/nsImageRenderer.cpp
@@ -267,17 +267,18 @@ CSSSizeOrRatio nsImageRenderer::ComputeI
     case eStyleImageType_Null:
     default:
       break;
   }
 
   return result;
 }
 
-/* static */ nsSize nsImageRenderer::ComputeConcreteSize(
+/* static */
+nsSize nsImageRenderer::ComputeConcreteSize(
     const CSSSizeOrRatio& aSpecifiedSize, const CSSSizeOrRatio& aIntrinsicSize,
     const nsSize& aDefaultSize) {
   // The specified size is fully specified, just use that
   if (aSpecifiedSize.IsConcrete()) {
     return aSpecifiedSize.ComputeConcreteSize();
   }
 
   MOZ_ASSERT(!aSpecifiedSize.mHasWidth || !aSpecifiedSize.mHasHeight);
@@ -325,19 +326,20 @@ CSSSizeOrRatio nsImageRenderer::ComputeI
   } else if (aIntrinsicSize.mHasWidth) {
     width = aIntrinsicSize.mWidth;
   } else {
     width = aDefaultSize.width;
   }
   return nsSize(width, aSpecifiedSize.mHeight);
 }
 
-/* static */ nsSize nsImageRenderer::ComputeConstrainedSize(
-    const nsSize& aConstrainingSize, const nsSize& aIntrinsicRatio,
-    FitType aFitType) {
+/* static */
+nsSize nsImageRenderer::ComputeConstrainedSize(const nsSize& aConstrainingSize,
+                                               const nsSize& aIntrinsicRatio,
+                                               FitType aFitType) {
   if (aIntrinsicRatio.width <= 0 && aIntrinsicRatio.height <= 0) {
     return aConstrainingSize;
   }
 
   float scaleX = double(aConstrainingSize.width) / aIntrinsicRatio.width;
   float scaleY = double(aConstrainingSize.height) / aIntrinsicRatio.height;
   nsSize size;
   if ((aFitType == CONTAIN) == (scaleX < scaleY)) {
--- a/layout/style/BindingStyleRule.cpp
+++ b/layout/style/BindingStyleRule.cpp
@@ -4,14 +4,15 @@
  * 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/. */
 
 #include "mozilla/BindingStyleRule.h"
 #include "mozilla/dom/CSSStyleRuleBinding.h"
 
 namespace mozilla {
 
-/* virtual */ JSObject* BindingStyleRule::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* BindingStyleRule::WrapObject(JSContext* aCx,
+                                       JS::Handle<JSObject*> aGivenProto) {
   return dom::CSSStyleRule_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 }  // namespace mozilla
--- a/layout/style/CSS.cpp
+++ b/layout/style/CSS.cpp
@@ -14,29 +14,31 @@
 #include "mozilla/dom/Document.h"
 #include "nsIURI.h"
 #include "nsStyleUtil.h"
 #include "xpcpublic.h"
 
 namespace mozilla {
 namespace dom {
 
-/* static */ bool CSS::Supports(const GlobalObject& aGlobal,
-                                const nsAString& aProperty,
-                                const nsAString& aValue, ErrorResult& aRv) {
+/* static */
+bool CSS::Supports(const GlobalObject& aGlobal, const nsAString& aProperty,
+                   const nsAString& aValue, ErrorResult& aRv) {
   NS_ConvertUTF16toUTF8 property(aProperty);
   NS_ConvertUTF16toUTF8 value(aValue);
   return Servo_CSSSupports2(&property, &value);
 }
 
-/* static */ bool CSS::Supports(const GlobalObject& aGlobal,
-                                const nsAString& aCondition, ErrorResult& aRv) {
+/* static */
+bool CSS::Supports(const GlobalObject& aGlobal, const nsAString& aCondition,
+                   ErrorResult& aRv) {
   NS_ConvertUTF16toUTF8 cond(aCondition);
   return Servo_CSSSupports(&cond);
 }
 
-/* static */ void CSS::Escape(const GlobalObject& aGlobal,
-                              const nsAString& aIdent, nsAString& aReturn) {
+/* static */
+void CSS::Escape(const GlobalObject& aGlobal, const nsAString& aIdent,
+                 nsAString& aReturn) {
   nsStyleUtil::AppendEscapedCSSIdent(aIdent, aReturn);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/CSSCounterStyleRule.cpp
+++ b/layout/style/CSSCounterStyleRule.cpp
@@ -64,20 +64,22 @@ void CSSCounterStyleRule::SetName(const 
       if (StyleSheet* sheet = GetStyleSheet()) {                    \
         sheet->RuleChanged(this);                                   \
       }                                                             \
     }                                                               \
   }
 #include "nsCSSCounterDescList.h"
 #undef CSS_COUNTER_DESC
 
-/* virtual */ size_t CSSCounterStyleRule::SizeOfIncludingThis(
+/* virtual */
+size_t CSSCounterStyleRule::SizeOfIncludingThis(
     MallocSizeOf aMallocSizeOf) const {
   return aMallocSizeOf(this);
 }
 
-/* virtual */ JSObject* CSSCounterStyleRule::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* CSSCounterStyleRule::WrapObject(JSContext* aCx,
+                                          JS::Handle<JSObject*> aGivenProto) {
   return CSSCounterStyleRule_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/CSSFontFaceRule.cpp
+++ b/layout/style/CSSFontFaceRule.cpp
@@ -177,17 +177,18 @@ uint16_t CSSFontFaceRule::Type() const {
 
 void CSSFontFaceRule::GetCssText(nsAString& aCssText) const {
   aCssText.Truncate();
   Servo_FontFaceRule_GetCssText(Raw(), &aCssText);
 }
 
 nsICSSDeclaration* CSSFontFaceRule::Style() { return &mDecl; }
 
-/* virtual */ size_t CSSFontFaceRule::SizeOfIncludingThis(
-    MallocSizeOf aMallocSizeOf) const {
+/* virtual */
+size_t CSSFontFaceRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
   return aMallocSizeOf(this);
 }
 
-/* virtual */ JSObject* CSSFontFaceRule::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* CSSFontFaceRule::WrapObject(JSContext* aCx,
+                                      JS::Handle<JSObject*> aGivenProto) {
   return CSSFontFaceRule_Binding::Wrap(aCx, this, aGivenProto);
 }
--- a/layout/style/CSSFontFeatureValuesRule.cpp
+++ b/layout/style/CSSFontFeatureValuesRule.cpp
@@ -54,15 +54,16 @@ void CSSFontFeatureValuesRule::SetValueT
   aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
 }
 
 // If this ever gets its own cycle-collection bits, reevaluate our IsCCLeaf
 // implementation.
 
 bool CSSFontFeatureValuesRule::IsCCLeaf() const { return Rule::IsCCLeaf(); }
 
-/* virtual */ JSObject* CSSFontFeatureValuesRule::WrapObject(
+/* virtual */
+JSObject* CSSFontFeatureValuesRule::WrapObject(
     JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
   return CSSFontFeatureValuesRule_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/CSSImportRule.cpp
+++ b/layout/style/CSSImportRule.cpp
@@ -55,17 +55,18 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(CS
   if (tmp->mChildSheet) {
     tmp->mChildSheet->SetOwnerRule(nullptr);
     tmp->mChildSheet = nullptr;
   }
   tmp->mRawRule = nullptr;
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END_INHERITED(css::Rule)
 
 #ifdef DEBUG
-/* virtual */ void CSSImportRule::List(FILE* out, int32_t aIndent) const {
+/* virtual */
+void CSSImportRule::List(FILE* out, int32_t aIndent) const {
   nsAutoCString str;
   for (int32_t i = 0; i < aIndent; i++) {
     str.AppendLiteral("  ");
   }
   Servo_ImportRule_Debug(mRawRule, &str);
   fprintf_stderr(out, "%s\n", str.get());
 }
 #endif
@@ -74,30 +75,33 @@ dom::MediaList* CSSImportRule::GetMedia(
   // When Bug 1326509 is fixed, we can assert mChildSheet instead.
   return mChildSheet ? mChildSheet->Media() : nullptr;
 }
 
 void CSSImportRule::GetHref(nsAString& aHref) const {
   Servo_ImportRule_GetHref(mRawRule, &aHref);
 }
 
-/* virtual */ void CSSImportRule::GetCssText(nsAString& aCssText) const {
+/* virtual */
+void CSSImportRule::GetCssText(nsAString& aCssText) const {
   Servo_ImportRule_GetCssText(mRawRule, &aCssText);
 }
 
-/* virtual */ size_t CSSImportRule::SizeOfIncludingThis(
+/* virtual */
+size_t CSSImportRule::SizeOfIncludingThis(
     mozilla::MallocSizeOf aMallocSizeOf) const {
   // TODO Implement this!
   return aMallocSizeOf(this);
 }
 
 bool CSSImportRule::IsCCLeaf() const {
   // We're not a leaf.
   return false;
 }
 
-/* virtual */ JSObject* CSSImportRule::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* CSSImportRule::WrapObject(JSContext* aCx,
+                                    JS::Handle<JSObject*> aGivenProto) {
   return CSSImportRule_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/CSSKeyframeRule.cpp
+++ b/layout/style/CSSKeyframeRule.cpp
@@ -122,17 +122,18 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDeclaration)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
 bool CSSKeyframeRule::IsCCLeaf() const {
   return Rule::IsCCLeaf() && !mDeclaration;
 }
 
 #ifdef DEBUG
-/* virtual */ void CSSKeyframeRule::List(FILE* out, int32_t aIndent) const {
+/* virtual */
+void CSSKeyframeRule::List(FILE* out, int32_t aIndent) const {
   nsAutoCString str;
   for (int32_t i = 0; i < aIndent; i++) {
     str.AppendLiteral("  ");
   }
   Servo_Keyframe_Debug(mRaw, &str);
   fprintf_stderr(out, "%s\n", str.get());
 }
 #endif
@@ -169,15 +170,16 @@ nsICSSDeclaration* CSSKeyframeRule::Styl
 size_t CSSKeyframeRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
   size_t n = aMallocSizeOf(this);
   if (mDeclaration) {
     n += mDeclaration->SizeOfIncludingThis(aMallocSizeOf);
   }
   return n;
 }
 
-/* virtual */ JSObject* CSSKeyframeRule::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* CSSKeyframeRule::WrapObject(JSContext* aCx,
+                                      JS::Handle<JSObject*> aGivenProto) {
   return CSSKeyframeRule_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/CSSKeyframesRule.cpp
+++ b/layout/style/CSSKeyframesRule.cpp
@@ -167,33 +167,36 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_IN
     tmp->mKeyframeList = nullptr;
   }
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(CSSKeyframesRule, Rule)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mKeyframeList)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-/* virtual */ bool CSSKeyframesRule::IsCCLeaf() const {
+/* virtual */
+bool CSSKeyframesRule::IsCCLeaf() const {
   // If we don't have rule list constructed, we are a leaf.
   return Rule::IsCCLeaf() && !mKeyframeList;
 }
 
 #ifdef DEBUG
-/* virtual */ void CSSKeyframesRule::List(FILE* out, int32_t aIndent) const {
+/* virtual */
+void CSSKeyframesRule::List(FILE* out, int32_t aIndent) const {
   nsAutoCString str;
   for (int32_t i = 0; i < aIndent; i++) {
     str.AppendLiteral("  ");
   }
   Servo_KeyframesRule_Debug(mRawRule, &str);
   fprintf_stderr(out, "%s\n", str.get());
 }
 #endif
 
-/* virtual */ void CSSKeyframesRule::DropSheetReference() {
+/* virtual */
+void CSSKeyframesRule::DropSheetReference() {
   if (mKeyframeList) {
     mKeyframeList->DropSheetReference();
   }
   css::Rule::DropSheetReference();
 }
 
 static const uint32_t kRuleNotFound = std::numeric_limits<uint32_t>::max();
 
@@ -253,17 +256,18 @@ void CSSKeyframesRule::DeleteRule(const 
   UpdateRule([this, index]() {
     Servo_KeyframesRule_DeleteRule(mRawRule, index);
     if (mKeyframeList) {
       mKeyframeList->RemoveRule(index);
     }
   });
 }
 
-/* virtual */ void CSSKeyframesRule::GetCssText(nsAString& aCssText) const {
+/* virtual */
+void CSSKeyframesRule::GetCssText(nsAString& aCssText) const {
   Servo_KeyframesRule_GetCssText(mRawRule, &aCssText);
 }
 
 /* virtual */ dom::CSSRuleList* CSSKeyframesRule::CssRules() {
   if (!mKeyframeList) {
     mKeyframeList = new CSSKeyframeList(do_AddRef(mRawRule), mSheet, this);
   }
   return mKeyframeList;
@@ -275,24 +279,25 @@ void CSSKeyframesRule::DeleteRule(const 
   if (index != kRuleNotFound) {
     // Construct mKeyframeList but ignore the result.
     CssRules();
     return mKeyframeList->GetRule(index);
   }
   return nullptr;
 }
 
-/* virtual */ size_t CSSKeyframesRule::SizeOfIncludingThis(
-    MallocSizeOf aMallocSizeOf) const {
+/* virtual */
+size_t CSSKeyframesRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
   size_t n = aMallocSizeOf(this);
   if (mKeyframeList) {
     n += mKeyframeList->SizeOfIncludingThis(aMallocSizeOf);
   }
   return n;
 }
 
-/* virtual */ JSObject* CSSKeyframesRule::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* CSSKeyframesRule::WrapObject(JSContext* aCx,
+                                       JS::Handle<JSObject*> aGivenProto) {
   return CSSKeyframesRule_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/CSSMediaRule.cpp
+++ b/layout/style/CSSMediaRule.cpp
@@ -43,25 +43,27 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_IN
   }
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(CSSMediaRule,
                                                   css::ConditionRule)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMediaList)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-/* virtual */ void CSSMediaRule::DropSheetReference() {
+/* virtual */
+void CSSMediaRule::DropSheetReference() {
   if (mMediaList) {
     mMediaList->SetStyleSheet(nullptr);
   }
   ConditionRule::DropSheetReference();
 }
 
 #ifdef DEBUG
-/* virtual */ void CSSMediaRule::List(FILE* out, int32_t aIndent) const {
+/* virtual */
+void CSSMediaRule::List(FILE* out, int32_t aIndent) const {
   nsAutoCString str;
   for (int32_t i = 0; i < aIndent; i++) {
     str.AppendLiteral("  ");
   }
   Servo_MediaRule_Debug(mRawRule, &str);
   fprintf_stderr(out, "%s\n", str.get());
 }
 #endif
@@ -70,33 +72,36 @@ void CSSMediaRule::GetConditionText(nsAS
   Media()->GetMediaText(aConditionText);
 }
 
 void CSSMediaRule::SetConditionText(const nsAString& aConditionText,
                                     ErrorResult& aRv) {
   Media()->SetMediaText(aConditionText);
 }
 
-/* virtual */ void CSSMediaRule::GetCssText(nsAString& aCssText) const {
+/* virtual */
+void CSSMediaRule::GetCssText(nsAString& aCssText) const {
   Servo_MediaRule_GetCssText(mRawRule, &aCssText);
 }
 
 /* virtual */ dom::MediaList* CSSMediaRule::Media() {
   if (!mMediaList) {
     mMediaList = new MediaList(Servo_MediaRule_GetMedia(mRawRule).Consume());
     mMediaList->SetStyleSheet(GetStyleSheet());
   }
   return mMediaList;
 }
 
-/* virtual */ size_t CSSMediaRule::SizeOfIncludingThis(
+/* virtual */
+size_t CSSMediaRule::SizeOfIncludingThis(
     mozilla::MallocSizeOf aMallocSizeOf) const {
   // TODO Implement this!
   return aMallocSizeOf(this);
 }
 
-/* virtual */ JSObject* CSSMediaRule::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* CSSMediaRule::WrapObject(JSContext* aCx,
+                                   JS::Handle<JSObject*> aGivenProto) {
   return CSSMediaRule_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/CSSMozDocumentRule.cpp
+++ b/layout/style/CSSMozDocumentRule.cpp
@@ -9,18 +9,19 @@
 #include "mozilla/ServoBindings.h"
 #include "nsContentUtils.h"
 
 namespace mozilla {
 namespace dom {
 
 using namespace mozilla::css;
 
-/* virtual */ JSObject* CSSMozDocumentRule::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* CSSMozDocumentRule::WrapObject(JSContext* aCx,
+                                         JS::Handle<JSObject*> aGivenProto) {
   return CSSMozDocumentRule_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 bool CSSMozDocumentRule::Match(const Document* aDoc, nsIURI* aDocURI,
                                const nsACString& aDocURISpec,
                                const nsACString& aPattern,
                                DocumentMatchingFunction aMatchingFunction) {
   switch (aMatchingFunction) {
@@ -81,17 +82,18 @@ CSSMozDocumentRule::CSSMozDocumentRule(R
 NS_IMPL_ADDREF_INHERITED(CSSMozDocumentRule, css::ConditionRule)
 NS_IMPL_RELEASE_INHERITED(CSSMozDocumentRule, css::ConditionRule)
 
 // QueryInterface implementation for MozDocumentRule
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CSSMozDocumentRule)
 NS_INTERFACE_MAP_END_INHERITING(css::ConditionRule)
 
 #ifdef DEBUG
-/* virtual */ void CSSMozDocumentRule::List(FILE* out, int32_t aIndent) const {
+/* virtual */
+void CSSMozDocumentRule::List(FILE* out, int32_t aIndent) const {
   nsAutoCString str;
   for (int32_t i = 0; i < aIndent; i++) {
     str.AppendLiteral("  ");
   }
   Servo_MozDocumentRule_Debug(mRawRule, &str);
   fprintf_stderr(out, "%s\n", str.get());
 }
 #endif
@@ -100,20 +102,22 @@ void CSSMozDocumentRule::GetConditionTex
   Servo_MozDocumentRule_GetConditionText(mRawRule, &aConditionText);
 }
 
 void CSSMozDocumentRule::SetConditionText(const nsAString& aConditionText,
                                           ErrorResult& aRv) {
   aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
 }
 
-/* virtual */ void CSSMozDocumentRule::GetCssText(nsAString& aCssText) const {
+/* virtual */
+void CSSMozDocumentRule::GetCssText(nsAString& aCssText) const {
   Servo_MozDocumentRule_GetCssText(mRawRule, &aCssText);
 }
 
-/* virtual */ size_t CSSMozDocumentRule::SizeOfIncludingThis(
+/* virtual */
+size_t CSSMozDocumentRule::SizeOfIncludingThis(
     MallocSizeOf aMallocSizeOf) const {
   // TODO Implement this!
   return aMallocSizeOf(this);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/CSSRuleList.cpp
+++ b/layout/style/CSSRuleList.cpp
@@ -16,15 +16,16 @@ NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CSSRuleList)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(CSSRuleList)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(CSSRuleList)
 
-/* virtual */ JSObject* CSSRuleList::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* CSSRuleList::WrapObject(JSContext* aCx,
+                                  JS::Handle<JSObject*> aGivenProto) {
   return CSSRuleList_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/CSSSupportsRule.cpp
+++ b/layout/style/CSSSupportsRule.cpp
@@ -25,17 +25,18 @@ CSSSupportsRule::CSSSupportsRule(RefPtr<
 NS_IMPL_ADDREF_INHERITED(CSSSupportsRule, ConditionRule)
 NS_IMPL_RELEASE_INHERITED(CSSSupportsRule, ConditionRule)
 
 // QueryInterface implementation for SupportsRule
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CSSSupportsRule)
 NS_INTERFACE_MAP_END_INHERITING(ConditionRule)
 
 #ifdef DEBUG
-/* virtual */ void CSSSupportsRule::List(FILE* out, int32_t aIndent) const {
+/* virtual */
+void CSSSupportsRule::List(FILE* out, int32_t aIndent) const {
   nsAutoCString str;
   for (int32_t i = 0; i < aIndent; i++) {
     str.AppendLiteral("  ");
   }
   Servo_SupportsRule_Debug(mRawRule, &str);
   fprintf_stderr(out, "%s\n", str.get());
 }
 #endif
@@ -44,25 +45,27 @@ void CSSSupportsRule::GetConditionText(n
   Servo_SupportsRule_GetConditionText(mRawRule, &aConditionText);
 }
 
 void CSSSupportsRule::SetConditionText(const nsAString& aConditionText,
                                        ErrorResult& aRv) {
   aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
 }
 
-/* virtual */ void CSSSupportsRule::GetCssText(nsAString& aCssText) const {
+/* virtual */
+void CSSSupportsRule::GetCssText(nsAString& aCssText) const {
   Servo_SupportsRule_GetCssText(mRawRule, &aCssText);
 }
 
-/* virtual */ size_t CSSSupportsRule::SizeOfIncludingThis(
-    MallocSizeOf aMallocSizeOf) const {
+/* virtual */
+size_t CSSSupportsRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
   // TODO Implement this!
   return aMallocSizeOf(this);
 }
 
-/* virtual */ JSObject* CSSSupportsRule::WrapObject(
-    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+/* virtual */
+JSObject* CSSSupportsRule::WrapObject(JSContext* aCx,
+                                      JS::Handle<JSObject*> aGivenProto) {
   return CSSSupportsRule_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 }  // namespace dom
 }  // namespace mozilla
--- a/layout/style/ComputedStyle.cpp
+++ b/layout/style/ComputedStyle.cpp
@@ -314,18 +314,19 @@ static nscolor ExtractColor(ComputedStyl
 #undef STYLE_FIELD
 
 struct ColorIndexSet {
   uint8_t colorIndex, alphaIndex;
 };
 
 static const ColorIndexSet gVisitedIndices[2] = {{0, 0}, {1, 0}};
 
-/* static */ nscolor ComputedStyle::CombineVisitedColors(nscolor* aColors,
-                                                         bool aLinkIsVisited) {
+/* static */
+nscolor ComputedStyle::CombineVisitedColors(nscolor* aColors,
+                                            bool aLinkIsVisited) {
   if (NS_GET_A(aColors[1]) == 0) {
     // If the style-if-visited is transparent, then just use the
     // unvisited style rather than using the (meaningless) color
     // components of the visited style along with a potentially
     // non-transparent alpha value.
     aLinkIsVisited = false;
   }
 
@@ -347,18 +348,18 @@ static const ColorIndexSet gVisitedIndic
       return #name_;
 #  include "nsStyleStructList.h"
 #  undef STYLE_STRUCT
     default:
       return "Unknown";
   }
 }
 
-/* static */ Maybe<StyleStructID> ComputedStyle::LookupStruct(
-    const nsACString& aName) {
+/* static */
+Maybe<StyleStructID> ComputedStyle::LookupStruct(const nsACString& aName) {
 #  define STYLE_STRUCT(name_) \
     if (aName.EqualsLiteral(#name_)) return Some(StyleStructID::name_);
 #  include "nsStyleStructList.h"
 #  undef STYLE_STRUCT
   return Nothing();
 }
 #endif  // DEBUG
 
--- a/layout/style/CounterStyleManager.cpp
+++ b/layout/style/CounterStyleManager.cpp
@@ -537,21 +537,21 @@ class BuiltinCounterStyle : public Count
  protected:
   constexpr BuiltinCounterStyle(const BuiltinCounterStyle& aOther)
       : CounterStyle(aOther.mStyle), mName(aOther.mName) {}
 
  private:
   nsStaticAtom* mName;
 };
 
-/* virtual */ void BuiltinCounterStyle::GetPrefix(nsAString& aResult) {
-  aResult.Truncate();
-}
+/* virtual */
+void BuiltinCounterStyle::GetPrefix(nsAString& aResult) { aResult.Truncate(); }
 
-/* virtual */ void BuiltinCounterStyle::GetSuffix(nsAString& aResult) {
+/* virtual */
+void BuiltinCounterStyle::GetSuffix(nsAString& aResult) {
   switch (mStyle) {
     case NS_STYLE_LIST_STYLE_NONE:
       aResult.Truncate();
       break;
 
     case NS_STYLE_LIST_STYLE_DISC:
     case NS_STYLE_LIST_STYLE_CIRCLE:
     case NS_STYLE_LIST_STYLE_SQUARE:
@@ -584,19 +584,21 @@ class BuiltinCounterStyle : public Count
 
 static const char16_t kDiscCharacter = 0x2022;
 static const char16_t kCircleCharacter = 0x25e6;
 static const char16_t kSquareCharacter = 0x25fe;
 static const char16_t kRightPointingCharacter = 0x25b8;
 static const char16_t kLeftPointingCharacter = 0x25c2;
 static const char16_t kDownPointingCharacter = 0x25be;
 
-/* virtual */ void BuiltinCounterStyle::GetSpokenCounterText(
-    CounterValue aOrdinal, WritingMode aWritingMode, nsAString& aResult,
-    bool& aIsBullet) {
+/* virtual */
+void BuiltinCounterStyle::GetSpokenCounterText(CounterValue aOrdinal,
+                                               WritingMode aWritingMode,
+                                               nsAString& aResult,
+                                               bool& aIsBullet) {
   switch (mStyle) {
     case NS_STYLE_LIST_STYLE_NONE:
     case NS_STYLE_LIST_STYLE_DISC:
     case NS_STYLE_LIST_STYLE_CIRCLE:
     case NS_STYLE_LIST_STYLE_SQUARE:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_CLOSED:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_OPEN: {
       // Same as the initial representation
@@ -607,17 +609,18 @@ static const char16_t kDownPointingChara
     }
     default:
       CounterStyle::GetSpokenCounterText(aOrdinal, aWritingMode, aResult,
                                          aIsBullet);
       break;
   }
 }
 
-/* virtual */ bool BuiltinCounterStyle::IsBullet() {
+/* virtual */
+bool BuiltinCounterStyle::IsBullet() {
   switch (mStyle) {
     case NS_STYLE_LIST_STYLE_DISC:
     case NS_STYLE_LIST_STYLE_CIRCLE:
     case NS_STYLE_LIST_STYLE_SQUARE:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_CLOSED:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_OPEN:
       return true;
     default:
@@ -627,17 +630,18 @@ static const char16_t kDownPointingChara
 
 static const char16_t gJapaneseNegative[] = {0x30de, 0x30a4, 0x30ca, 0x30b9,
                                              0x0000};
 static const char16_t gKoreanNegative[] = {0xb9c8, 0xc774, 0xb108,
                                            0xc2a4, 0x0020, 0x0000};
 static const char16_t gSimpChineseNegative[] = {0x8d1f, 0x0000};
 static const char16_t gTradChineseNegative[] = {0x8ca0, 0x0000};
 
-/* virtual */ void BuiltinCounterStyle::GetNegative(NegativeType& aResult) {
+/* virtual */
+void BuiltinCounterStyle::GetNegative(NegativeType& aResult) {
   switch (mStyle) {
     case NS_STYLE_LIST_STYLE_JAPANESE_FORMAL:
     case NS_STYLE_LIST_STYLE_JAPANESE_INFORMAL:
       aResult.before = gJapaneseNegative;
       break;
 
     case NS_STYLE_LIST_STYLE_KOREAN_HANGUL_FORMAL:
     case NS_STYLE_LIST_STYLE_KOREAN_HANJA_INFORMAL:
@@ -656,18 +660,18 @@ static const char16_t gTradChineseNegati
       break;
 
     default:
       aResult.before.AssignLiteral(u"-");
   }
   aResult.after.Truncate();
 }
 
-/* virtual */ bool BuiltinCounterStyle::IsOrdinalInRange(
-    CounterValue aOrdinal) {
+/* virtual */
+bool BuiltinCounterStyle::IsOrdinalInRange(CounterValue aOrdinal) {
   switch (mStyle) {
     default:
     // cyclic
     case NS_STYLE_LIST_STYLE_NONE:
     case NS_STYLE_LIST_STYLE_DISC:
     case NS_STYLE_LIST_STYLE_CIRCLE:
     case NS_STYLE_LIST_STYLE_SQUARE:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_CLOSED:
@@ -691,18 +695,18 @@ static const char16_t gTradChineseNegati
       return aOrdinal >= 1;
 
     // use HebrewToText
     case NS_STYLE_LIST_STYLE_HEBREW:
       return aOrdinal >= 1 && aOrdinal <= 999999;
   }
 }
 
-/* virtual */ bool BuiltinCounterStyle::IsOrdinalInAutoRange(
-    CounterValue aOrdinal) {
+/* virtual */
+bool BuiltinCounterStyle::IsOrdinalInAutoRange(CounterValue aOrdinal) {
   switch (mStyle) {
     // cyclic:
     case NS_STYLE_LIST_STYLE_NONE:
     case NS_STYLE_LIST_STYLE_DISC:
     case NS_STYLE_LIST_STYLE_CIRCLE:
     case NS_STYLE_LIST_STYLE_SQUARE:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_CLOSED:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_OPEN:
@@ -728,58 +732,64 @@ static const char16_t gTradChineseNegati
       return IsOrdinalInRange(aOrdinal);
 
     default:
       MOZ_ASSERT_UNREACHABLE("Unknown counter style");
       return false;
   }
 }
 
-/* virtual */ void BuiltinCounterStyle::GetPad(PadType& aResult) {
+/* virtual */
+void BuiltinCounterStyle::GetPad(PadType& aResult) {
   aResult.width = 0;
   aResult.symbol.Truncate();
 }
 
-/* virtual */ CounterStyle* BuiltinCounterStyle::GetFallback() {
+/* virtual */
+CounterStyle* BuiltinCounterStyle::GetFallback() {
   // Fallback of dependent builtin counter styles are handled in class
   // DependentBuiltinCounterStyle.
   return CounterStyleManager::GetDecimalStyle();
 }
 
-/* virtual */ uint8_t BuiltinCounterStyle::GetSpeakAs() {
+/* virtual */
+uint8_t BuiltinCounterStyle::GetSpeakAs() {
   switch (mStyle) {
     case NS_STYLE_LIST_STYLE_NONE:
     case NS_STYLE_LIST_STYLE_DISC:
     case NS_STYLE_LIST_STYLE_CIRCLE:
     case NS_STYLE_LIST_STYLE_SQUARE:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_CLOSED:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_OPEN:
       return NS_STYLE_COUNTER_SPEAKAS_BULLETS;
     default:
       return NS_STYLE_COUNTER_SPEAKAS_NUMBERS;
   }
 }
 
-/* virtual */ bool BuiltinCounterStyle::UseNegativeSign() {
+/* virtual */
+bool BuiltinCounterStyle::UseNegativeSign() {
   switch (mStyle) {
     case NS_STYLE_LIST_STYLE_NONE:
     case NS_STYLE_LIST_STYLE_DISC:
     case NS_STYLE_LIST_STYLE_CIRCLE:
     case NS_STYLE_LIST_STYLE_SQUARE:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_CLOSED:
     case NS_STYLE_LIST_STYLE_DISCLOSURE_OPEN:
       return false;
     default:
       return true;
   }
 }
 
-/* virtual */ bool BuiltinCounterStyle::GetInitialCounterText(
-    CounterValue aOrdinal, WritingMode aWritingMode, nsAString& aResult,
-    bool& aIsRTL) {
+/* virtual */
+bool BuiltinCounterStyle::GetInitialCounterText(CounterValue aOrdinal,
+                                                WritingMode aWritingMode,
+                                                nsAString& aResult,
+                                                bool& aIsRTL) {
   aIsRTL = false;
   switch (mStyle) {
     // used by counters & extends counter-style code only
     // XXX We really need to do this the same way we do list bullets.
     case NS_STYLE_LIST_STYLE_NONE:
       aResult.Truncate();
       return true;
     case NS_STYLE_LIST_STYLE_DISC:
@@ -882,17 +892,18 @@ class DependentBuiltinCounterStyle final
   }
 
  private:
   ~DependentBuiltinCounterStyle() {}
 
   CounterStyleManager* mManager;
 };
 
-/* virtual */ CounterStyle* DependentBuiltinCounterStyle::GetFallback() {
+/* virtual */
+CounterStyle* DependentBuiltinCounterStyle::GetFallback() {
   switch (GetStyle()) {
     case NS_STYLE_LIST_STYLE_JAPANESE_INFORMAL:
     case NS_STYLE_LIST_STYLE_JAPANESE_FORMAL:
     case NS_STYLE_LIST_STYLE_KOREAN_HANGUL_FORMAL:
     case NS_STYLE_LIST_STYLE_KOREAN_HANJA_INFORMAL:
     case NS_STYLE_LIST_STYLE_KOREAN_HANJA_FORMAL:
     case NS_STYLE_LIST_STYLE_SIMP_CHINESE_INFORMAL:
     case NS_STYLE_LIST_STYLE_SIMP_CHINESE_FORMAL:
@@ -1078,75 +1089,81 @@ void CustomCounterStyle::ResetDependentD
   mExtends = nullptr;
   mExtendsRoot = nullptr;
   if (IsExtendsSystem()) {
     mFlags &= ~(FLAG_NEGATIVE_INITED | FLAG_PREFIX_INITED | FLAG_SUFFIX_INITED |
                 FLAG_PAD_INITED);
   }
 }
 
-/* virtual */ void CustomCounterStyle::GetPrefix(nsAString& aResult) {
+/* virtual */
+void CustomCounterStyle::GetPrefix(nsAString& aResult) {
   if (!(mFlags & FLAG_PREFIX_INITED)) {
     mFlags |= FLAG_PREFIX_INITED;
 
     nsCSSValue value = GetDesc(eCSSCounterDesc_Prefix);
     if (value.UnitHasStringValue()) {
       value.GetStringValue(mPrefix);
     } else if (IsExtendsSystem()) {
       GetExtends()->GetPrefix(mPrefix);
     } else {
       mPrefix.Truncate();
     }
   }
   aResult = mPrefix;
 }
 
-/* virtual */ void CustomCounterStyle::GetSuffix(nsAString& aResult) {
+/* virtual */
+void CustomCounterStyle::GetSuffix(nsAString& aResult) {
   if (!(mFlags & FLAG_SUFFIX_INITED)) {
     mFlags |= FLAG_SUFFIX_INITED;
 
     nsCSSValue value = GetDesc(eCSSCounterDesc_Suffix);
     if (value.UnitHasStringValue()) {
       value.GetStringValue(mSuffix);
     } else if (IsExtendsSystem()) {
       GetExtends()->GetSuffix(mSuffix);
     } else {
       mSuffix.AssignLiteral(u". ");
     }
   }
   aResult = mSuffix;
 }
 
-/* virtual */ void CustomCounterStyle::GetSpokenCounterText(
-    CounterValue aOrdinal, WritingMode aWritingMode, nsAString& aResult,
-    bool& aIsBullet) {
+/* virtual */
+void CustomCounterStyle::GetSpokenCounterText(CounterValue aOrdinal,
+                                              WritingMode aWritingMode,
+                                              nsAString& aResult,
+                                              bool& aIsBullet) {
   if (GetSpeakAs() != NS_STYLE_COUNTER_SPEAKAS_OTHER) {
     CounterStyle::GetSpokenCounterText(aOrdinal, aWritingMode, aResult,
                                        aIsBullet);
   } else {
     MOZ_ASSERT(mSpeakAsCounter,
                "mSpeakAsCounter should have been initialized.");
     mSpeakAsCounter->GetSpokenCounterText(aOrdinal, aWritingMode, aResult,
                                           aIsBullet);
   }
 }
 
-/* virtual */ bool CustomCounterStyle::IsBullet() {
+/* virtual */
+bool CustomCounterStyle::IsBullet() {
   switch (mSystem) {
     case NS_STYLE_COUNTER_SYSTEM_CYCLIC:
       // Only use ::-moz-list-bullet for cyclic system
       return true;
     case NS_STYLE_COUNTER_SYSTEM_EXTENDS:
       return GetExtendsRoot()->IsBullet();
     default:
       return false;
   }
 }
 
-/* virtual */ void CustomCounterStyle::GetNegative(NegativeType& aResult) {
+/* virtual */
+void CustomCounterStyle::GetNegative(NegativeType& aResult) {
   if (!(mFlags & FLAG_NEGATIVE_INITED)) {
     mFlags |= FLAG_NEGATIVE_INITED;
     nsCSSValue value = GetDesc(eCSSCounterDesc_Negative);
     switch (value.GetUnit()) {
       case eCSSUnit_Ident:
       case eCSSUnit_String:
         value.GetStringValue(mNegative.before);
         mNegative.after.Truncate();
@@ -1170,17 +1187,18 @@ void CustomCounterStyle::ResetDependentD
   aResult = mNegative;
 }
 
 static inline bool IsRangeValueInfinite(const nsCSSValue& aValue) {
   return aValue.GetUnit() == eCSSUnit_Enumerated &&
          aValue.GetIntValue() == NS_STYLE_COUNTER_RANGE_INFINITE;
 }
 
-/* virtual */ bool CustomCounterStyle::IsOrdinalInRange(CounterValue aOrdinal) {
+/* virtual */
+bool CustomCounterStyle::IsOrdinalInRange(CounterValue aOrdinal) {
   nsCSSValue value = GetDesc(eCSSCounterDesc_Range);
   if (value.GetUnit() == eCSSUnit_PairList) {
     for (const nsCSSValuePairList* item = value.GetPairListValue();
          item != nullptr; item = item->mNext) {
       const nsCSSValue& lowerBound = item->mXValue;
       const nsCSSValue& upperBound = item->mYValue;
       if ((IsRangeValueInfinite(lowerBound) ||
            aOrdinal >= lowerBound.GetIntValue()) &&
@@ -1192,18 +1210,18 @@ static inline bool IsRangeValueInfinite(
     return false;
   } else if (IsExtendsSystem() && value.GetUnit() == eCSSUnit_None) {
     // Only use the range of extended style when 'range' is not specified.
     return GetExtends()->IsOrdinalInRange(aOrdinal);
   }
   return IsOrdinalInAutoRange(aOrdinal);
 }
 
-/* virtual */ bool CustomCounterStyle::IsOrdinalInAutoRange(
-    CounterValue aOrdinal) {
+/* virtual */
+bool CustomCounterStyle::IsOrdinalInAutoRange(CounterValue aOrdinal) {
   switch (mSystem) {
     case NS_STYLE_COUNTER_SYSTEM_CYCLIC:
     case NS_STYLE_COUNTER_SYSTEM_NUMERIC:
     case NS_STYLE_COUNTER_SYSTEM_FIXED:
       return true;
     case NS_STYLE_COUNTER_SYSTEM_ALPHABETIC:
     case NS_STYLE_COUNTER_SYSTEM_SYMBOLIC:
       return aOrdinal >= 1;
@@ -1212,17 +1230,18 @@ static inline bool IsRangeValueInfinite(
     case NS_STYLE_COUNTER_SYSTEM_EXTENDS:
       return GetExtendsRoot()->IsOrdinalInAutoRange(aOrdinal);
     default:
       MOZ_ASSERT_UNREACHABLE("Invalid system for computing auto value.");
       return false;
   }
 }
 
-/* virtual */ void CustomCounterStyle::GetPad(PadType& aResult) {
+/* virtual */
+void CustomCounterStyle::GetPad(PadType& aResult) {
   if (!(mFlags & FLAG_PAD_INITED)) {
     mFlags |= FLAG_PAD_INITED;
     nsCSSValue value = GetDesc(eCSSCounterDesc_Pad);
     if (value.GetUnit() == eCSSUnit_Pair) {
       const nsCSSValuePair& pair = value.GetPairValue();
       mPad.width = pair.mXValue.GetIntValue();
       pair.mYValue.GetStringValue(mPad.symbol);
     } else if (IsExtendsSystem()) {
@@ -1230,56 +1249,62 @@ static inline bool IsRangeValueInfinite(
     } else {
       mPad.width = 0;
       mPad.symbol.Truncate();
     }
   }
   aResult = mPad;
 }
 
-/* virtual */ CounterStyle* CustomCounterStyle::GetFallback() {
+/* virtual */
+CounterStyle* CustomCounterStyle::GetFallback() {
   if (!mFallback) {
     mFallback = CounterStyleManager::GetDecimalStyle();
     if (nsAtom* fallback = Servo_CounterStyleRule_GetFallback(mRule)) {
       mFallback = mManager->ResolveCounterStyle(fallback);
     } else if (IsExtendsSystem()) {
       mFallback = GetExtends()->GetFallback();
     }
   }
   return mFallback;
 }
 
-/* virtual */ uint8_t CustomCounterStyle::GetSpeakAs() {
+/* virtual */
+uint8_t CustomCounterStyle::GetSpeakAs() {
   if (!(mFlags & FLAG_SPEAKAS_INITED)) {
     ComputeSpeakAs();
   }
   return mSpeakAs;
 }
 
-/* virtual */ bool CustomCounterStyle::UseNegativeSign() {
+/* virtual */
+bool CustomCounterStyle::UseNegativeSign() {
   if (mSystem == NS_STYLE_COUNTER_SYSTEM_EXTENDS) {
     return GetExtendsRoot()->UseNegativeSign();
   }
   return SystemUsesNegativeSign(mSystem);
 }
 
-/* virtual */ void CustomCounterStyle::CallFallbackStyle(
-    CounterValue aOrdinal, WritingMode aWritingMode, nsAString& aResult,
-    bool& aIsRTL) {
+/* virtual */
+void CustomCounterStyle::CallFallbackStyle(CounterValue aOrdinal,
+                                           WritingMode aWritingMode,
+                                           nsAString& aResult, bool& aIsRTL) {
   CounterStyle* fallback = GetFallback();
   // If it recursively falls back to this counter style again,
   // it will then fallback to decimal to break the loop.
   mFallback = CounterStyleManager::GetDecimalStyle();
   fallback->GetCounterText(aOrdinal, aWritingMode, aResult, aIsRTL);
   mFallback = fallback;
 }
 
-/* virtual */ bool CustomCounterStyle::GetInitialCounterText(
-    CounterValue aOrdinal, WritingMode aWritingMode, nsAString& aResult,
-    bool& aIsRTL) {
+/* virtual */
+bool CustomCounterStyle::GetInitialCounterText(CounterValue aOrdinal,
+                                               WritingMode aWritingMode,
+                                               nsAString& aResult,
+                                               bool& aIsRTL) {
   switch (mSystem) {
     case NS_STYLE_COUNTER_SYSTEM_CYCLIC:
       return GetCyclicCounterText(aOrdinal, aResult, GetSymbols());
     case NS_STYLE_COUNTER_SYSTEM_FIXED: {
       int32_t start = Servo_CounterStyleRule_GetFixedFirstValue(mRule);
       return GetFixedCounterText(aOrdinal, aResult, start, GetSymbols());
     }
     case NS_STYLE_COUNTER_SYSTEM_SYMBOLIC:
@@ -1538,84 +1563,94 @@ AnonymousCounterStyle::AnonymousCounterS
 
 AnonymousCounterStyle::AnonymousCounterStyle(uint8_t aSystem,
                                              nsTArray<nsString> aSymbols)
     : CounterStyle(NS_STYLE_LIST_STYLE_CUSTOM),
       mSingleString(false),
       mSystem(aSystem),
       mSymbols(std::move(aSymbols)) {}
 
-/* virtual */ void AnonymousCounterStyle::GetPrefix(nsAString& aResult) {
+/* virtual */
+void AnonymousCounterStyle::GetPrefix(nsAString& aResult) {
   aResult.Truncate();
 }
 
-/* virtual */ void AnonymousCounterStyle::GetSuffix(nsAString& aResult) {
+/* virtual */
+void AnonymousCounterStyle::GetSuffix(nsAString& aResult) {
   if (IsSingleString()) {
     aResult.Truncate();
   } else {
     aResult = ' ';
   }
 }
 
-/* virtual */ bool AnonymousCounterStyle::IsBullet() {
+/* virtual */
+bool AnonymousCounterStyle::IsBullet() {
   switch (mSystem) {
     case NS_STYLE_COUNTER_SYSTEM_CYCLIC:
       // Only use ::-moz-list-bullet for cyclic system
       return true;
     default:
       return false;
   }
 }
 
-/* virtual */ void AnonymousCounterStyle::GetNegative(NegativeType& aResult) {
+/* virtual */
+void AnonymousCounterStyle::GetNegative(NegativeType& aResult) {
   aResult.before.AssignLiteral(u"-");
   aResult.after.Truncate();
 }
 
-/* virtual */ bool AnonymousCounterStyle::IsOrdinalInRange(
-    CounterValue aOrdinal) {
+/* virtual */
+bool AnonymousCounterStyle::IsOrdinalInRange(CounterValue aOrdinal) {
   switch (mSystem) {
     case NS_STYLE_COUNTER_SYSTEM_CYCLIC:
     case NS_STYLE_COUNTER_SYSTEM_NUMERIC:
     case NS_STYLE_COUNTER_SYSTEM_FIXED:
       return true;
     case NS_STYLE_COUNTER_SYSTEM_ALPHABETIC:
     case NS_STYLE_COU