--- a/layout/generic/nsFrameIdList.h
+++ b/layout/generic/nsFrameIdList.h
@@ -86,17 +86,17 @@ FRAME_ID(nsMathMLmoFrame)
 FRAME_ID(nsMathMLmoverFrame)
 FRAME_ID(nsMathMLmpaddedFrame)
 FRAME_ID(nsMathMLmrootFrame)
 FRAME_ID(nsMathMLmrowFrame)
 FRAME_ID(nsMathMLmspaceFrame)
 FRAME_ID(nsMathMLmsqrtFrame)
 FRAME_ID(nsMathMLmstyleFrame)
 FRAME_ID(nsMathMLmtableFrame)
-FRAME_ID(nsMathMLmtableOuterFrame)
+FRAME_ID(nsMathMLmtableWrapperFrame)
 FRAME_ID(nsMathMLmtdFrame)
 FRAME_ID(nsMathMLmtdInnerFrame)
 FRAME_ID(nsMathMLmtrFrame)
 FRAME_ID(nsMathMLmunderFrame)
 FRAME_ID(nsMathMLmunderoverFrame)
 FRAME_ID(nsMathMLsemanticsFrame)
 FRAME_ID(nsMathMLTokenFrame)
 FRAME_ID(nsMenuBarFrame)

--- a/layout/mathml/nsMathMLmtableFrame.cpp
+++ b/layout/mathml/nsMathMLmtableFrame.cpp
@@ -60,17 +60,18 @@ ParseStyleValue(nsIAtom* aAttribute, con
   } else {
     MOZ_CRASH("Unrecognized attribute.");
   }
 
   return -1;
 }
 
 static nsTArray<int8_t>*
-ExtractStyleValues(const nsAString& aString, nsIAtom* aAttribute,
+ExtractStyleValues(const nsAString& aString,
+                   nsIAtom* aAttribute,
                    bool aAllowMultiValues)
 {
   nsTArray<int8_t>* styleArray = nullptr;
 
   const char16_t* start = aString.BeginReading();
   const char16_t* end = aString.EndReading();
 
   int32_t startIndex = 0;
@@ -107,18 +108,20 @@ ExtractStyleValues(const nsAString& aStr
 
       startIndex += count;
       count = 0;
     }
   }
   return styleArray;
 }
 
-static nsresult ReportParseError(nsIFrame* aFrame, const char16_t* aAttribute,
-                                 const char16_t* aValue)
+static nsresult
+ReportParseError(nsIFrame* aFrame,
+                 const char16_t* aAttribute,
+                 const char16_t* aValue)
 {
   nsIContent* content = aFrame->GetContent();
 
   const char16_t* params[] =
     { aValue, aAttribute, content->NodeInfo()->NameAtom()->GetUTF16String() };
 
   return nsContentUtils::ReportToConsole(nsIScriptError::errorFlag,
                                          NS_LITERAL_CSTRING("Layout: MathML"),
@@ -147,17 +150,17 @@ AttributeToProperty(nsIAtom* aAttribute)
   if (aAttribute == nsGkAtoms::columnalign_)
     return ColumnAlignProperty();
   NS_ASSERTION(aAttribute == nsGkAtoms::columnlines_, "Invalid attribute");
   return ColumnLinesProperty();
 }
 
 /* This method looks for a property that applies to a cell, but it looks
  * recursively because some cell properties can come from the cell, a row,
- * a table, etc. This function searches through the heirarchy for a property
+ * a table, etc. This function searches through the hierarchy for a property
  * and returns its value. The function stops searching after checking a <mtable>
  * frame.
  */
 static nsTArray<int8_t>*
 FindCellProperty(const nsIFrame* aCellFrame,
                  const FramePropertyDescriptor<nsTArray<int8_t>>* aFrameProperty)
 {
   const nsIFrame* currentFrame = aCellFrame;
@@ -222,17 +225,18 @@ ApplyBorderToStyle(const nsMathMLmtdFram
       aStyleBorder.SetBorderStyle(NS_SIDE_LEFT,
                     columnLinesList->ElementAt(listLength - 1));
     }
     aStyleBorder.SetBorderWidth(NS_SIDE_LEFT, borderWidth);
   }
 }
 
 static nsMargin
-ComputeBorderOverflow(nsMathMLmtdFrame* aFrame, const nsStyleBorder& aStyleBorder)
+ComputeBorderOverflow(nsMathMLmtdFrame* aFrame,
+                      const nsStyleBorder& aStyleBorder)
 {
   nsMargin overflow;
   int32_t rowIndex;
   int32_t columnIndex;
   nsTableFrame* table = aFrame->GetTableFrame();
   aFrame->GetCellIndexes(rowIndex, columnIndex);
   if (!columnIndex) {
     overflow.left = table->GetColSpacing(-1);
@@ -257,17 +261,18 @@ ComputeBorderOverflow(nsMathMLmtdFrame* 
   return overflow;
 }
 
 /*
  * A variant of the nsDisplayBorder contains special code to render a border
  * around a nsMathMLmtdFrame based on the rowline and columnline properties
  * set on the cell frame.
  */
-class nsDisplaymtdBorder : public nsDisplayBorder {
+class nsDisplaymtdBorder : public nsDisplayBorder
+{
 public:
   nsDisplaymtdBorder(nsDisplayListBuilder* aBuilder, nsMathMLmtdFrame* aFrame)
     : nsDisplayBorder(aBuilder, aFrame)
   {
   }
 
   nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override
   {
@@ -332,17 +337,18 @@ public:
 #ifdef DEBUG
 #define DEBUG_VERIFY_THAT_FRAME_IS(_frame, _expected) \
   NS_ASSERTION(NS_STYLE_DISPLAY_##_expected == _frame->StyleDisplay()->mDisplay, "internal error");
 #else
 #define DEBUG_VERIFY_THAT_FRAME_IS(_frame, _expected)
 #endif
 
 static void
-ParseFrameAttribute(nsIFrame* aFrame, nsIAtom* aAttribute,
+ParseFrameAttribute(nsIFrame* aFrame,
+                    nsIAtom* aAttribute,
                     bool aAllowMultiValues)
 {
   nsAutoString attrValue;
 
   nsIContent* frameContent = aFrame->GetContent();
   frameContent->GetAttr(kNameSpaceID_None, aAttribute, attrValue);
 
   if (!attrValue.IsEmpty()) {
@@ -555,17 +561,17 @@ ParseSpacingAttribute(nsMathMLmtableFram
 static void ParseSpacingAttributes(nsMathMLmtableFrame* aTableFrame)
 {
   ParseSpacingAttribute(aTableFrame, nsGkAtoms::rowspacing_);
   ParseSpacingAttribute(aTableFrame, nsGkAtoms::columnspacing_);
   ParseSpacingAttribute(aTableFrame, nsGkAtoms::framespacing_);
   aTableFrame->SetUseCSSSpacing();
 }
 
-// map all attribues within a table -- requires the indices of rows and cells.
+// map all attributes within a table -- requires the indices of rows and cells.
 // so it can only happen after they are made ready by the table base class.
 static void
 MapAllAttributesIntoCSS(nsMathMLmtableFrame* aTableFrame)
 {
   // Map mtable rowalign & rowlines.
   ParseFrameAttribute(aTableFrame, nsGkAtoms::rowalign_, true);
   ParseFrameAttribute(aTableFrame, nsGkAtoms::rowlines_, true);
 
@@ -676,38 +682,38 @@ ListMathMLTree(nsIFrame* atLeast)
       break;
   }
   if (!f) f = atLeast;
   f->List(stdout, 0);
 }
 #endif
 
 // --------
-// implementation of nsMathMLmtableOuterFrame
+// implementation of nsMathMLmtableWrapperFrame
 
-NS_QUERYFRAME_HEAD(nsMathMLmtableOuterFrame)
+NS_QUERYFRAME_HEAD(nsMathMLmtableWrapperFrame)
   NS_QUERYFRAME_ENTRY(nsIMathMLFrame)
 NS_QUERYFRAME_TAIL_INHERITING(nsTableWrapperFrame)
 
 nsContainerFrame*
 NS_NewMathMLmtableOuterFrame (nsIPresShell* aPresShell, nsStyleContext* aContext)
 {
-  return new (aPresShell) nsMathMLmtableOuterFrame(aContext);
+  return new (aPresShell) nsMathMLmtableWrapperFrame(aContext);
 }
 
-NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmtableOuterFrame)
+NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmtableWrapperFrame)
  
-nsMathMLmtableOuterFrame::~nsMathMLmtableOuterFrame()
+nsMathMLmtableWrapperFrame::~nsMathMLmtableWrapperFrame()
 {
 }
 
 nsresult
-nsMathMLmtableOuterFrame::AttributeChanged(int32_t  aNameSpaceID,
-                                           nsIAtom* aAttribute,
-                                           int32_t  aModType)
+nsMathMLmtableWrapperFrame::AttributeChanged(int32_t  aNameSpaceID,
+                                             nsIAtom* aAttribute,
+                                             int32_t  aModType)
 {
   // Attributes specific to <mtable>:
   // frame         : in mathml.css
   // framespacing  : here
   // groupalign    : not yet supported
   // equalrows     : not yet supported 
   // equalcolumns  : not yet supported 
   // displaystyle  : here and in mathml.css
@@ -774,17 +780,17 @@ nsMathMLmtableOuterFrame::AttributeChang
   // Explicitly request a reflow in our subtree to pick up any changes
   presContext->PresShell()->
       FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
 
   return NS_OK;
 }
 
 nsIFrame*
-nsMathMLmtableOuterFrame::GetRowFrameAt(int32_t aRowIndex)
+nsMathMLmtableWrapperFrame::GetRowFrameAt(int32_t aRowIndex)
 {
   int32_t rowCount = GetRowCount();
 
   // Negative indices mean to find upwards from the end.
   if (aRowIndex < 0) {
     aRowIndex = rowCount + aRowIndex;
   } else {
     // aRowIndex is 1-based, so convert it to a 0-based index
@@ -809,20 +815,20 @@ nsMathMLmtableOuterFrame::GetRowFrameAt(
       }
       --aRowIndex;
     }
   }
   return nullptr;
 }
 
 void
-nsMathMLmtableOuterFrame::Reflow(nsPresContext*          aPresContext,
-                                 nsHTMLReflowMetrics&     aDesiredSize,
-                                 const nsHTMLReflowState& aReflowState,
-                                 nsReflowStatus&          aStatus)
+nsMathMLmtableWrapperFrame::Reflow(nsPresContext*           aPresContext,
+                                   nsHTMLReflowMetrics&     aDesiredSize,
+                                   const nsHTMLReflowState& aReflowState,
+                                   nsReflowStatus&          aStatus)
 {
   nsAutoString value;
   // we want to return a table that is anchored according to the align attribute
 
   nsTableWrapperFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
   NS_ASSERTION(aDesiredSize.Height() >= 0, "illegal height for mtable");
   NS_ASSERTION(aDesiredSize.Width() >= 0, "illegal width for mtable");
 
@@ -966,17 +972,17 @@ nsMathMLmtableFrame::GetColSpacing(int32
   if ((uint32_t) aColIndex >= mColSpacing.Length()) {
     return mColSpacing.LastElement();
   }
   return mColSpacing.ElementAt(aColIndex);
 }
 
 nscoord
 nsMathMLmtableFrame::GetColSpacing(int32_t aStartColIndex,
-                                     int32_t aEndColIndex)
+                                  int32_t aEndColIndex)
 {
   if (mUseCSSSpacing) {
     return nsTableFrame::GetColSpacing(aStartColIndex, aEndColIndex);
   }
   if (aStartColIndex == aEndColIndex) {
     return 0;
   }
   if (!mColSpacing.Length()) {
@@ -1026,17 +1032,17 @@ nsMathMLmtableFrame::GetRowSpacing(int32
   if ((uint32_t) aRowIndex >= mRowSpacing.Length()) {
     return mRowSpacing.LastElement();
   }
   return mRowSpacing.ElementAt(aRowIndex);
 }
 
 nscoord
 nsMathMLmtableFrame::GetRowSpacing(int32_t aStartRowIndex,
-                                     int32_t aEndRowIndex)
+                                   int32_t aEndRowIndex)
 {
   if (mUseCSSSpacing) {
     return nsTableFrame::GetRowSpacing(aStartRowIndex, aEndRowIndex);
   }
   if (aStartRowIndex == aEndRowIndex) {
     return 0;
   }
   if (!mRowSpacing.Length()) {
@@ -1126,18 +1132,19 @@ nsMathMLmtrFrame::AttributeChanged(int32
 
   return NS_OK;
 }
 
 // --------
 // implementation of nsMathMLmtdFrame
 
 nsContainerFrame*
-NS_NewMathMLmtdFrame(nsIPresShell* aPresShell, nsStyleContext* aContext,
-                     nsTableFrame* aTableFrame)
+NS_NewMathMLmtdFrame(nsIPresShell*   aPresShell,
+                     nsStyleContext* aContext,
+                     nsTableFrame*   aTableFrame)
 {
   return new (aPresShell) nsMathMLmtdFrame(aContext, aTableFrame);
 }
 
 NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmtdFrame)
 
 nsMathMLmtdFrame::~nsMathMLmtdFrame()
 {
@@ -1293,27 +1300,27 @@ NS_NewMathMLmtdInnerFrame(nsIPresShell* 
   return new (aPresShell) nsMathMLmtdInnerFrame(aContext);
 }
 
 NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmtdInnerFrame)
 
 nsMathMLmtdInnerFrame::nsMathMLmtdInnerFrame(nsStyleContext* aContext)
   : nsBlockFrame(aContext)
 {
-  // Make a copy of the parent nsStyleText for later modificaiton.
+  // Make a copy of the parent nsStyleText for later modification.
   mUniqueStyleText = new (PresContext()) nsStyleText(*StyleText());
 }
 
 nsMathMLmtdInnerFrame::~nsMathMLmtdInnerFrame()
 {
   mUniqueStyleText->Destroy(PresContext());
 }
 
 void
-nsMathMLmtdInnerFrame::Reflow(nsPresContext*          aPresContext,
+nsMathMLmtdInnerFrame::Reflow(nsPresContext*           aPresContext,
                               nsHTMLReflowMetrics&     aDesiredSize,
                               const nsHTMLReflowState& aReflowState,
                               nsReflowStatus&          aStatus)
 {
   // Let the base class do the reflow
   nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
 
   // more about <maligngroup/> and <malignmark/> later

--- a/layout/mathml/nsMathMLmtableFrame.h
+++ b/layout/mathml/nsMathMLmtableFrame.h
@@ -12,66 +12,69 @@
 #include "nsTableWrapperFrame.h"
 #include "nsTableRowFrame.h"
 #include "nsTableCellFrame.h"
 
 //
 // <mtable> -- table or matrix
 //
 
-class nsMathMLmtableOuterFrame : public nsTableWrapperFrame,
-                                 public nsMathMLFrame
+class nsMathMLmtableWrapperFrame : public nsTableWrapperFrame,
+                                   public nsMathMLFrame
 {
 public:
-  friend nsContainerFrame* NS_NewMathMLmtableOuterFrame(nsIPresShell* aPresShell,
-                                                        nsStyleContext* aContext);
+  friend nsContainerFrame*
+  NS_NewMathMLmtableOuterFrame(nsIPresShell*   aPresShell,
+                               nsStyleContext* aContext);
 
   NS_DECL_QUERYFRAME
   NS_DECL_FRAMEARENA_HELPERS
 
   // overloaded nsTableWrapperFrame methods
 
   virtual void
-  Reflow(nsPresContext*          aPresContext,
+  Reflow(nsPresContext*           aPresContext,
          nsHTMLReflowMetrics&     aDesiredSize,
          const nsHTMLReflowState& aReflowState,
          nsReflowStatus&          aStatus) override;
 
   virtual nsresult
   AttributeChanged(int32_t  aNameSpaceID,
                    nsIAtom* aAttribute,
                    int32_t  aModType) override;
 
   virtual bool IsFrameOfType(uint32_t aFlags) const override
   {
     return nsTableWrapperFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
   }
 
 protected:
-  explicit nsMathMLmtableOuterFrame(nsStyleContext* aContext) : nsTableWrapperFrame(aContext) {}
-  virtual ~nsMathMLmtableOuterFrame();
+  explicit nsMathMLmtableWrapperFrame(nsStyleContext* aContext)
+    : nsTableWrapperFrame(aContext) {}
+  virtual ~nsMathMLmtableWrapperFrame();
 
   // helper to find the row frame at a given index, positive or negative, e.g.,
   // 1..n means the first row down to the last row, -1..-n means the last row
   // up to the first row. Used for alignments that are relative to a given row
   nsIFrame*
   GetRowFrameAt(int32_t aRowIndex);
-}; // class nsMathMLmtableOuterFrame
+}; // class nsMathMLmtableWrapperFrame
 
 // --------------
 
 class nsMathMLmtableFrame : public nsTableFrame
 {
 public:
   NS_DECL_QUERYFRAME_TARGET(nsMathMLmtableFrame)
   NS_DECL_QUERYFRAME
   NS_DECL_FRAMEARENA_HELPERS
 
-  friend nsContainerFrame* NS_NewMathMLmtableFrame(nsIPresShell* aPresShell,
-                                                   nsStyleContext* aContext);
+  friend nsContainerFrame*
+  NS_NewMathMLmtableFrame(nsIPresShell*   aPresShell,
+                          nsStyleContext* aContext);
 
   // Overloaded nsTableFrame methods
 
   virtual void
   SetInitialChildList(ChildListID  aListID,
                       nsFrameList& aChildList) override;
 
   virtual void
@@ -87,18 +90,17 @@ public:
                nsIFrame* aPrevFrame,
                nsFrameList& aFrameList) override
   {
     nsTableFrame::InsertFrames(aListID, aPrevFrame, aFrameList);
     RestyleTable();
   }
 
   virtual void
-  RemoveFrame(ChildListID aListID,
-              nsIFrame* aOldFrame) override
+  RemoveFrame(ChildListID aListID, nsIFrame* aOldFrame) override
   {
     nsTableFrame::RemoveFrame(aListID, aOldFrame);
     RestyleTable();
   }
 
   virtual bool IsFrameOfType(uint32_t aFlags) const override
   {
     return nsTableFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
@@ -144,24 +146,21 @@ public:
   }
 
   /** Determines whether the placement of table cells is determined by CSS
    * spacing based on padding and border-spacing, or one based upon the
    * rowspacing, columnspacing and framespacing attributes.  The second
    * approach is used if the user specifies at least one of those attributes.
    */
   void SetUseCSSSpacing();
-
-  bool GetUseCSSSpacing()
-  {
-    return mUseCSSSpacing;
-  }
+  bool GetUseCSSSpacing() { return mUseCSSSpacing; }
 
 protected:
-  explicit nsMathMLmtableFrame(nsStyleContext* aContext) : nsTableFrame(aContext) {}
+  explicit nsMathMLmtableFrame(nsStyleContext* aContext)
+    : nsTableFrame(aContext) {}
   virtual ~nsMathMLmtableFrame();
 
 private:
   nsTArray<nscoord> mColSpacing;
   nsTArray<nscoord> mRowSpacing;
   nscoord mFrameSpacingX;
   nscoord mFrameSpacingY;
   bool mUseCSSSpacing;
@@ -169,18 +168,19 @@ private:
 
 // --------------
 
 class nsMathMLmtrFrame : public nsTableRowFrame
 {
 public:
   NS_DECL_FRAMEARENA_HELPERS
 
-  friend nsContainerFrame* NS_NewMathMLmtrFrame(nsIPresShell* aPresShell,
-                                                nsStyleContext* aContext);
+  friend nsContainerFrame*
+  NS_NewMathMLmtrFrame(nsIPresShell*   aPresShell,
+                       nsStyleContext* aContext);
 
   // overloaded nsTableRowFrame methods
 
   virtual nsresult
   AttributeChanged(int32_t  aNameSpaceID,
                    nsIAtom* aAttribute,
                    int32_t  aModType) override;
 
@@ -188,27 +188,26 @@ public:
   AppendFrames(ChildListID  aListID,
                nsFrameList& aFrameList) override
   {
     nsTableRowFrame::AppendFrames(aListID, aFrameList);
     RestyleTable();
   }
 
   virtual void
-  InsertFrames(ChildListID aListID,
-               nsIFrame* aPrevFrame,
+  InsertFrames(ChildListID  aListID,
+               nsIFrame*    aPrevFrame,
                nsFrameList& aFrameList) override
   {
     nsTableRowFrame::InsertFrames(aListID, aPrevFrame, aFrameList);
     RestyleTable();
   }
 
   virtual void
-  RemoveFrame(ChildListID aListID,
-              nsIFrame* aOldFrame) override
+  RemoveFrame(ChildListID aListID, nsIFrame* aOldFrame) override
   {
     nsTableRowFrame::RemoveFrame(aListID, aOldFrame);
     RestyleTable();
   }
 
   virtual bool IsFrameOfType(uint32_t aFlags) const override
   {
     return nsTableRowFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
@@ -220,45 +219,47 @@ public:
     nsTableFrame* tableFrame = GetTableFrame();
     if (tableFrame && tableFrame->IsFrameOfType(nsIFrame::eMathML)) {
       // relayout the table
       ((nsMathMLmtableFrame*)tableFrame)->RestyleTable();
     }
   }
 
 protected:
-  explicit nsMathMLmtrFrame(nsStyleContext* aContext) : nsTableRowFrame(aContext) {}
+  explicit nsMathMLmtrFrame(nsStyleContext* aContext)
+    : nsTableRowFrame(aContext) {}
   virtual ~nsMathMLmtrFrame();
 }; // class nsMathMLmtrFrame
 
 // --------------
 
 class nsMathMLmtdFrame : public nsTableCellFrame
 {
 public:
   NS_DECL_FRAMEARENA_HELPERS
 
-  friend nsContainerFrame* NS_NewMathMLmtdFrame(nsIPresShell* aPresShell,
-                                                nsStyleContext* aContext,
-                                                nsTableFrame* aTableFrame);
+  friend nsContainerFrame*
+  NS_NewMathMLmtdFrame(nsIPresShell*   aPresShell,
+                       nsStyleContext* aContext,
+                       nsTableFrame*   aTableFrame);
 
   // overloaded nsTableCellFrame methods
 
   virtual void Init(nsIContent*       aContent,
                     nsContainerFrame* aParent,
                     nsIFrame*         aPrevInFlow) override;
 
   virtual nsresult
   AttributeChanged(int32_t  aNameSpaceID,
                    nsIAtom* aAttribute,
                    int32_t  aModType) override;
 
   virtual uint8_t GetVerticalAlign() const override;
-  virtual nsresult ProcessBorders(nsTableFrame* aFrame,
-                                  nsDisplayListBuilder* aBuilder,
+  virtual nsresult ProcessBorders(nsTableFrame*           aFrame,
+                                  nsDisplayListBuilder*   aBuilder,
                                   const nsDisplayListSet& aLists) override;
 
   virtual int32_t GetRowSpan() override;
   virtual int32_t GetColSpan() override;
   virtual bool IsFrameOfType(uint32_t aFlags) const override
   {
     return nsTableCellFrame::IsFrameOfType(aFlags & ~(nsIFrame::eMathML));
   }
@@ -271,54 +272,59 @@ protected:
   nsMathMLmtdFrame(nsStyleContext* aContext, nsTableFrame* aTableFrame)
     : nsTableCellFrame(aContext, aTableFrame) {}
   virtual ~nsMathMLmtdFrame();
 }; // class nsMathMLmtdFrame
 
 // --------------
 
 class nsMathMLmtdInnerFrame : public nsBlockFrame,
-                              public nsMathMLFrame {
+                              public nsMathMLFrame
+{
 public:
-  friend nsContainerFrame* NS_NewMathMLmtdInnerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
+  friend nsContainerFrame*
+  NS_NewMathMLmtdInnerFrame(nsIPresShell*   aPresShell,
+                            nsStyleContext* aContext);
 
   NS_DECL_QUERYFRAME
   NS_DECL_FRAMEARENA_HELPERS
 
   // Overloaded nsIMathMLFrame methods
 
   NS_IMETHOD
-  UpdatePresentationDataFromChildAt(int32_t         aFirstIndex,
-                                    int32_t         aLastIndex,
-                                    uint32_t        aFlagsValues,
-                                    uint32_t        aFlagsToUpdate) override
+  UpdatePresentationDataFromChildAt(int32_t  aFirstIndex,
+                                    int32_t  aLastIndex,
+                                    uint32_t aFlagsValues,
+                                    uint32_t aFlagsToUpdate) override
   {
     nsMathMLContainerFrame::PropagatePresentationDataFromChildAt(this,
       aFirstIndex, aLastIndex, aFlagsValues, aFlagsToUpdate);
     return NS_OK;
   }
 
   virtual void
-  Reflow(nsPresContext*          aPresContext,
+  Reflow(nsPresContext*           aPresContext,
          nsHTMLReflowMetrics&     aDesiredSize,
          const nsHTMLReflowState& aReflowState,
          nsReflowStatus&          aStatus) override;
 
   virtual bool IsFrameOfType(uint32_t aFlags) const override
   {
     return nsBlockFrame::IsFrameOfType(aFlags &
       ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace));
   }
 
   virtual const nsStyleText* StyleTextForLineLayout() override;
   virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) override;
 
   bool
-  IsMrowLike() override {
-    return mFrames.FirstChild() != mFrames.LastChild() ||
+  IsMrowLike() override
+  {
+    return mFrames.FirstChild() !=
+           mFrames.LastChild() ||
            !mFrames.FirstChild();
   }
 
 protected:
   explicit nsMathMLmtdInnerFrame(nsStyleContext* aContext);
   virtual ~nsMathMLmtdInnerFrame();
 
   nsStyleText* mUniqueStyleText;