Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 630 insertions, 0 deletions

diff --git a/layout/mathml/nsMathMLmmultiscriptsFrame.cpp b/layout/mathml/nsMathMLmmultiscriptsFrame.cpp
new file mode 100644
index 0000000000..fdc9743792
--- /dev/null
+++ b/layout/mathml/nsMathMLmmultiscriptsFrame.cpp
@@ -0,0 +1,630 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 "nsMathMLmmultiscriptsFrame.h"
+
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_mathml.h"
+#include "nsLayoutUtils.h"
+#include "nsPresContext.h"
+#include <algorithm>
+#include "gfxContext.h"
+#include "gfxMathTable.h"
+#include "gfxTextRun.h"
+
+using namespace mozilla;
+
+//
+// <mmultiscripts> -- attach prescripts and tensor indices to a base -
+// implementation <msub> -- attach a subscript to a base - implementation
+// <msubsup> -- attach a subscript-superscript pair to a base - implementation
+// <msup> -- attach a superscript to a base - implementation
+//
+
+nsIFrame* NS_NewMathMLmmultiscriptsFrame(PresShell* aPresShell,
+                                         ComputedStyle* aStyle) {
+  return new (aPresShell)
+      nsMathMLmmultiscriptsFrame(aStyle, aPresShell->GetPresContext());
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmmultiscriptsFrame)
+
+nsMathMLmmultiscriptsFrame::~nsMathMLmmultiscriptsFrame() = default;
+
+uint8_t nsMathMLmmultiscriptsFrame::ScriptIncrement(nsIFrame* aFrame) {
+  if (!aFrame) return 0;
+  if (mFrames.ContainsFrame(aFrame)) {
+    if (mFrames.FirstChild() == aFrame ||
+        aFrame->GetContent()->IsMathMLElement(nsGkAtoms::mprescripts_)) {
+      return 0;  // No script increment for base frames or prescript markers
+    }
+    return 1;
+  }
+  return 0;  // not a child
+}
+
+NS_IMETHODIMP
+nsMathMLmmultiscriptsFrame::TransmitAutomaticData() {
+  // if our base is an embellished operator, let its state bubble to us
+  mPresentationData.baseFrame = mFrames.FirstChild();
+  GetEmbellishDataFrom(mPresentationData.baseFrame, mEmbellishData);
+
+  // The TeXbook (Ch 17. p.141) says the superscript inherits the compression
+  // while the subscript is compressed. So here we collect subscripts and set
+  // the compression flag in them.
+
+  int32_t count = 0;
+  bool isSubScript = !mContent->IsMathMLElement(nsGkAtoms::msup_);
+
+  AutoTArray<nsIFrame*, 8> subScriptFrames;
+  nsIFrame* childFrame = mFrames.FirstChild();
+  while (childFrame) {
+    if (childFrame->GetContent()->IsMathMLElement(nsGkAtoms::mprescripts_)) {
+      // mprescripts frame
+    } else if (0 == count) {
+      // base frame
+    } else {
+      // super/subscript block
+      if (isSubScript) {
+        // subscript
+        subScriptFrames.AppendElement(childFrame);
+      } else {
+        // superscript
+      }
+      PropagateFrameFlagFor(childFrame, NS_FRAME_MATHML_SCRIPT_DESCENDANT);
+      isSubScript = !isSubScript;
+    }
+    count++;
+    childFrame = childFrame->GetNextSibling();
+  }
+  for (int32_t i = subScriptFrames.Length() - 1; i >= 0; i--) {
+    childFrame = subScriptFrames[i];
+    PropagatePresentationDataFor(childFrame, NS_MATHML_COMPRESSED,
+                                 NS_MATHML_COMPRESSED);
+  }
+
+  return NS_OK;
+}
+
+/* virtual */
+nsresult nsMathMLmmultiscriptsFrame::Place(DrawTarget* aDrawTarget,
+                                           bool aPlaceOrigin,
+                                           ReflowOutput& aDesiredSize) {
+  nscoord subScriptShift = 0;
+  nscoord supScriptShift = 0;
+  float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
+
+  return PlaceMultiScript(PresContext(), aDrawTarget, aPlaceOrigin,
+                          aDesiredSize, this, subScriptShift, supScriptShift,
+                          fontSizeInflation);
+}
+
+// exported routine that both munderover and mmultiscripts share.
+// munderover uses this when movablelimits is set.
+nsresult nsMathMLmmultiscriptsFrame::PlaceMultiScript(
+    nsPresContext* aPresContext, DrawTarget* aDrawTarget, bool aPlaceOrigin,
+    ReflowOutput& aDesiredSize, nsMathMLContainerFrame* aFrame,
+    nscoord aUserSubScriptShift, nscoord aUserSupScriptShift,
+    float aFontSizeInflation) {
+  nsAtom* tag = aFrame->GetContent()->NodeInfo()->NameAtom();
+
+  // This function deals with both munderover etc. as well as msubsup etc.
+  // As the former behaves identically to the later, we treat it as such
+  // to avoid additional checks later.
+  if (aFrame->GetContent()->IsMathMLElement(nsGkAtoms::mover_))
+    tag = nsGkAtoms::msup_;
+  else if (aFrame->GetContent()->IsMathMLElement(nsGkAtoms::munder_))
+    tag = nsGkAtoms::msub_;
+  else if (aFrame->GetContent()->IsMathMLElement(nsGkAtoms::munderover_))
+    tag = nsGkAtoms::msubsup_;
+
+  nsBoundingMetrics bmFrame;
+
+  nscoord minShiftFromXHeight, subDrop, supDrop;
+
+  ////////////////////////////////////////
+  // Initialize super/sub shifts that
+  // depend only on the current font
+  ////////////////////////////////////////
+
+  nsIFrame* baseFrame = aFrame->PrincipalChildList().FirstChild();
+
+  if (!baseFrame) {
+    if (tag == nsGkAtoms::mmultiscripts_)
+      aFrame->ReportErrorToConsole("NoBase");
+    else
+      aFrame->ReportChildCountError();
+    return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
+  }
+
+  // get x-height (an ex)
+  const nsStyleFont* font = aFrame->StyleFont();
+  RefPtr<nsFontMetrics> fm =
+      nsLayoutUtils::GetFontMetricsForFrame(baseFrame, aFontSizeInflation);
+
+  nscoord xHeight = fm->XHeight();
+
+  nscoord oneDevPixel = fm->AppUnitsPerDevPixel();
+  RefPtr<gfxFont> mathFont = fm->GetThebesFontGroup()->GetFirstMathFont();
+  // scriptspace from TeX for extra spacing after sup/subscript
+  nscoord scriptSpace;
+  if (mathFont) {
+    scriptSpace = mathFont->MathTable()->Constant(
+        gfxMathTable::SpaceAfterScript, oneDevPixel);
+  } else {
+    // (0.5pt in plain TeX)
+    scriptSpace = nsPresContext::CSSPointsToAppUnits(0.5f);
+  }
+
+  // Try and read sub and sup drops from the MATH table.
+  if (mathFont) {
+    subDrop = mathFont->MathTable()->Constant(
+        gfxMathTable::SubscriptBaselineDropMin, oneDevPixel);
+    supDrop = mathFont->MathTable()->Constant(
+        gfxMathTable::SuperscriptBaselineDropMax, oneDevPixel);
+  }
+
+  // force the scriptSpace to be at least 1 pixel
+  nscoord onePixel = nsPresContext::CSSPixelsToAppUnits(1);
+  scriptSpace = std::max(onePixel, scriptSpace);
+
+  /////////////////////////////////////
+  // first the shift for the subscript
+
+  nscoord subScriptShift;
+  if (mathFont) {
+    // Try and get the sub script shift from the MATH table. Note that contrary
+    // to TeX we only have one parameter.
+    subScriptShift = mathFont->MathTable()->Constant(
+        gfxMathTable::SubscriptShiftDown, oneDevPixel);
+  } else {
+    // subScriptShift{1,2}
+    // = minimum amount to shift the subscript down
+    // = sub{1,2} in TeXbook
+    // subScriptShift1 = subscriptshift attribute * x-height
+    nscoord subScriptShift1, subScriptShift2;
+    // Get subScriptShift{1,2} default from font
+    GetSubScriptShifts(fm, subScriptShift1, subScriptShift2);
+    if (tag == nsGkAtoms::msub_) {
+      subScriptShift = subScriptShift1;
+    } else {
+      subScriptShift = std::max(subScriptShift1, subScriptShift2);
+    }
+  }
+
+  if (0 < aUserSubScriptShift) {
+    // the user has set the subscriptshift attribute
+    subScriptShift = std::max(subScriptShift, aUserSubScriptShift);
+  }
+
+  /////////////////////////////////////
+  // next the shift for the superscript
+
+  nscoord supScriptShift;
+  nsPresentationData presentationData;
+  aFrame->GetPresentationData(presentationData);
+  if (mathFont) {
+    // Try and get the super script shift from the MATH table. Note that
+    // contrary to TeX we only have two parameters.
+    supScriptShift = mathFont->MathTable()->Constant(
+        NS_MATHML_IS_COMPRESSED(presentationData.flags)
+            ? gfxMathTable::SuperscriptShiftUpCramped
+            : gfxMathTable::SuperscriptShiftUp,
+        oneDevPixel);
+  } else {
+    // supScriptShift{1,2,3}
+    // = minimum amount to shift the supscript up
+    // = sup{1,2,3} in TeX
+    // supScriptShift1 = superscriptshift attribute * x-height
+    // Note that there are THREE values for supscript shifts depending
+    // on the current style
+    nscoord supScriptShift1, supScriptShift2, supScriptShift3;
+    // Set supScriptShift{1,2,3} default from font
+    GetSupScriptShifts(fm, supScriptShift1, supScriptShift2, supScriptShift3);
+
+    // get sup script shift depending on current script level and display style
+    // Rule 18c, App. G, TeXbook
+    if (font->mMathDepth == 0 && font->mMathStyle == StyleMathStyle::Normal &&
+        !NS_MATHML_IS_COMPRESSED(presentationData.flags)) {
+      // Style D in TeXbook
+      supScriptShift = supScriptShift1;
+    } else if (NS_MATHML_IS_COMPRESSED(presentationData.flags)) {
+      // Style C' in TeXbook = D',T',S',SS'
+      supScriptShift = supScriptShift3;
+    } else {
+      // everything else = T,S,SS
+      supScriptShift = supScriptShift2;
+    }
+  }
+
+  if (0 < aUserSupScriptShift) {
+    // the user has set the supscriptshift attribute
+    supScriptShift = std::max(supScriptShift, aUserSupScriptShift);
+  }
+
+  ////////////////////////////////////
+  // Get the children's sizes
+  ////////////////////////////////////
+
+  const WritingMode wm(aDesiredSize.GetWritingMode());
+  nscoord width = 0, prescriptsWidth = 0, rightBearing = 0;
+  nscoord minSubScriptShift = 0, minSupScriptShift = 0;
+  nscoord trySubScriptShift = subScriptShift;
+  nscoord trySupScriptShift = supScriptShift;
+  nscoord maxSubScriptShift = subScriptShift;
+  nscoord maxSupScriptShift = supScriptShift;
+  ReflowOutput baseSize(wm);
+  ReflowOutput subScriptSize(wm);
+  ReflowOutput supScriptSize(wm);
+  ReflowOutput multiSubSize(wm), multiSupSize(wm);
+  baseFrame = nullptr;
+  nsIFrame* subScriptFrame = nullptr;
+  nsIFrame* supScriptFrame = nullptr;
+  nsIFrame* prescriptsFrame = nullptr;  // frame of <mprescripts/>, if there.
+
+  bool firstPrescriptsPair = false;
+  nsBoundingMetrics bmBase, bmSubScript, bmSupScript, bmMultiSub, bmMultiSup;
+  multiSubSize.SetBlockStartAscent(-0x7FFFFFFF);
+  multiSupSize.SetBlockStartAscent(-0x7FFFFFFF);
+  bmMultiSub.ascent = bmMultiSup.ascent = -0x7FFFFFFF;
+  bmMultiSub.descent = bmMultiSup.descent = -0x7FFFFFFF;
+  nscoord italicCorrection = 0;
+
+  nsBoundingMetrics boundingMetrics;
+  boundingMetrics.width = 0;
+  boundingMetrics.ascent = boundingMetrics.descent = -0x7FFFFFFF;
+  aDesiredSize.Width() = aDesiredSize.Height() = 0;
+
+  int32_t count = 0;
+
+  // Boolean to determine whether the current child is a subscript.
+  // Note that only msup starts with a superscript.
+  bool isSubScript = (tag != nsGkAtoms::msup_);
+
+  nsIFrame* childFrame = aFrame->PrincipalChildList().FirstChild();
+  while (childFrame) {
+    if (childFrame->GetContent()->IsMathMLElement(nsGkAtoms::mprescripts_)) {
+      if (tag != nsGkAtoms::mmultiscripts_) {
+        if (aPlaceOrigin) {
+          aFrame->ReportInvalidChildError(nsGkAtoms::mprescripts_);
+        }
+        return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
+      }
+      if (prescriptsFrame) {
+        // duplicate <mprescripts/> found
+        // report an error, encourage people to get their markups in order
+        if (aPlaceOrigin) {
+          aFrame->ReportErrorToConsole("DuplicateMprescripts");
+        }
+        return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
+      }
+      if (!isSubScript) {
+        if (aPlaceOrigin) {
+          aFrame->ReportErrorToConsole("SubSupMismatch");
+        }
+        return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
+      }
+
+      prescriptsFrame = childFrame;
+      firstPrescriptsPair = true;
+    } else if (0 == count) {
+      // base
+      baseFrame = childFrame;
+      GetReflowAndBoundingMetricsFor(baseFrame, baseSize, bmBase);
+
+      if (tag != nsGkAtoms::msub_) {
+        // Apply italics correction if there is the potential for a
+        // postsupscript.
+        GetItalicCorrection(bmBase, italicCorrection);
+        // If italics correction is applied, we always add "a little to spare"
+        // (see TeXbook Ch.11, p.64), as we estimate the italic creation
+        // ourselves and it isn't the same as TeX.
+        italicCorrection += onePixel;
+      }
+
+      // we update boundingMetrics.{ascent,descent} with that
+      // of the baseFrame only after processing all the sup/sub pairs
+      boundingMetrics.width = bmBase.width;
+      boundingMetrics.rightBearing = bmBase.rightBearing;
+      boundingMetrics.leftBearing = bmBase.leftBearing;  // until overwritten
+    } else {
+      // super/subscript block
+      if (isSubScript) {
+        // subscript
+        subScriptFrame = childFrame;
+        GetReflowAndBoundingMetricsFor(subScriptFrame, subScriptSize,
+                                       bmSubScript);
+        if (!mathFont) {
+          // get the subdrop from the subscript font
+          GetSubDropFromChild(subScriptFrame, subDrop, aFontSizeInflation);
+        }
+
+        // parameter v, Rule 18a, App. G, TeXbook
+        minSubScriptShift = bmBase.descent + subDrop;
+        trySubScriptShift = std::max(minSubScriptShift, subScriptShift);
+        multiSubSize.SetBlockStartAscent(std::max(
+            multiSubSize.BlockStartAscent(), subScriptSize.BlockStartAscent()));
+        bmMultiSub.ascent = std::max(bmMultiSub.ascent, bmSubScript.ascent);
+        bmMultiSub.descent = std::max(bmMultiSub.descent, bmSubScript.descent);
+        multiSubSize.Height() =
+            std::max(multiSubSize.Height(),
+                     subScriptSize.Height() - subScriptSize.BlockStartAscent());
+        if (bmSubScript.width) width = bmSubScript.width + scriptSpace;
+        rightBearing = bmSubScript.rightBearing;
+
+        if (tag == nsGkAtoms::msub_) {
+          boundingMetrics.rightBearing = boundingMetrics.width + rightBearing;
+          boundingMetrics.width += width;
+
+          nscoord subscriptTopMax;
+          if (mathFont) {
+            subscriptTopMax = mathFont->MathTable()->Constant(
+                gfxMathTable::SubscriptTopMax, oneDevPixel);
+          } else {
+            // get min subscript shift limit from x-height
+            // = h(x) - 4/5 * sigma_5, Rule 18b, App. G, TeXbook
+            subscriptTopMax = NSToCoordRound((4.0f / 5.0f) * xHeight);
+          }
+          nscoord minShiftFromXHeight = bmSubScript.ascent - subscriptTopMax;
+          maxSubScriptShift = std::max(trySubScriptShift, minShiftFromXHeight);
+
+          maxSubScriptShift = std::max(maxSubScriptShift, trySubScriptShift);
+          trySubScriptShift = subScriptShift;
+        }
+      } else {
+        // supscript
+        supScriptFrame = childFrame;
+        GetReflowAndBoundingMetricsFor(supScriptFrame, supScriptSize,
+                                       bmSupScript);
+        if (!mathFont) {
+          // get the supdrop from the supscript font
+          GetSupDropFromChild(supScriptFrame, supDrop, aFontSizeInflation);
+        }
+        // parameter u, Rule 18a, App. G, TeXbook
+        minSupScriptShift = bmBase.ascent - supDrop;
+        nscoord superscriptBottomMin;
+        if (mathFont) {
+          superscriptBottomMin = mathFont->MathTable()->Constant(
+              gfxMathTable::SuperscriptBottomMin, oneDevPixel);
+        } else {
+          // get min supscript shift limit from x-height
+          // = d(x) + 1/4 * sigma_5, Rule 18c, App. G, TeXbook
+          superscriptBottomMin = NSToCoordRound((1.0f / 4.0f) * xHeight);
+        }
+        minShiftFromXHeight = bmSupScript.descent + superscriptBottomMin;
+        trySupScriptShift = std::max(
+            minSupScriptShift, std::max(minShiftFromXHeight, supScriptShift));
+        multiSupSize.SetBlockStartAscent(std::max(
+            multiSupSize.BlockStartAscent(), supScriptSize.BlockStartAscent()));
+        bmMultiSup.ascent = std::max(bmMultiSup.ascent, bmSupScript.ascent);
+        bmMultiSup.descent = std::max(bmMultiSup.descent, bmSupScript.descent);
+        multiSupSize.Height() =
+            std::max(multiSupSize.Height(),
+                     supScriptSize.Height() - supScriptSize.BlockStartAscent());
+
+        if (bmSupScript.width)
+          width = std::max(width, bmSupScript.width + scriptSpace);
+
+        if (!prescriptsFrame) {  // we are still looping over base & postscripts
+          rightBearing = std::max(rightBearing,
+                                  italicCorrection + bmSupScript.rightBearing);
+          boundingMetrics.rightBearing = boundingMetrics.width + rightBearing;
+          boundingMetrics.width += width;
+        } else {
+          prescriptsWidth += width;
+          if (firstPrescriptsPair) {
+            firstPrescriptsPair = false;
+            boundingMetrics.leftBearing =
+                std::min(bmSubScript.leftBearing, bmSupScript.leftBearing);
+          }
+        }
+        width = rightBearing = 0;
+
+        // negotiate between the various shifts so that
+        // there is enough gap between the sup and subscripts
+        // Rule 18e, App. G, TeXbook
+        if (tag == nsGkAtoms::mmultiscripts_ || tag == nsGkAtoms::msubsup_) {
+          nscoord subSuperscriptGapMin;
+          if (mathFont) {
+            subSuperscriptGapMin = mathFont->MathTable()->Constant(
+                gfxMathTable::SubSuperscriptGapMin, oneDevPixel);
+          } else {
+            nscoord ruleSize;
+            GetRuleThickness(aDrawTarget, fm, ruleSize);
+            subSuperscriptGapMin = 4 * ruleSize;
+          }
+          nscoord gap = (trySupScriptShift - bmSupScript.descent) -
+                        (bmSubScript.ascent - trySubScriptShift);
+          if (gap < subSuperscriptGapMin) {
+            // adjust trySubScriptShift to get a gap of subSuperscriptGapMin
+            trySubScriptShift += subSuperscriptGapMin - gap;
+          }
+
+          // next we want to ensure that the bottom of the superscript
+          // will be > superscriptBottomMaxWithSubscript
+          nscoord superscriptBottomMaxWithSubscript;
+          if (mathFont) {
+            superscriptBottomMaxWithSubscript = mathFont->MathTable()->Constant(
+                gfxMathTable::SuperscriptBottomMaxWithSubscript, oneDevPixel);
+          } else {
+            superscriptBottomMaxWithSubscript =
+                NSToCoordRound((4.0f / 5.0f) * xHeight);
+          }
+          gap = superscriptBottomMaxWithSubscript -
+                (trySupScriptShift - bmSupScript.descent);
+          if (gap > 0) {
+            trySupScriptShift += gap;
+            trySubScriptShift -= gap;
+          }
+        }
+
+        maxSubScriptShift = std::max(maxSubScriptShift, trySubScriptShift);
+        maxSupScriptShift = std::max(maxSupScriptShift, trySupScriptShift);
+
+        trySubScriptShift = subScriptShift;
+        trySupScriptShift = supScriptShift;
+      }
+
+      isSubScript = !isSubScript;
+    }
+    count++;
+    childFrame = childFrame->GetNextSibling();
+  }
+
+  // NoBase error may also have been reported above
+  if ((count != 2 && (tag == nsGkAtoms::msup_ || tag == nsGkAtoms::msub_)) ||
+      (count != 3 && tag == nsGkAtoms::msubsup_) || !baseFrame ||
+      (!isSubScript && tag == nsGkAtoms::mmultiscripts_)) {
+    // report an error, encourage people to get their markups in order
+    if (aPlaceOrigin) {
+      if ((count != 2 &&
+           (tag == nsGkAtoms::msup_ || tag == nsGkAtoms::msub_)) ||
+          (count != 3 && tag == nsGkAtoms::msubsup_)) {
+        aFrame->ReportChildCountError();
+      } else if (!baseFrame) {
+        aFrame->ReportErrorToConsole("NoBase");
+      } else {
+        aFrame->ReportErrorToConsole("SubSupMismatch");
+      }
+    }
+    return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
+  }
+
+  // we left out the width of prescripts, so ...
+  boundingMetrics.rightBearing += prescriptsWidth;
+  boundingMetrics.width += prescriptsWidth;
+
+  // Zero out the shifts in where a frame isn't present to avoid the potential
+  // for overflow.
+  if (!subScriptFrame) maxSubScriptShift = 0;
+  if (!supScriptFrame) maxSupScriptShift = 0;
+
+  // we left out the base during our bounding box updates, so ...
+  if (tag == nsGkAtoms::msub_) {
+    boundingMetrics.ascent =
+        std::max(bmBase.ascent, bmMultiSub.ascent - maxSubScriptShift);
+  } else {
+    boundingMetrics.ascent =
+        std::max(bmBase.ascent, (bmMultiSup.ascent + maxSupScriptShift));
+  }
+  if (tag == nsGkAtoms::msup_) {
+    boundingMetrics.descent =
+        std::max(bmBase.descent, bmMultiSup.descent - maxSupScriptShift);
+  } else {
+    boundingMetrics.descent =
+        std::max(bmBase.descent, (bmMultiSub.descent + maxSubScriptShift));
+  }
+  aFrame->SetBoundingMetrics(boundingMetrics);
+
+  // get the reflow metrics ...
+  aDesiredSize.SetBlockStartAscent(
+      std::max(baseSize.BlockStartAscent(),
+               std::max(multiSubSize.BlockStartAscent() - maxSubScriptShift,
+                        multiSupSize.BlockStartAscent() + maxSupScriptShift)));
+  aDesiredSize.Height() =
+      aDesiredSize.BlockStartAscent() +
+      std::max(baseSize.Height() - baseSize.BlockStartAscent(),
+               std::max(multiSubSize.Height() + maxSubScriptShift,
+                        multiSupSize.Height() - maxSupScriptShift));
+  aDesiredSize.Width() = boundingMetrics.width;
+  aDesiredSize.mBoundingMetrics = boundingMetrics;
+
+  aFrame->SetReference(nsPoint(0, aDesiredSize.BlockStartAscent()));
+
+  //////////////////
+  // Place Children
+
+  // Place prescripts, followed by base, and then postscripts.
+  // The list of frames is in the order: {base} {postscripts} {prescripts}
+  // We go over the list in a circular manner, starting at <prescripts/>
+
+  if (aPlaceOrigin) {
+    nscoord dx = 0, dy = 0;
+
+    // With msub and msup there is only one element and
+    // subscriptFrame/supScriptFrame have already been set above where
+    // relevant.  In these cases we skip to the reflow part.
+    if (tag == nsGkAtoms::msub_ || tag == nsGkAtoms::msup_)
+      count = 1;
+    else
+      count = 0;
+    childFrame = prescriptsFrame;
+    bool isPreScript = true;
+    do {
+      if (!childFrame) {  // end of prescripts,
+        isPreScript = false;
+        // place the base ...
+        childFrame = baseFrame;
+        dy = aDesiredSize.BlockStartAscent() - baseSize.BlockStartAscent();
+        FinishReflowChild(
+            baseFrame, aPresContext, baseSize, nullptr,
+            aFrame->MirrorIfRTL(aDesiredSize.Width(), baseSize.Width(), dx), dy,
+            ReflowChildFlags::Default);
+        dx += bmBase.width;
+      } else if (prescriptsFrame == childFrame) {
+        // Clear reflow flags of prescripts frame.
+        prescriptsFrame->DidReflow(aPresContext, nullptr);
+      } else {
+        // process each sup/sub pair
+        if (0 == count) {
+          subScriptFrame = childFrame;
+          count = 1;
+        } else if (1 == count) {
+          if (tag != nsGkAtoms::msub_) supScriptFrame = childFrame;
+          count = 0;
+
+          // get the ascent/descent of sup/subscripts stored in their rects
+          // rect.x = descent, rect.y = ascent
+          if (subScriptFrame)
+            GetReflowAndBoundingMetricsFor(subScriptFrame, subScriptSize,
+                                           bmSubScript);
+          if (supScriptFrame)
+            GetReflowAndBoundingMetricsFor(supScriptFrame, supScriptSize,
+                                           bmSupScript);
+
+          width = std::max(subScriptSize.Width(), supScriptSize.Width());
+
+          if (subScriptFrame) {
+            nscoord x = dx;
+            // prescripts should be right aligned
+            // https://bugzilla.mozilla.org/show_bug.cgi?id=928675
+            if (isPreScript) x += width - subScriptSize.Width();
+            dy = aDesiredSize.BlockStartAscent() -
+                 subScriptSize.BlockStartAscent() + maxSubScriptShift;
+            FinishReflowChild(subScriptFrame, aPresContext, subScriptSize,
+                              nullptr,
+                              aFrame->MirrorIfRTL(aDesiredSize.Width(),
+                                                  subScriptSize.Width(), x),
+                              dy, ReflowChildFlags::Default);
+          }
+
+          if (supScriptFrame) {
+            nscoord x = dx;
+            if (isPreScript) {
+              x += width - supScriptSize.Width();
+            } else {
+              // post superscripts are shifted by the italic correction value
+              x += italicCorrection;
+            }
+            dy = aDesiredSize.BlockStartAscent() -
+                 supScriptSize.BlockStartAscent() - maxSupScriptShift;
+            FinishReflowChild(supScriptFrame, aPresContext, supScriptSize,
+                              nullptr,
+                              aFrame->MirrorIfRTL(aDesiredSize.Width(),
+                                                  supScriptSize.Width(), x),
+                              dy, ReflowChildFlags::Default);
+          }
+          dx += width + scriptSpace;
+        }
+      }
+      childFrame = childFrame->GetNextSibling();
+    } while (prescriptsFrame != childFrame);
+  }
+
+  return NS_OK;
+}