Add m-esr52 at 52.6.0

1 files changed, 231 insertions, 0 deletions

diff --git a/layout/svg/nsSVGIntegrationUtils.h b/layout/svg/nsSVGIntegrationUtils.h
new file mode 100644
index 000000000..e3eb3c5f2
--- /dev/null
+++ b/layout/svg/nsSVGIntegrationUtils.h
@@ -0,0 +1,231 @@
+/* -*- 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/. */
+
+#ifndef NSSVGINTEGRATIONUTILS_H_
+#define NSSVGINTEGRATIONUTILS_H_
+
+#include "gfxMatrix.h"
+#include "gfxRect.h"
+#include "nsRegionFwd.h"
+#include "mozilla/gfx/Rect.h"
+
+class gfxContext;
+class gfxDrawable;
+class nsDisplayList;
+class nsDisplayListBuilder;
+class nsIFrame;
+
+struct nsRect;
+
+namespace mozilla {
+namespace gfx {
+class DrawTarget;
+} // namespace gfx
+namespace layers {
+class LayerManager;
+} // namespace layers
+} // namespace mozilla
+
+struct nsPoint;
+struct nsSize;
+
+/**
+ * Integration of SVG effects (clipPath clipping, masking and filters) into
+ * regular display list based painting and hit-testing.
+ */
+class nsSVGIntegrationUtils final
+{
+  typedef mozilla::gfx::DrawTarget DrawTarget;
+  typedef mozilla::gfx::IntRect IntRect;
+  typedef mozilla::image::DrawResult DrawResult;
+
+public:
+  /**
+   * Returns true if SVG effects are currently applied to this frame.
+   */
+  static bool
+  UsingEffectsForFrame(const nsIFrame* aFrame);
+
+  /**
+   * Returns true if mask or clippath are currently applied to this frame.
+   */
+  static bool
+  UsingMaskOrClipPathForFrame(const nsIFrame* aFrame);
+
+  /**
+   * Returns the size of the union of the border-box rects of all of
+   * aNonSVGFrame's continuations.
+   */
+  static nsSize
+  GetContinuationUnionSize(nsIFrame* aNonSVGFrame);
+
+  /**
+   * When SVG effects need to resolve percentage, userSpaceOnUse lengths, they
+   * need a coordinate context to resolve them against. This method provides
+   * that coordinate context for non-SVG frames with SVG effects applied to
+   * them. The gfxSize returned is the size of the union of all of the given
+   * frame's continuations' border boxes, converted to SVG user units (equal to
+   * CSS px units), as required by the SVG code.
+   */
+  static mozilla::gfx::Size
+  GetSVGCoordContextForNonSVGFrame(nsIFrame* aNonSVGFrame);
+
+  /**
+   * SVG effects such as SVG filters, masking and clipPath may require an SVG
+   * "bbox" for the element they're being applied to in order to make decisions
+   * about positioning, and to resolve various lengths against. This method
+   * provides the "bbox" for non-SVG frames. The bbox returned is in CSS px
+   * units, and is the union of all aNonSVGFrame's continuations' overflow
+   * areas, relative to the top-left of the union of all aNonSVGFrame's
+   * continuations' border box rects.
+   */
+  static gfxRect
+  GetSVGBBoxForNonSVGFrame(nsIFrame* aNonSVGFrame);
+
+  /**
+   * Used to adjust a frame's pre-effects visual overflow rect to take account
+   * of SVG effects.
+   *
+   * XXX This method will not do the right thing for frames with continuations.
+   * It really needs all the continuations to have been reflowed before being
+   * called, but we currently call it on each continuation as its overflow
+   * rects are set during the reflow of each particular continuation. Gecko's
+   * current reflow architecture does not allow us to set the overflow rects
+   * for a whole chain of continuations for a given element at the point when
+   * the last continuation is reflowed. See:
+   * http://groups.google.com/group/mozilla.dev.tech.layout/msg/6b179066f3051f65
+   */
+  static nsRect
+  ComputePostEffectsVisualOverflowRect(nsIFrame* aFrame,
+                                       const nsRect& aPreEffectsOverflowRect);
+
+  /**
+   * Used to adjust the area of a frame that needs to be invalidated to take
+   * account of SVG effects.
+   *
+   * @param aFrame The effects frame.
+   * @param aToReferenceFrame The offset (in app units) from aFrame to its
+   * reference display item.
+   * @param aInvalidRegion The pre-effects invalid region in pixels relative to
+   * the reference display item.
+   * @return The post-effects invalid rect in pixels relative to the reference
+   * display item.
+   */
+  static nsIntRegion
+  AdjustInvalidAreaForSVGEffects(nsIFrame* aFrame, const nsPoint& aToReferenceFrame,
+                                 const nsIntRegion& aInvalidRegion);
+
+  /**
+   * Figure out which area of the source is needed given an area to
+   * repaint
+   */
+  static nsRect
+  GetRequiredSourceForInvalidArea(nsIFrame* aFrame, const nsRect& aDamageRect);
+
+  /**
+   * Returns true if the given point is not clipped out by effects.
+   * @param aPt in appunits relative to aFrame
+   */
+  static bool
+  HitTestFrameForEffects(nsIFrame* aFrame, const nsPoint& aPt);
+
+  struct PaintFramesParams {
+    gfxContext& ctx;
+    nsIFrame* frame;
+    const nsRect& dirtyRect;
+    const nsRect& borderArea;
+    nsDisplayListBuilder* builder;
+    mozilla::layers::LayerManager* layerManager;
+    bool handleOpacity; // If true, PaintMaskAndClipPath/ PaintFilter should
+                        // apply css opacity.
+    IntRect maskRect;
+
+    explicit PaintFramesParams(gfxContext& aCtx, nsIFrame* aFrame,
+                               const nsRect& aDirtyRect,
+                               const nsRect& aBorderArea,
+                               nsDisplayListBuilder* aBuilder,
+                               mozilla::layers::LayerManager* aLayerManager,
+                               bool aHandleOpacity)
+      : ctx(aCtx), frame(aFrame), dirtyRect(aDirtyRect),
+        borderArea(aBorderArea), builder(aBuilder),
+        layerManager(aLayerManager), handleOpacity(aHandleOpacity)
+    { }
+  };
+
+  /**
+   * Paint non-SVG frame with mask, clipPath and opacity effect.
+   */
+  static DrawResult
+  PaintMaskAndClipPath(const PaintFramesParams& aParams);
+
+  /**
+   * Paint mask of non-SVG frame onto a given context, aParams.ctx.
+   * aParams.ctx must contain an A8 surface.
+   */
+  static DrawResult
+  PaintMask(const PaintFramesParams& aParams);
+
+  /**
+   * Return true if all the mask resource of aFrame are ready.
+   */
+  static bool
+  IsMaskResourceReady(nsIFrame* aFrame);
+
+  /**
+   * Paint non-SVG frame with filter and opacity effect.
+   */
+  static DrawResult
+  PaintFilter(const PaintFramesParams& aParams);
+
+  /**
+   * SVG frames expect to paint in SVG user units, which are equal to CSS px
+   * units. This method provides a transform matrix to multiply onto a
+   * gfxContext's current transform to convert the context's current units from
+   * its usual dev pixels to SVG user units/CSS px to keep the SVG code happy.
+   */
+  static gfxMatrix
+  GetCSSPxToDevPxMatrix(nsIFrame* aNonSVGFrame);
+
+  /**
+   * @param aRenderingContext the target rendering context in which the paint
+   * server will be rendered
+   * @param aTarget the target frame onto which the paint server will be
+   * rendered
+   * @param aPaintServer a first-continuation frame to use as the source
+   * @param aFilter a filter to be applied when scaling
+   * @param aDest the area the paint server image should be mapped to
+   * @param aFill the area to be filled with copies of the paint server image
+   * @param aAnchor a point in aFill which we will ensure is pixel-aligned in
+   * the output
+   * @param aDirty pixels outside this area may be skipped
+   * @param aPaintServerSize the size that would be filled when using
+   * background-repeat:no-repeat and background-size:auto. For normal background
+   * images, this would be the intrinsic size of the image; for gradients and
+   * patterns this would be the whole target frame fill area.
+   * @param aFlags pass FLAG_SYNC_DECODE_IMAGES and any images in the paint
+   * server will be decoding synchronously if they are not decoded already.
+   */
+  enum {
+    FLAG_SYNC_DECODE_IMAGES = 0x01,
+  };
+
+  static already_AddRefed<gfxDrawable>
+  DrawableFromPaintServer(nsIFrame* aFrame,
+                          nsIFrame* aTarget,
+                          const nsSize& aPaintServerSize,
+                          const mozilla::gfx::IntSize& aRenderSize,
+                          const DrawTarget* aDrawTarget,
+                          const gfxMatrix& aContextMatrix,
+                          uint32_t aFlags);
+
+  /**
+   * For non-SVG frames, this gives the offset to the frame's "user space".
+   * For SVG frames, this returns a zero offset.
+   */
+  static nsPoint
+  GetOffsetToBoundingBox(nsIFrame* aFrame);
+};
+
+#endif /*NSSVGINTEGRATIONUTILS_H_*/