Add m-esr52 at 52.6.0

1 files changed, 226 insertions, 0 deletions

diff --git a/layout/style/nsStyleTransformMatrix.h b/layout/style/nsStyleTransformMatrix.h
new file mode 100644
index 000000000..bde87c7ad
--- /dev/null
+++ b/layout/style/nsStyleTransformMatrix.h
@@ -0,0 +1,226 @@
+/* -*- 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/. */
+
+/*
+ * A class representing three matrices that can be used for style transforms.
+ */
+
+#ifndef nsStyleTransformMatrix_h_
+#define nsStyleTransformMatrix_h_
+
+#include "mozilla/EnumeratedArray.h"
+#include "nsCSSValue.h"
+
+#include <limits>
+
+class nsIFrame;
+class nsStyleContext;
+class nsPresContext;
+struct gfxQuaternion;
+struct nsRect;
+namespace mozilla {
+class RuleNodeCacheConditions;
+} // namespace mozilla
+
+/**
+ * A helper to generate gfxMatrixes from css transform functions.
+ */
+namespace nsStyleTransformMatrix {
+
+  // Function for applying perspective() transform function. We treat
+  // any value smaller than epsilon as perspective(infinity), which
+  // follows CSSWG's resolution on perspective(0). See bug 1316236.
+  inline void ApplyPerspectiveToMatrix(mozilla::gfx::Matrix4x4& aMatrix,
+                                       float aDepth)
+  {
+    if (aDepth >= std::numeric_limits<float>::epsilon()) {
+      aMatrix.Perspective(aDepth);
+    }
+  }
+
+  /**
+   * This class provides on-demand access to the 'reference box' for CSS
+   * transforms (needed to resolve percentage values in 'transform',
+   * 'transform-origin', etc.):
+   *
+   *    http://dev.w3.org/csswg/css-transforms/#reference-box
+   *
+   * This class helps us to avoid calculating the reference box unless and
+   * until it is actually needed. This is important for performance when
+   * transforms are applied to SVG elements since the reference box for SVG is
+   * much more expensive to calculate (than for elements with a CSS layout box
+   * where we can use the nsIFrame's cached mRect), much more common (than on
+   * HTML), and yet very rarely have percentage values that require the
+   * reference box to be resolved. We also don't want to cause SVG frames to
+   * cache lots of ObjectBoundingBoxProperty objects that aren't needed.
+   *
+   * If UNIFIED_CONTINUATIONS (experimental, and currently broke) is defined,
+   * we consider the reference box for non-SVG frames to be the smallest
+   * rectangle containing a frame and all of its continuations.  For example,
+   * if there is a <span> element with several continuations split over
+   * several lines, this function will return the rectangle containing all of
+   * those continuations. (This behavior is not currently in a spec.)
+   */
+  class MOZ_STACK_CLASS TransformReferenceBox final {
+  public:
+    typedef nscoord (TransformReferenceBox::*DimensionGetter)();
+
+    explicit TransformReferenceBox()
+      : mFrame(nullptr)
+      , mIsCached(false)
+    {}
+
+    explicit TransformReferenceBox(const nsIFrame* aFrame)
+      : mFrame(aFrame)
+      , mIsCached(false)
+    {
+      MOZ_ASSERT(mFrame);
+    }
+
+    explicit TransformReferenceBox(const nsIFrame* aFrame,
+                                   const nsSize& aFallbackDimensions)
+    {
+      mFrame = aFrame;
+      mIsCached = false;
+      if (!mFrame) {
+        Init(aFallbackDimensions);
+      }
+    }
+
+    void Init(const nsIFrame* aFrame) {
+      MOZ_ASSERT(!mFrame && !mIsCached);
+      mFrame = aFrame;
+    }
+
+    void Init(const nsSize& aDimensions);
+
+    /**
+     * The offset of the reference box from the nsIFrame's TopLeft(). This
+     * is non-zero only in the case of SVG content. If we can successfully
+     * implement UNIFIED_CONTINUATIONS at some point in the future then it
+     * may also be non-zero for non-SVG content.
+     */
+    nscoord X() {
+      EnsureDimensionsAreCached();
+      return mX;
+    }
+    nscoord Y() {
+      EnsureDimensionsAreCached();
+      return mY;
+    }
+
+    /**
+     * The size of the reference box.
+     */
+    nscoord Width() {
+      EnsureDimensionsAreCached();
+      return mWidth;
+    }
+    nscoord Height() {
+      EnsureDimensionsAreCached();
+      return mHeight;
+    }
+
+    bool IsEmpty() {
+      return !mFrame;
+    }
+
+  private:
+    // We don't really need to prevent copying, but since none of our consumers
+    // currently need to copy, preventing copying may allow us to catch some
+    // cases where we use pass-by-value instead of pass-by-reference.
+    TransformReferenceBox(const TransformReferenceBox&) = delete;
+
+    void EnsureDimensionsAreCached();
+
+    const nsIFrame* mFrame;
+    nscoord mX, mY, mWidth, mHeight;
+    bool mIsCached;
+  };
+
+  /**
+   * Return the transform function, as an nsCSSKeyword, for the given
+   * nsCSSValue::Array from a transform list.
+   */
+  nsCSSKeyword TransformFunctionOf(const nsCSSValue::Array* aData);
+
+  void SetIdentityMatrix(nsCSSValue::Array* aMatrix);
+
+  float ProcessTranslatePart(const nsCSSValue& aValue,
+                             nsStyleContext* aContext,
+                             nsPresContext* aPresContext,
+                             mozilla::RuleNodeCacheConditions& aConditions,
+                             TransformReferenceBox* aRefBox,
+                             TransformReferenceBox::DimensionGetter aDimensionGetter = nullptr);
+
+  void
+  ProcessInterpolateMatrix(mozilla::gfx::Matrix4x4& aMatrix,
+                           const nsCSSValue::Array* aData,
+                           nsStyleContext* aContext,
+                           nsPresContext* aPresContext,
+                           mozilla::RuleNodeCacheConditions& aConditions,
+                           TransformReferenceBox& aBounds,
+                           bool* aContains3dTransform);
+
+  /**
+   * Given an nsCSSValueList containing -moz-transform functions,
+   * returns a matrix containing the value of those functions.
+   *
+   * @param aData The nsCSSValueList containing the transform functions
+   * @param aContext The style context, used for unit conversion.
+   * @param aPresContext The presentation context, used for unit conversion.
+   * @param aConditions Set to uncachable (by calling SetUncacheable()) if the
+   *   result cannot be cached in the rule tree, otherwise untouched.
+   * @param aBounds The frame's bounding rectangle.
+   * @param aAppUnitsPerMatrixUnit The number of app units per device pixel.
+   * @param aContains3dTransform [out] Set to true if aList contains at least
+   *   one 3d transform function (as defined in the CSS transforms
+   *   specification), false otherwise.
+   *
+   * aContext and aPresContext may be null if all of the (non-percent)
+   * length values in aData are already known to have been converted to
+   * eCSSUnit_Pixel (as they are in an StyleAnimationValue)
+   */
+  mozilla::gfx::Matrix4x4 ReadTransforms(const nsCSSValueList* aList,
+                                         nsStyleContext* aContext,
+                                         nsPresContext* aPresContext,
+                                         mozilla::RuleNodeCacheConditions& aConditions,
+                                         TransformReferenceBox& aBounds,
+                                         float aAppUnitsPerMatrixUnit,
+                                         bool* aContains3dTransform);
+
+  // Shear type for decomposition.
+  enum class ShearType {
+    XYSHEAR,
+    XZSHEAR,
+    YZSHEAR,
+    Count
+  };
+  using ShearArray =
+    mozilla::EnumeratedArray<ShearType, ShearType::Count, float>;
+
+  /*
+   * Implements the 2d transform matrix decomposition algorithm.
+   */
+  bool Decompose2DMatrix(const mozilla::gfx::Matrix& aMatrix,
+                         mozilla::gfx::Point3D& aScale,
+                         ShearArray& aShear,
+                         gfxQuaternion& aRotate,
+                         mozilla::gfx::Point3D& aTranslate);
+  /*
+   * Implements the 3d transform matrix decomposition algorithm.
+   */
+  bool Decompose3DMatrix(const mozilla::gfx::Matrix4x4& aMatrix,
+                         mozilla::gfx::Point3D& aScale,
+                         ShearArray& aShear,
+                         gfxQuaternion& aRotate,
+                         mozilla::gfx::Point3D& aTranslate,
+                         mozilla::gfx::Point4D& aPerspective);
+
+  mozilla::gfx::Matrix CSSValueArrayTo2DMatrix(nsCSSValue::Array* aArray);
+  mozilla::gfx::Matrix4x4 CSSValueArrayTo3DMatrix(nsCSSValue::Array* aArray);
+} // namespace nsStyleTransformMatrix
+
+#endif