Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 316 insertions, 0 deletions

diff --git a/layout/painting/nsImageRenderer.h b/layout/painting/nsImageRenderer.h
new file mode 100644
index 0000000000..6d5843a73f
--- /dev/null
+++ b/layout/painting/nsImageRenderer.h
@@ -0,0 +1,316 @@
+/* -*- 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/. */
+
+#ifndef nsImageRenderer_h__
+#define nsImageRenderer_h__
+
+#include "nsStyleStruct.h"
+#include "Units.h"
+#include "mozilla/AspectRatio.h"
+#include "mozilla/SurfaceFromElementResult.h"
+
+class gfxDrawable;
+class nsDisplayItem;
+namespace mozilla {
+
+namespace layers {
+class StackingContextHelper;
+class WebRenderParentCommand;
+class RenderRootStateManager;
+}  // namespace layers
+
+namespace wr {
+class DisplayListBuilder;
+class IpcResourceUpdateQueue;
+}  // namespace wr
+
+// A CSSSizeOrRatio represents a (possibly partially specified) size for use
+// in computing image sizes. Either or both of the width and height might be
+// given. A ratio of width to height may also be given. If we at least two
+// of these then we can compute a concrete size, that is a width and height.
+struct CSSSizeOrRatio {
+  CSSSizeOrRatio()
+      : mWidth(0), mHeight(0), mHasWidth(false), mHasHeight(false) {}
+
+  bool CanComputeConcreteSize() const {
+    return mHasWidth + mHasHeight + HasRatio() >= 2;
+  }
+  bool IsConcrete() const { return mHasWidth && mHasHeight; }
+  bool HasRatio() const { return !!mRatio; }
+  bool IsEmpty() const {
+    return (mHasWidth && mWidth <= 0) || (mHasHeight && mHeight <= 0) ||
+           !mRatio;
+  }
+
+  // CanComputeConcreteSize must return true when ComputeConcreteSize is
+  // called.
+  nsSize ComputeConcreteSize() const;
+
+  void SetWidth(nscoord aWidth) {
+    mWidth = aWidth;
+    mHasWidth = true;
+    if (mHasHeight) {
+      mRatio = AspectRatio::FromSize(mWidth, mHeight);
+    }
+  }
+  void SetHeight(nscoord aHeight) {
+    mHeight = aHeight;
+    mHasHeight = true;
+    if (mHasWidth) {
+      mRatio = AspectRatio::FromSize(mWidth, mHeight);
+    }
+  }
+  void SetSize(const nsSize& aSize) {
+    mWidth = aSize.width;
+    mHeight = aSize.height;
+    mHasWidth = true;
+    mHasHeight = true;
+    mRatio = AspectRatio::FromSize(mWidth, mHeight);
+  }
+  void SetRatio(const AspectRatio& aRatio) {
+    MOZ_ASSERT(
+        !mHasWidth || !mHasHeight,
+        "Probably shouldn't be setting a ratio if we have a concrete size");
+    mRatio = aRatio;
+  }
+
+  AspectRatio mRatio;
+  nscoord mWidth;
+  nscoord mHeight;
+  bool mHasWidth;
+  bool mHasHeight;
+};
+
+/**
+ * This is a small wrapper class to encapsulate image drawing that can draw an
+ * StyleImage image, which may internally be a real image, a sub image, or a CSS
+ * gradient, etc...
+ *
+ * @note Always call the member functions in the order of PrepareImage(),
+ * SetSize(), and Draw*().
+ */
+class nsImageRenderer {
+ public:
+  typedef mozilla::image::ImgDrawResult ImgDrawResult;
+  typedef mozilla::layers::LayerManager LayerManager;
+  typedef mozilla::layers::ImageContainer ImageContainer;
+
+  enum {
+    FLAG_SYNC_DECODE_IMAGES = 0x01,
+    FLAG_PAINTING_TO_WINDOW = 0x02,
+    FLAG_HIGH_QUALITY_SCALING = 0x04
+  };
+  enum FitType { CONTAIN, COVER };
+
+  nsImageRenderer(nsIFrame* aForFrame, const mozilla::StyleImage* aImage,
+                  uint32_t aFlags);
+  ~nsImageRenderer() = default;
+  /**
+   * Populates member variables to get ready for rendering.
+   * @return true iff the image is ready, and there is at least a pixel to
+   * draw.
+   */
+  bool PrepareImage();
+
+  /**
+   * The three Compute*Size functions correspond to the sizing algorthms and
+   * definitions from the CSS Image Values and Replaced Content spec. See
+   * http://dev.w3.org/csswg/css-images-3/#sizing .
+   */
+
+  /**
+   * Compute the intrinsic size of the image as defined in the CSS Image Values
+   * spec. The intrinsic size is the unscaled size which the image would ideally
+   * like to be in app units.
+   */
+  mozilla::CSSSizeOrRatio ComputeIntrinsicSize();
+
+  /**
+   * Computes the placement for a background image, or for the image data
+   * inside of a replaced element.
+   *
+   * @param aPos The CSS <position> value that specifies the image's position.
+   * @param aOriginBounds The box to which the tiling position should be
+   *          relative. For background images, this should correspond to
+   *          'background-origin' for the frame, except when painting on the
+   *          canvas, in which case the origin bounds should be the bounds
+   *          of the root element's frame. For a replaced element, this should
+   *          be the element's content-box.
+   * @param aTopLeft [out] The top-left corner where an image tile should be
+   *          drawn.
+   * @param aAnchorPoint [out] A point which should be pixel-aligned by
+   *          nsLayoutUtils::DrawImage. This is the same as aTopLeft, unless
+   *          CSS specifies a percentage (including 'right' or 'bottom'), in
+   *          which case it's that percentage within of aOriginBounds. So
+   *          'right' would set aAnchorPoint.x to aOriginBounds.XMost().
+   *
+   * Points are returned relative to aOriginBounds.
+   */
+  static void ComputeObjectAnchorPoint(const mozilla::Position& aPos,
+                                       const nsSize& aOriginBounds,
+                                       const nsSize& aImageSize,
+                                       nsPoint* aTopLeft,
+                                       nsPoint* aAnchorPoint);
+
+  /**
+   * Compute the size of the rendered image using either the 'cover' or
+   * 'contain' constraints (aFitType).
+   */
+  static nsSize ComputeConstrainedSize(
+      const nsSize& aConstrainingSize,
+      const mozilla::AspectRatio& aIntrinsicRatio, FitType aFitType);
+  /**
+   * Compute the size of the rendered image (the concrete size) where no cover/
+   * contain constraints are given. The 'default algorithm' from the CSS Image
+   * Values spec.
+   */
+  static nsSize ComputeConcreteSize(
+      const mozilla::CSSSizeOrRatio& aSpecifiedSize,
+      const mozilla::CSSSizeOrRatio& aIntrinsicSize,
+      const nsSize& aDefaultSize);
+
+  /**
+   * Set this image's preferred size. This will be its intrinsic size where
+   * specified and the default size where it is not. Used as the unscaled size
+   * when rendering the image.
+   */
+  void SetPreferredSize(const mozilla::CSSSizeOrRatio& aIntrinsicSize,
+                        const nsSize& aDefaultSize);
+
+  /**
+   * Draws the image to the target rendering context using
+   * {background|mask}-specific arguments.
+   * @see nsLayoutUtils::DrawImage() for parameters.
+   */
+  ImgDrawResult DrawLayer(nsPresContext* aPresContext,
+                          gfxContext& aRenderingContext, const nsRect& aDest,
+                          const nsRect& aFill, const nsPoint& aAnchor,
+                          const nsRect& aDirty, const nsSize& aRepeatSize,
+                          float aOpacity);
+
+  /**
+   * Builds WebRender DisplayItems for an image using
+   * {background|mask}-specific arguments.
+   * @see nsLayoutUtils::DrawImage() for parameters.
+   */
+  ImgDrawResult BuildWebRenderDisplayItemsForLayer(
+      nsPresContext* aPresContext, mozilla::wr::DisplayListBuilder& aBuilder,
+      mozilla::wr::IpcResourceUpdateQueue& aResource,
+      const mozilla::layers::StackingContextHelper& aSc,
+      mozilla::layers::RenderRootStateManager* aManager, nsDisplayItem* aItem,
+      const nsRect& aDest, const nsRect& aFill, const nsPoint& aAnchor,
+      const nsRect& aDirty, const nsSize& aRepeatSize, float aOpacity);
+
+  /**
+   * Draw the image to a single component of a border-image style rendering.
+   * aFill The destination rect to be drawn into
+   * aSrc is the part of the image to be rendered into a tile (aUnitSize in
+   * aFill), if aSrc and the dest tile are different sizes, the image will be
+   * scaled to map aSrc onto the dest tile.
+   * aHFill and aVFill are the repeat patterns for the component -
+   * NS_STYLE_BORDER_IMAGE_REPEAT_*
+   * aUnitSize The scaled size of a single source rect (in destination coords)
+   * aIndex identifies the component: 0 1 2
+   *                                  3 4 5
+   *                                  6 7 8
+   * aSVGViewportSize The image size evaluated by default sizing algorithm.
+   * Pass Nothing() if we can read a valid viewport size or aspect-ratio from
+   * the drawing image directly, otherwise, pass Some() with viewport size
+   * evaluated from default sizing algorithm.
+   * aHasIntrinsicRatio is used to record if the source image has fixed
+   * intrinsic ratio.
+   */
+  ImgDrawResult DrawBorderImageComponent(
+      nsPresContext* aPresContext, gfxContext& aRenderingContext,
+      const nsRect& aDirtyRect, const nsRect& aFill,
+      const mozilla::CSSIntRect& aSrc, mozilla::StyleBorderImageRepeat aHFill,
+      mozilla::StyleBorderImageRepeat aVFill, const nsSize& aUnitSize,
+      uint8_t aIndex, const mozilla::Maybe<nsSize>& aSVGViewportSize,
+      const bool aHasIntrinsicRatio);
+
+  /**
+   * Draw the image to aRenderingContext which can be used to define the
+   * float area in the presence of "shape-outside: <image>".
+   */
+  ImgDrawResult DrawShapeImage(nsPresContext* aPresContext,
+                               gfxContext& aRenderingContext);
+
+  bool IsRasterImage();
+  bool IsAnimatedImage();
+
+  /// Retrieves the image associated with this nsImageRenderer, if there is one.
+  already_AddRefed<imgIContainer> GetImage();
+
+  bool IsImageContainerAvailable(layers::LayerManager* aManager,
+                                 uint32_t aFlags);
+  bool IsReady() const { return mPrepareResult == ImgDrawResult::SUCCESS; }
+  ImgDrawResult PrepareResult() const { return mPrepareResult; }
+  void SetExtendMode(mozilla::gfx::ExtendMode aMode) { mExtendMode = aMode; }
+  void SetMaskOp(mozilla::StyleMaskMode aMaskOp) { mMaskOp = aMaskOp; }
+  void PurgeCacheForViewportChange(
+      const mozilla::Maybe<nsSize>& aSVGViewportSize, const bool aHasRatio);
+  const nsSize& GetSize() const { return mSize; }
+  mozilla::StyleImage::Tag GetType() const { return mType; }
+  const mozilla::StyleGradient* GetGradientData() const {
+    return mGradientData;
+  }
+
+ private:
+  /**
+   * Draws the image to the target rendering context.
+   * aSrc is a rect on the source image which will be mapped to aDest; it's
+   * currently only used for gradients.
+   *
+   * @see nsLayoutUtils::DrawImage() for other parameters.
+   */
+  ImgDrawResult Draw(nsPresContext* aPresContext, gfxContext& aRenderingContext,
+                     const nsRect& aDirtyRect, const nsRect& aDest,
+                     const nsRect& aFill, const nsPoint& aAnchor,
+                     const nsSize& aRepeatSize, const mozilla::CSSIntRect& aSrc,
+                     float aOpacity = 1.0);
+
+  /**
+   * Builds WebRender DisplayItems for the image.
+   * aSrc is a rect on the source image which will be mapped to aDest; it's
+   * currently only used for gradients.
+   *
+   * @see nsLayoutUtils::DrawImage() for other parameters.
+   */
+  ImgDrawResult BuildWebRenderDisplayItems(
+      nsPresContext* aPresContext, mozilla::wr::DisplayListBuilder& aBuilder,
+      mozilla::wr::IpcResourceUpdateQueue& aResources,
+      const mozilla::layers::StackingContextHelper& aSc,
+      mozilla::layers::RenderRootStateManager* aManager, nsDisplayItem* aItem,
+      const nsRect& aDirtyRect, const nsRect& aDest, const nsRect& aFill,
+      const nsPoint& aAnchor, const nsSize& aRepeatSize,
+      const mozilla::CSSIntRect& aSrc, float aOpacity = 1.0);
+
+  /**
+   * Helper method for creating a gfxDrawable from mPaintServerFrame or
+   * mImageElementSurface.
+   * Requires mType to be Element.
+   * Returns null if we cannot create the drawable.
+   */
+  already_AddRefed<gfxDrawable> DrawableForElement(const nsRect& aImageRect,
+                                                   gfxContext& aContext);
+
+  nsIFrame* mForFrame;
+  const mozilla::StyleImage* mImage;
+  mozilla::StyleImage::Tag mType;
+  nsCOMPtr<imgIContainer> mImageContainer;
+  const mozilla::StyleGradient* mGradientData;
+  nsIFrame* mPaintServerFrame;
+  SurfaceFromElementResult mImageElementSurface;
+  ImgDrawResult mPrepareResult;
+  nsSize mSize;  // unscaled size of the image, in app units
+  uint32_t mFlags;
+  mozilla::gfx::ExtendMode mExtendMode;
+  mozilla::StyleMaskMode mMaskOp;
+};
+
+}  // namespace mozilla
+
+#endif /* nsImageRenderer_h__ */