Add m-esr52 at 52.6.0

1 files changed, 449 insertions, 0 deletions

diff --git a/layout/mathml/nsMathMLmpaddedFrame.cpp b/layout/mathml/nsMathMLmpaddedFrame.cpp
new file mode 100644
index 000000000..5b2e8282f
--- /dev/null
+++ b/layout/mathml/nsMathMLmpaddedFrame.cpp
@@ -0,0 +1,449 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "nsMathMLmpaddedFrame.h"
+#include "nsMathMLElement.h"
+#include "mozilla/gfx/2D.h"
+#include <algorithm>
+
+//
+// <mpadded> -- adjust space around content - implementation
+//
+
+#define NS_MATHML_SIGN_INVALID           -1 // if the attribute is not there
+#define NS_MATHML_SIGN_UNSPECIFIED        0
+#define NS_MATHML_SIGN_MINUS              1
+#define NS_MATHML_SIGN_PLUS               2
+
+#define NS_MATHML_PSEUDO_UNIT_UNSPECIFIED 0
+#define NS_MATHML_PSEUDO_UNIT_ITSELF      1 // special
+#define NS_MATHML_PSEUDO_UNIT_WIDTH       2
+#define NS_MATHML_PSEUDO_UNIT_HEIGHT      3
+#define NS_MATHML_PSEUDO_UNIT_DEPTH       4
+#define NS_MATHML_PSEUDO_UNIT_NAMEDSPACE  5
+
+nsIFrame*
+NS_NewMathMLmpaddedFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  return new (aPresShell) nsMathMLmpaddedFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmpaddedFrame)
+
+nsMathMLmpaddedFrame::~nsMathMLmpaddedFrame()
+{
+}
+
+NS_IMETHODIMP
+nsMathMLmpaddedFrame::InheritAutomaticData(nsIFrame* aParent) 
+{
+  // let the base class get the default from our parent
+  nsMathMLContainerFrame::InheritAutomaticData(aParent);
+
+  mPresentationData.flags |= NS_MATHML_STRETCH_ALL_CHILDREN_VERTICALLY;
+
+  return NS_OK;
+}
+
+void
+nsMathMLmpaddedFrame::ProcessAttributes()
+{
+  /*
+  parse the attributes
+
+  width  = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
+  height = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
+  depth  = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
+  lspace = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
+  voffset= [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
+  */
+
+  nsAutoString value;
+
+  // width
+  mWidthSign = NS_MATHML_SIGN_INVALID;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::width, value);
+  if (!value.IsEmpty()) {
+    if (!ParseAttribute(value, mWidthSign, mWidth, mWidthPseudoUnit)) {      
+      ReportParseError(nsGkAtoms::width->GetUTF16String(), value.get());
+    }
+  }
+
+  // height
+  mHeightSign = NS_MATHML_SIGN_INVALID;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::height, value);
+  if (!value.IsEmpty()) {
+    if (!ParseAttribute(value, mHeightSign, mHeight, mHeightPseudoUnit)) {
+      ReportParseError(nsGkAtoms::height->GetUTF16String(), value.get());
+    }
+  }
+
+  // depth
+  mDepthSign = NS_MATHML_SIGN_INVALID;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::depth_, value);
+  if (!value.IsEmpty()) {
+    if (!ParseAttribute(value, mDepthSign, mDepth, mDepthPseudoUnit)) {
+      ReportParseError(nsGkAtoms::depth_->GetUTF16String(), value.get());
+    }
+  }
+
+  // lspace
+  mLeadingSpaceSign = NS_MATHML_SIGN_INVALID;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::lspace_, value);
+  if (!value.IsEmpty()) {
+    if (!ParseAttribute(value, mLeadingSpaceSign, mLeadingSpace, 
+                        mLeadingSpacePseudoUnit)) {
+      ReportParseError(nsGkAtoms::lspace_->GetUTF16String(), value.get());
+    }
+  }
+
+  // voffset
+  mVerticalOffsetSign = NS_MATHML_SIGN_INVALID;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::voffset_, value);
+  if (!value.IsEmpty()) {
+    if (!ParseAttribute(value, mVerticalOffsetSign, mVerticalOffset,
+                        mVerticalOffsetPseudoUnit)) {
+      ReportParseError(nsGkAtoms::voffset_->GetUTF16String(), value.get());
+    }
+  }
+  
+}
+
+// parse an input string in the following format (see bug 148326 for testcases):
+// [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | css-unit | namedspace)
+bool
+nsMathMLmpaddedFrame::ParseAttribute(nsString&   aString,
+                                     int32_t&    aSign,
+                                     nsCSSValue& aCSSValue,
+                                     int32_t&    aPseudoUnit)
+{
+  aCSSValue.Reset();
+  aSign = NS_MATHML_SIGN_INVALID;
+  aPseudoUnit = NS_MATHML_PSEUDO_UNIT_UNSPECIFIED;
+  aString.CompressWhitespace(); // aString is not a const in this code
+
+  int32_t stringLength = aString.Length();
+  if (!stringLength)
+    return false;
+
+  nsAutoString number, unit;
+
+  //////////////////////
+  // see if the sign is there
+
+  int32_t i = 0;
+
+  if (aString[0] == '+') {
+    aSign = NS_MATHML_SIGN_PLUS;
+    i++;
+  }
+  else if (aString[0] == '-') {
+    aSign = NS_MATHML_SIGN_MINUS;
+    i++;
+  }
+  else
+    aSign = NS_MATHML_SIGN_UNSPECIFIED;
+
+  // get the number
+  bool gotDot = false, gotPercent = false;
+  for (; i < stringLength; i++) {
+    char16_t c = aString[i];
+    if (gotDot && c == '.') {
+      // error - two dots encountered
+      aSign = NS_MATHML_SIGN_INVALID;
+      return false;
+    }
+
+    if (c == '.')
+      gotDot = true;
+    else if (!nsCRT::IsAsciiDigit(c)) {
+      break;
+    }
+    number.Append(c);
+  }
+
+  // catch error if we didn't enter the loop above... we could simply initialize
+  // floatValue = 1, to cater for cases such as width="height", but that wouldn't
+  // be in line with the spec which requires an explicit number
+  if (number.IsEmpty()) {
+    aSign = NS_MATHML_SIGN_INVALID;
+    return false;
+  }
+
+  nsresult errorCode;
+  float floatValue = number.ToFloat(&errorCode);
+  if (NS_FAILED(errorCode)) {
+    aSign = NS_MATHML_SIGN_INVALID;
+    return false;
+  }
+
+  // see if this is a percentage-based value
+  if (i < stringLength && aString[i] == '%') {
+    i++;
+    gotPercent = true;
+  }
+
+  // the remainder now should be a css-unit, or a pseudo-unit, or a named-space
+  aString.Right(unit, stringLength - i);
+
+  if (unit.IsEmpty()) {
+    if (gotPercent) {
+      // case ["+"|"-"] unsigned-number "%" 
+      aCSSValue.SetPercentValue(floatValue / 100.0f);
+      aPseudoUnit = NS_MATHML_PSEUDO_UNIT_ITSELF;
+      return true;
+    } else {
+      // case ["+"|"-"] unsigned-number
+      // XXXfredw: should we allow non-zero unitless values? See bug 757703.
+      if (!floatValue) {
+        aCSSValue.SetFloatValue(floatValue, eCSSUnit_Number);
+        aPseudoUnit = NS_MATHML_PSEUDO_UNIT_ITSELF;
+        return true;
+      }
+    }
+  }
+  else if (unit.EqualsLiteral("width"))  aPseudoUnit = NS_MATHML_PSEUDO_UNIT_WIDTH;
+  else if (unit.EqualsLiteral("height")) aPseudoUnit = NS_MATHML_PSEUDO_UNIT_HEIGHT;
+  else if (unit.EqualsLiteral("depth"))  aPseudoUnit = NS_MATHML_PSEUDO_UNIT_DEPTH;
+  else if (!gotPercent) { // percentage can only apply to a pseudo-unit
+
+    // see if the unit is a named-space
+    if (nsMathMLElement::ParseNamedSpaceValue(unit, aCSSValue,
+                                              nsMathMLElement::
+                                              PARSE_ALLOW_NEGATIVE)) {
+      // re-scale properly, and we know that the unit of the named-space is 'em'
+      floatValue *= aCSSValue.GetFloatValue();
+      aCSSValue.SetFloatValue(floatValue, eCSSUnit_EM);
+      aPseudoUnit = NS_MATHML_PSEUDO_UNIT_NAMEDSPACE;
+      return true;
+    }
+
+    // see if the input was just a CSS value
+    // We are not supposed to have a unitless, percent, negative or namedspace
+    // value here.
+    number.Append(unit); // leave the sign out if it was there
+    if (nsMathMLElement::ParseNumericValue(number, aCSSValue, 
+                                           nsMathMLElement::
+                                           PARSE_SUPPRESS_WARNINGS, nullptr))
+      return true;
+  }
+
+  // if we enter here, we have a number that will act as a multiplier on a pseudo-unit
+  if (aPseudoUnit != NS_MATHML_PSEUDO_UNIT_UNSPECIFIED) {
+    if (gotPercent)
+      aCSSValue.SetPercentValue(floatValue / 100.0f);
+    else
+      aCSSValue.SetFloatValue(floatValue, eCSSUnit_Number);
+
+    return true;
+  }
+
+
+#ifdef DEBUG
+  printf("mpadded: attribute with bad numeric value: %s\n",
+          NS_LossyConvertUTF16toASCII(aString).get());
+#endif
+  // if we reach here, it means we encounter an unexpected input
+  aSign = NS_MATHML_SIGN_INVALID;
+  return false;
+}
+
+void
+nsMathMLmpaddedFrame::UpdateValue(int32_t                  aSign,
+                                  int32_t                  aPseudoUnit,
+                                  const nsCSSValue&        aCSSValue,
+                                  const ReflowOutput& aDesiredSize,
+                                  nscoord&                 aValueToUpdate,
+                                  float                aFontSizeInflation) const
+{
+  nsCSSUnit unit = aCSSValue.GetUnit();
+  if (NS_MATHML_SIGN_INVALID != aSign && eCSSUnit_Null != unit) {
+    nscoord scaler = 0, amount = 0;
+
+    if (eCSSUnit_Percent == unit || eCSSUnit_Number == unit) {
+      switch(aPseudoUnit) {
+        case NS_MATHML_PSEUDO_UNIT_WIDTH:
+             scaler = aDesiredSize.Width();
+             break;
+
+        case NS_MATHML_PSEUDO_UNIT_HEIGHT:
+             scaler = aDesiredSize.BlockStartAscent();
+             break;
+
+        case NS_MATHML_PSEUDO_UNIT_DEPTH:
+             scaler = aDesiredSize.Height() - aDesiredSize.BlockStartAscent();
+             break;
+
+        default:
+          // if we ever reach here, it would mean something is wrong 
+          // somewhere with the setup and/or the caller
+          NS_ERROR("Unexpected Pseudo Unit");
+          return;
+      }
+    }
+
+    if (eCSSUnit_Number == unit)
+      amount = NSToCoordRound(float(scaler) * aCSSValue.GetFloatValue());
+    else if (eCSSUnit_Percent == unit)
+      amount = NSToCoordRound(float(scaler) * aCSSValue.GetPercentValue());
+    else
+      amount = CalcLength(PresContext(), mStyleContext, aCSSValue,
+                          aFontSizeInflation);
+
+    if (NS_MATHML_SIGN_PLUS == aSign)
+      aValueToUpdate += amount;
+    else if (NS_MATHML_SIGN_MINUS == aSign)
+      aValueToUpdate -= amount;
+    else
+      aValueToUpdate  = amount;
+  }
+}
+
+void
+nsMathMLmpaddedFrame::Reflow(nsPresContext*          aPresContext,
+                             ReflowOutput&     aDesiredSize,
+                             const ReflowInput& aReflowInput,
+                             nsReflowStatus&          aStatus)
+{
+  mPresentationData.flags &= ~NS_MATHML_ERROR;
+  ProcessAttributes();
+
+  ///////////////
+  // Let the base class format our content like an inferred mrow
+  nsMathMLContainerFrame::Reflow(aPresContext, aDesiredSize,
+                                 aReflowInput, aStatus);
+  //NS_ASSERTION(NS_FRAME_IS_COMPLETE(aStatus), "bad status");
+}
+
+/* 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();
+  // The REC says:
+  //
+  // "The lspace attribute ('leading' space) specifies the horizontal location
+  // of the positioning point of the child content with respect to the
+  // positioning point of the mpadded element. By default they coincide, and
+  // therefore absolute values for lspace have the same effect as relative
+  // values."
+  //
+  // "MathML renderers should ensure that, except for the effects of the
+  // attributes, the relative spacing between the contents of the mpadded
+  // element and surrounding MathML elements would not be modified by replacing
+  // an mpadded element with an mrow element with the same content, even if
+  // linebreaking occurs within the mpadded element."
+  //
+  // (http://www.w3.org/TR/MathML/chapter3.html#presm.mpadded)
+  // 
+  // "In those discussions, the terms leading and trailing are used to specify
+  // a side of an object when which side to use depends on the directionality;
+  // ie. leading means left in LTR but right in RTL."
+  // (http://www.w3.org/TR/MathML/chapter3.html#presm.bidi.math)
+  nscoord lspace = 0;
+  // In MathML3, "width" will be the bounding box width and "advancewidth" will
+  // refer "to the horizontal distance between the positioning point of the
+  // mpadded and the positioning point for the following content".  MathML2
+  // doesn't make the distinction.
+  nscoord width  = aDesiredSize.Width();
+  nscoord voffset = 0;
+
+  int32_t pseudoUnit;
+  nscoord initialWidth = width;
+  float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
+
+  // update width
+  pseudoUnit = (mWidthPseudoUnit == NS_MATHML_PSEUDO_UNIT_ITSELF)
+             ? NS_MATHML_PSEUDO_UNIT_WIDTH : mWidthPseudoUnit;
+  UpdateValue(mWidthSign, pseudoUnit, mWidth,
+              aDesiredSize, width, fontSizeInflation);
+  width = std::max(0, width);
+
+  // update "height" (this is the ascent in the terminology of the REC)
+  pseudoUnit = (mHeightPseudoUnit == NS_MATHML_PSEUDO_UNIT_ITSELF)
+             ? NS_MATHML_PSEUDO_UNIT_HEIGHT : mHeightPseudoUnit;
+  UpdateValue(mHeightSign, pseudoUnit, mHeight,
+              aDesiredSize, height, fontSizeInflation);
+  height = std::max(0, height);
+
+  // update "depth" (this is the descent in the terminology of the REC)
+  pseudoUnit = (mDepthPseudoUnit == NS_MATHML_PSEUDO_UNIT_ITSELF)
+             ? NS_MATHML_PSEUDO_UNIT_DEPTH : mDepthPseudoUnit;
+  UpdateValue(mDepthSign, pseudoUnit, mDepth,
+              aDesiredSize, depth, fontSizeInflation);
+  depth = std::max(0, depth);
+
+  // update lspace
+  if (mLeadingSpacePseudoUnit != NS_MATHML_PSEUDO_UNIT_ITSELF) {
+    pseudoUnit = mLeadingSpacePseudoUnit;
+    UpdateValue(mLeadingSpaceSign, pseudoUnit, mLeadingSpace,
+                aDesiredSize, lspace, fontSizeInflation);
+  }
+
+  // update voffset
+  if (mVerticalOffsetPseudoUnit != NS_MATHML_PSEUDO_UNIT_ITSELF) {
+    pseudoUnit = mVerticalOffsetPseudoUnit;
+    UpdateValue(mVerticalOffsetSign, pseudoUnit, mVerticalOffset,
+                aDesiredSize, voffset, fontSizeInflation);
+  }
+  // do the padding now that we have everything
+  // The idea here is to maintain the invariant that <mpadded>...</mpadded> (i.e.,
+  // with no attributes) looks the same as <mrow>...</mrow>. But when there are
+  // attributes, tweak our metrics and move children to achieve the desired visual
+  // effects.
+
+  if ((StyleVisibility()->mDirection ?
+       mWidthSign : mLeadingSpaceSign) != NS_MATHML_SIGN_INVALID) {
+    // there was padding on the left. dismiss the left italic correction now
+    // (so that our parent won't correct us)
+    mBoundingMetrics.leftBearing = 0;
+  }
+
+  if ((StyleVisibility()->mDirection ?
+       mLeadingSpaceSign : mWidthSign) != NS_MATHML_SIGN_INVALID) {
+    // there was padding on the right. dismiss the right italic correction now
+    // (so that our parent won't correct us)
+    mBoundingMetrics.width = width;
+    mBoundingMetrics.rightBearing = mBoundingMetrics.width;
+  }
+
+  nscoord dx = (StyleVisibility()->mDirection ?
+                width - initialWidth - lspace : lspace);
+    
+  aDesiredSize.SetBlockStartAscent(height);
+  aDesiredSize.Width() = mBoundingMetrics.width;
+  aDesiredSize.Height() = depth + aDesiredSize.BlockStartAscent();
+  mBoundingMetrics.ascent = height;
+  mBoundingMetrics.descent = depth;
+  aDesiredSize.mBoundingMetrics = mBoundingMetrics;
+
+  mReference.x = 0;
+  mReference.y = aDesiredSize.BlockStartAscent();
+
+  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)
+{
+  ProcessAttributes();
+  return Place(aDrawTarget, false, aDesiredSize);
+}