Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 465 insertions, 0 deletions

diff --git a/layout/generic/nsImageFrame.h b/layout/generic/nsImageFrame.h
new file mode 100644
index 0000000000..d9e2610e81
--- /dev/null
+++ b/layout/generic/nsImageFrame.h
@@ -0,0 +1,465 @@
+/* -*- 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/. */
+
+/* rendering object for replaced elements with image data */
+
+#ifndef nsImageFrame_h___
+#define nsImageFrame_h___
+
+#include "nsAtomicContainerFrame.h"
+#include "nsIObserver.h"
+
+#include "imgINotificationObserver.h"
+
+#include "nsDisplayList.h"
+#include "imgIContainer.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/StaticPtr.h"
+#include "nsIReflowCallback.h"
+#include "nsTObserverArray.h"
+
+class nsFontMetrics;
+class nsImageMap;
+class nsIURI;
+class nsILoadGroup;
+class nsPresContext;
+class nsImageFrame;
+class nsTransform2D;
+class nsImageLoadingContent;
+
+namespace mozilla {
+class nsDisplayImage;
+class PresShell;
+namespace layers {
+class ImageContainer;
+class LayerManager;
+}  // namespace layers
+}  // namespace mozilla
+
+class nsImageListener final : public imgINotificationObserver {
+ protected:
+  virtual ~nsImageListener();
+
+ public:
+  explicit nsImageListener(nsImageFrame* aFrame);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_IMGINOTIFICATIONOBSERVER
+
+  void SetFrame(nsImageFrame* frame) { mFrame = frame; }
+
+ private:
+  nsImageFrame* mFrame;
+};
+
+class nsImageFrame : public nsAtomicContainerFrame, public nsIReflowCallback {
+ public:
+  template <typename T>
+  using Maybe = mozilla::Maybe<T>;
+  using Nothing = mozilla::Nothing;
+  using Visibility = mozilla::Visibility;
+
+  typedef mozilla::image::ImgDrawResult ImgDrawResult;
+  typedef mozilla::layers::ImageContainer ImageContainer;
+  typedef mozilla::layers::LayerManager LayerManager;
+
+  NS_DECL_FRAMEARENA_HELPERS(nsImageFrame)
+  NS_DECL_QUERYFRAME
+
+  void Destroy(DestroyContext&) override;
+  void DidSetComputedStyle(ComputedStyle* aOldStyle) final;
+
+  void Init(nsIContent* aContent, nsContainerFrame* aParent,
+            nsIFrame* aPrevInFlow) override;
+  void BuildDisplayList(nsDisplayListBuilder*, const nsDisplayListSet&) final;
+  nscoord GetMinISize(gfxContext* aRenderingContext) final;
+  nscoord GetPrefISize(gfxContext* aRenderingContext) final;
+  mozilla::IntrinsicSize GetIntrinsicSize() final { return mIntrinsicSize; }
+  mozilla::AspectRatio GetIntrinsicRatio() const final {
+    return mIntrinsicRatio;
+  }
+  void Reflow(nsPresContext*, ReflowOutput&, const ReflowInput&,
+              nsReflowStatus&) override;
+  bool IsLeafDynamic() const override;
+
+  nsresult GetContentForEvent(const mozilla::WidgetEvent*,
+                              nsIContent** aContent) final;
+  nsresult HandleEvent(nsPresContext*, mozilla::WidgetGUIEvent*,
+                       nsEventStatus*) override;
+  Cursor GetCursor(const nsPoint&) override;
+  nsresult AttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                            int32_t aModType) final;
+
+  void OnVisibilityChange(
+      Visibility aNewVisibility,
+      const Maybe<OnNonvisible>& aNonvisibleAction = Nothing()) final;
+
+  void ResponsiveContentDensityChanged();
+  void ElementStateChanged(mozilla::dom::ElementState) override;
+  void SetupOwnedRequest();
+  void DeinitOwnedRequest();
+  bool ShouldShowBrokenImageIcon() const;
+
+  bool IsForImageLoadingContent() const {
+    return mKind == Kind::ImageLoadingContent;
+  }
+
+  void UpdateXULImage();
+  const mozilla::StyleImage* GetImageFromStyle() const;
+
+#ifdef ACCESSIBILITY
+  mozilla::a11y::AccType AccessibleType() override;
+#endif
+
+#ifdef DEBUG_FRAME_DUMP
+  nsresult GetFrameName(nsAString& aResult) const override;
+  void List(FILE* out = stderr, const char* aPrefix = "",
+            ListFlags aFlags = ListFlags()) const final;
+#endif
+
+  LogicalSides GetLogicalSkipSides() const final;
+
+  static void ReleaseGlobals();
+
+  already_AddRefed<imgIRequest> GetCurrentRequest() const;
+  void Notify(imgIRequest*, int32_t aType, const nsIntRect* aData);
+
+  /**
+   * Returns whether we should replace an element with an image corresponding to
+   * its 'content' CSS property.
+   */
+  static bool ShouldCreateImageFrameForContentProperty(
+      const mozilla::dom::Element&, const ComputedStyle&);
+
+  /**
+   * Function to test whether given an element and its style, that element
+   * should get an image frame, and if so, which kind of image frame (for
+   * `content`, or for the element itself).
+   */
+  enum class ImageFrameType {
+    ForContentProperty,
+    ForElementRequest,
+    None,
+  };
+  static ImageFrameType ImageFrameTypeFor(const mozilla::dom::Element&,
+                                          const ComputedStyle&);
+
+  ImgDrawResult DisplayAltFeedback(gfxContext& aRenderingContext,
+                                   const nsRect& aDirtyRect, nsPoint aPt,
+                                   uint32_t aFlags);
+
+  ImgDrawResult DisplayAltFeedbackWithoutLayer(
+      nsDisplayItem*, mozilla::wr::DisplayListBuilder&,
+      mozilla::wr::IpcResourceUpdateQueue&,
+      const mozilla::layers::StackingContextHelper&,
+      mozilla::layers::RenderRootStateManager*, nsDisplayListBuilder*,
+      nsPoint aPt, uint32_t aFlags);
+
+  /**
+   * Return a map element associated with this image.
+   */
+  mozilla::dom::Element* GetMapElement() const;
+
+  /**
+   * Return true if the image has associated image map.
+   */
+  bool HasImageMap() const { return mImageMap || GetMapElement(); }
+
+  nsImageMap* GetImageMap();
+  nsImageMap* GetExistingImageMap() const { return mImageMap; }
+
+  void AddInlineMinISize(gfxContext* aRenderingContext,
+                         InlineMinISizeData* aData) final;
+
+  void DisconnectMap();
+
+  // nsIReflowCallback
+  bool ReflowFinished() final;
+  void ReflowCallbackCanceled() final;
+
+  // The kind of image frame we are.
+  enum class Kind : uint8_t {
+    // For an nsImageLoadingContent.
+    ImageLoadingContent,
+    // For a <xul:image> element.
+    XULImage,
+    // For css 'content: url(..)' on non-generated content.
+    ContentProperty,
+    // For a child of a ::before / ::after pseudo-element that had an url() item
+    // for the content property.
+    ContentPropertyAtIndex,
+    // For a list-style-image ::marker.
+    ListStyleImage,
+  };
+
+  // Creates a suitable continuing frame for this frame.
+  nsImageFrame* CreateContinuingFrame(mozilla::PresShell*,
+                                      ComputedStyle*) const;
+
+ private:
+  friend nsIFrame* NS_NewImageFrame(mozilla::PresShell*, ComputedStyle*);
+  friend nsIFrame* NS_NewXULImageFrame(mozilla::PresShell*, ComputedStyle*);
+  friend nsIFrame* NS_NewImageFrameForContentProperty(mozilla::PresShell*,
+                                                      ComputedStyle*);
+  friend nsIFrame* NS_NewImageFrameForGeneratedContentIndex(mozilla::PresShell*,
+                                                            ComputedStyle*);
+  friend nsIFrame* NS_NewImageFrameForListStyleImage(mozilla::PresShell*,
+                                                     ComputedStyle*);
+
+  nsImageFrame(ComputedStyle* aStyle, nsPresContext* aPresContext, Kind aKind)
+      : nsImageFrame(aStyle, aPresContext, kClassID, aKind) {}
+
+  nsImageFrame(ComputedStyle*, nsPresContext* aPresContext, ClassID, Kind);
+
+  void ReflowChildren(nsPresContext*, const ReflowInput&,
+                      const mozilla::LogicalSize& aImageSize);
+
+  void UpdateIntrinsicSizeAndRatio();
+
+ protected:
+  nsImageFrame(ComputedStyle* aStyle, nsPresContext* aPresContext, ClassID aID)
+      : nsImageFrame(aStyle, aPresContext, aID, Kind::ImageLoadingContent) {}
+
+  ~nsImageFrame() override;
+
+  void EnsureIntrinsicSizeAndRatio();
+
+  bool GotInitialReflow() const {
+    return !HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
+  }
+
+  SizeComputationResult ComputeSize(
+      gfxContext* aRenderingContext, mozilla::WritingMode aWM,
+      const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize,
+      const mozilla::LogicalSize& aMargin,
+      const mozilla::LogicalSize& aBorderPadding,
+      const mozilla::StyleSizeOverrides& aSizeOverrides,
+      mozilla::ComputeSizeFlags aFlags) final;
+
+  bool IsServerImageMap();
+
+  // Translate a point that is relative to our frame into a localized CSS pixel
+  // coordinate that is relative to the content area of this frame (inside the
+  // border+padding).
+  mozilla::CSSIntPoint TranslateEventCoords(const nsPoint& aPoint);
+
+  bool GetAnchorHREFTargetAndNode(nsIURI** aHref, nsString& aTarget,
+                                  nsIContent** aNode);
+  /**
+   * Computes the width of the string that fits into the available space
+   *
+   * @param in aLength total length of the string in PRUnichars
+   * @param in aMaxWidth width not to be exceeded
+   * @param out aMaxFit length of the string that fits within aMaxWidth
+   *            in PRUnichars
+   * @return width of the string that fits within aMaxWidth
+   */
+  nscoord MeasureString(const char16_t* aString, int32_t aLength,
+                        nscoord aMaxWidth, uint32_t& aMaxFit,
+                        gfxContext& aContext, nsFontMetrics& aFontMetrics);
+
+  void DisplayAltText(nsPresContext* aPresContext,
+                      gfxContext& aRenderingContext, const nsString& aAltText,
+                      const nsRect& aRect);
+
+  ImgDrawResult PaintImage(gfxContext& aRenderingContext, nsPoint aPt,
+                           const nsRect& aDirtyRect, imgIContainer* aImage,
+                           uint32_t aFlags);
+
+  /**
+   * If we're ready to decode - that is, if our current request's image is
+   * available and our decoding heuristics are satisfied - then trigger a decode
+   * for our image at the size we predict it will be drawn next time it's
+   * painted.
+   */
+  void MaybeDecodeForPredictedSize();
+
+  /**
+   * Is this frame part of a ::marker pseudo?
+   */
+  bool IsForMarkerPseudo() const;
+
+ protected:
+  friend class nsImageListener;
+  friend class nsImageLoadingContent;
+  friend class mozilla::PresShell;
+
+  void OnSizeAvailable(imgIRequest* aRequest, imgIContainer* aImage);
+  void OnFrameUpdate(imgIRequest* aRequest, const nsIntRect* aRect);
+  void OnLoadComplete(imgIRequest* aRequest, nsresult aStatus);
+
+  /**
+   * Notification that aRequest will now be the current request.
+   */
+  void NotifyNewCurrentRequest(imgIRequest* aRequest, nsresult aStatus);
+
+  /// Always sync decode our image when painting if @aForce is true.
+  void SetForceSyncDecoding(bool aForce) { mForceSyncDecoding = aForce; }
+
+  void AssertSyncDecodingHintIsInSync() const
+#ifndef DEBUG
+      {}
+#else
+      ;
+#endif
+
+  /**
+   * Computes the predicted dest rect that we'll draw into, in app units, based
+   * upon the provided frame content box. (The content box is what
+   * nsDisplayImage::GetBounds() returns.)
+   * The result is not necessarily contained in the frame content box.
+   */
+  nsRect PredictedDestRect(const nsRect& aFrameContentBox);
+
+ private:
+  nscoord GetContinuationOffset() const;
+  bool ShouldDisplaySelection();
+
+  // Whether the image frame should use the mapped aspect ratio from width=""
+  // and height="".
+  bool ShouldUseMappedAspectRatio() const;
+
+  // Recalculate mIntrinsicSize from the image.
+  bool UpdateIntrinsicSize();
+
+  // Recalculate mIntrinsicRatio from the image.
+  bool UpdateIntrinsicRatio();
+
+  /**
+   * This function calculates the transform for converting between
+   * source space & destination space. May fail if our image has a
+   * percent-valued or zero-valued height or width.
+   *
+   * @param aTransform The transform object to populate.
+   *
+   * @return whether we succeeded in creating the transform.
+   */
+  bool GetSourceToDestTransform(nsTransform2D& aTransform);
+
+  /**
+   * Helper function to check whether the request corresponds to a load we don't
+   * care about.  Most of the decoder observer methods will bail early if this
+   * returns true.
+   */
+  bool IsPendingLoad(imgIRequest*) const;
+
+  /**
+   * Updates mImage based on the current image request, and the image passed in
+   * (both can be null), and invalidate layout and paint as needed.
+   */
+  void UpdateImage(imgIRequest*, imgIContainer*);
+
+  /**
+   * Function to convert a dirty rect in the source image to a dirty
+   * rect for the image frame.
+   */
+  nsRect SourceRectToDest(const nsIntRect& aRect);
+
+  /**
+   * Triggers invalidation for both our image display item and, if appropriate,
+   * our alt-feedback display item.
+   *
+   * @param aLayerInvalidRect The area to invalidate in layer space. If null,
+   * the entire layer will be invalidated.
+   * @param aFrameInvalidRect The area to invalidate in frame space. If null,
+   * the entire frame will be invalidated.
+   */
+  void InvalidateSelf(const nsIntRect* aLayerInvalidRect,
+                      const nsRect* aFrameInvalidRect);
+
+  void MaybeSendIntrinsicSizeAndRatioToEmbedder();
+  void MaybeSendIntrinsicSizeAndRatioToEmbedder(Maybe<mozilla::IntrinsicSize>,
+                                                Maybe<mozilla::AspectRatio>);
+
+  RefPtr<nsImageMap> mImageMap;
+
+  RefPtr<nsImageListener> mListener;
+
+  // An image request created for content: url(..), list-style-image, or
+  // <xul:image>.
+  RefPtr<imgRequestProxy> mOwnedRequest;
+
+  nsCOMPtr<imgIContainer> mImage;
+  nsCOMPtr<imgIContainer> mPrevImage;
+
+  // The content-box size as if we are not fragmented, cached in the most recent
+  // reflow.
+  nsSize mComputedSize;
+
+  mozilla::IntrinsicSize mIntrinsicSize;
+
+  // Stores mImage's intrinsic ratio, or a default AspectRatio if there's no
+  // intrinsic ratio.
+  mozilla::AspectRatio mIntrinsicRatio;
+
+  const Kind mKind;
+  bool mOwnedRequestRegistered = false;
+  bool mDisplayingIcon = false;
+  bool mFirstFrameComplete = false;
+  bool mReflowCallbackPosted = false;
+  bool mForceSyncDecoding = false;
+  bool mIsInObjectOrEmbed = false;
+
+ public:
+  friend class mozilla::nsDisplayImage;
+  friend class nsDisplayGradient;
+};
+
+namespace mozilla {
+/**
+ * Note that nsDisplayImage does not receive events. However, an image element
+ * is replaced content so its background will be z-adjacent to the
+ * image itself, and hence receive events just as if the image itself
+ * received events.
+ */
+class nsDisplayImage final : public nsPaintedDisplayItem {
+ public:
+  typedef mozilla::layers::LayerManager LayerManager;
+
+  nsDisplayImage(nsDisplayListBuilder* aBuilder, nsImageFrame* aFrame,
+                 imgIContainer* aImage, imgIContainer* aPrevImage)
+      : nsPaintedDisplayItem(aBuilder, aFrame),
+        mImage(aImage),
+        mPrevImage(aPrevImage) {
+    MOZ_COUNT_CTOR(nsDisplayImage);
+  }
+  ~nsDisplayImage() final { MOZ_COUNT_DTOR(nsDisplayImage); }
+
+  void Paint(nsDisplayListBuilder*, gfxContext* aCtx) final;
+
+  /**
+   * @return The dest rect we'll use when drawing this image, in app units.
+   *         Not necessarily contained in this item's bounds.
+   */
+  nsRect GetDestRect() const;
+
+  nsRect GetBounds(bool* aSnap) const {
+    *aSnap = true;
+    return Frame()->GetContentRectRelativeToSelf() + ToReferenceFrame();
+  }
+
+  nsRect GetBounds(nsDisplayListBuilder*, bool* aSnap) const final {
+    return GetBounds(aSnap);
+  }
+
+  nsRegion GetOpaqueRegion(nsDisplayListBuilder*, bool* aSnap) const final;
+
+  bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder&,
+                               mozilla::wr::IpcResourceUpdateQueue&,
+                               const StackingContextHelper&,
+                               mozilla::layers::RenderRootStateManager*,
+                               nsDisplayListBuilder*) final;
+
+  NS_DISPLAY_DECL_NAME("Image", TYPE_IMAGE)
+ private:
+  nsCOMPtr<imgIContainer> mImage;
+  nsCOMPtr<imgIContainer> mPrevImage;
+};
+
+}  // namespace mozilla
+
+#endif /* nsImageFrame_h___ */