summaryrefslogtreecommitdiffstats
path: root/layout/svg/SVGImageFrame.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /layout/svg/SVGImageFrame.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'layout/svg/SVGImageFrame.cpp')
-rw-r--r--layout/svg/SVGImageFrame.cpp909
1 files changed, 909 insertions, 0 deletions
diff --git a/layout/svg/SVGImageFrame.cpp b/layout/svg/SVGImageFrame.cpp
new file mode 100644
index 0000000000..242ee6e25e
--- /dev/null
+++ b/layout/svg/SVGImageFrame.cpp
@@ -0,0 +1,909 @@
+/* -*- 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/. */
+
+#include "SVGImageFrame.h"
+
+// Keep in (case-insensitive) order:
+#include "gfxContext.h"
+#include "gfxPlatform.h"
+#include "mozilla/ComputedStyleInlines.h"
+#include "mozilla/image/WebRenderImageProvider.h"
+#include "mozilla/layers/RenderRootStateManager.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "imgIContainer.h"
+#include "ImageRegion.h"
+#include "nsContainerFrame.h"
+#include "nsIImageLoadingContent.h"
+#include "nsLayoutUtils.h"
+#include "imgINotificationObserver.h"
+#include "SVGGeometryProperty.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_image.h"
+#include "mozilla/SVGContentUtils.h"
+#include "mozilla/SVGImageContext.h"
+#include "mozilla/SVGObserverUtils.h"
+#include "mozilla/SVGUtils.h"
+#include "mozilla/dom/MutationEventBinding.h"
+#include "mozilla/dom/SVGImageElement.h"
+#include "mozilla/dom/LargestContentfulPaint.h"
+#include "nsIReflowCallback.h"
+
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+using namespace mozilla::image;
+using namespace mozilla::dom::SVGPreserveAspectRatio_Binding;
+namespace SVGT = SVGGeometryProperty::Tags;
+
+namespace mozilla {
+
+class SVGImageListener final : public imgINotificationObserver {
+ public:
+ explicit SVGImageListener(SVGImageFrame* aFrame);
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_IMGINOTIFICATIONOBSERVER
+
+ void SetFrame(SVGImageFrame* frame) { mFrame = frame; }
+
+ private:
+ ~SVGImageListener() = default;
+
+ SVGImageFrame* mFrame;
+};
+
+// ---------------------------------------------------------------------
+// nsQueryFrame methods
+
+NS_QUERYFRAME_HEAD(SVGImageFrame)
+ NS_QUERYFRAME_ENTRY(ISVGDisplayableFrame)
+ NS_QUERYFRAME_ENTRY(SVGImageFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsIFrame)
+
+} // namespace mozilla
+
+nsIFrame* NS_NewSVGImageFrame(mozilla::PresShell* aPresShell,
+ mozilla::ComputedStyle* aStyle) {
+ return new (aPresShell)
+ mozilla::SVGImageFrame(aStyle, aPresShell->GetPresContext());
+}
+
+namespace mozilla {
+
+NS_IMPL_FRAMEARENA_HELPERS(SVGImageFrame)
+
+SVGImageFrame::~SVGImageFrame() {
+ // set the frame to null so we don't send messages to a dead object.
+ if (mListener) {
+ nsCOMPtr<nsIImageLoadingContent> imageLoader =
+ do_QueryInterface(GetContent());
+ if (imageLoader) {
+ imageLoader->RemoveNativeObserver(mListener);
+ }
+ reinterpret_cast<SVGImageListener*>(mListener.get())->SetFrame(nullptr);
+ }
+ mListener = nullptr;
+}
+
+void SVGImageFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
+ nsIFrame* aPrevInFlow) {
+ NS_ASSERTION(aContent->IsSVGElement(nsGkAtoms::image),
+ "Content is not an SVG image!");
+
+ AddStateBits(aParent->GetStateBits() & NS_STATE_SVG_CLIPPATH_CHILD);
+ nsIFrame::Init(aContent, aParent, aPrevInFlow);
+
+ if (HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) {
+ // Non-display frames are likely to be patterns, masks or the like.
+ // Treat them as always visible.
+ // This call must happen before the FrameCreated. This is because the
+ // primary frame pointer on our content node isn't set until after this
+ // function ends, so there is no way for the resulting OnVisibilityChange
+ // notification to get a frame. FrameCreated has a workaround for this in
+ // that it passes our frame around so it can be accessed. OnVisibilityChange
+ // doesn't have that workaround.
+ IncApproximateVisibleCount();
+ }
+
+ mListener = new SVGImageListener(this);
+ nsCOMPtr<nsIImageLoadingContent> imageLoader =
+ do_QueryInterface(GetContent());
+ if (!imageLoader) {
+ MOZ_CRASH("Why is this not an image loading content?");
+ }
+
+ // We should have a PresContext now, so let's notify our image loader that
+ // we need to register any image animations with the refresh driver.
+ imageLoader->FrameCreated(this);
+
+ imageLoader->AddNativeObserver(mListener);
+}
+
+/* virtual */
+void SVGImageFrame::Destroy(DestroyContext& aContext) {
+ if (HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) {
+ DecApproximateVisibleCount();
+ }
+
+ if (mReflowCallbackPosted) {
+ PresShell()->CancelReflowCallback(this);
+ mReflowCallbackPosted = false;
+ }
+
+ nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
+
+ if (imageLoader) {
+ imageLoader->FrameDestroyed(this);
+ }
+
+ nsIFrame::Destroy(aContext);
+}
+
+/* virtual */
+void SVGImageFrame::DidSetComputedStyle(ComputedStyle* aOldStyle) {
+ nsIFrame::DidSetComputedStyle(aOldStyle);
+
+ if (!mImageContainer || !aOldStyle) {
+ return;
+ }
+
+ nsCOMPtr<imgIRequest> currentRequest;
+ nsCOMPtr<nsIImageLoadingContent> imageLoader =
+ do_QueryInterface(GetContent());
+ if (imageLoader) {
+ imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+ getter_AddRefs(currentRequest));
+ }
+
+ StyleImageOrientation newOrientation =
+ StyleVisibility()->UsedImageOrientation(currentRequest);
+ StyleImageOrientation oldOrientation =
+ aOldStyle->StyleVisibility()->UsedImageOrientation(currentRequest);
+
+ if (oldOrientation != newOrientation) {
+ nsCOMPtr<imgIContainer> image(mImageContainer->Unwrap());
+ mImageContainer = nsLayoutUtils::OrientImage(image, newOrientation);
+ }
+
+ // TODO(heycam): We should handle aspect-ratio, like nsImageFrame does.
+}
+
+bool SVGImageFrame::IsSVGTransformed(gfx::Matrix* aOwnTransform,
+ gfx::Matrix* aFromParentTransform) const {
+ return SVGUtils::IsSVGTransformed(this, aOwnTransform, aFromParentTransform);
+}
+
+//----------------------------------------------------------------------
+// nsIFrame methods:
+
+nsresult SVGImageFrame::AttributeChanged(int32_t aNameSpaceID,
+ nsAtom* aAttribute, int32_t aModType) {
+ if (aNameSpaceID == kNameSpaceID_None) {
+ if (aAttribute == nsGkAtoms::preserveAspectRatio) {
+ // We don't paint the content of the image using display lists, therefore
+ // we have to invalidate for this children-only transform changes since
+ // there is no layer tree to notice that the transform changed and
+ // recomposite.
+ InvalidateFrame();
+ return NS_OK;
+ }
+ }
+
+ // Currently our SMIL implementation does not modify the DOM attributes. Once
+ // we implement the SVG 2 SMIL behaviour this can be removed
+ // SVGImageElement::AfterSetAttr's implementation will be sufficient.
+ if (aModType == MutationEvent_Binding::SMIL &&
+ aAttribute == nsGkAtoms::href &&
+ (aNameSpaceID == kNameSpaceID_XLink ||
+ aNameSpaceID == kNameSpaceID_None)) {
+ SVGImageElement* element = static_cast<SVGImageElement*>(GetContent());
+
+ bool hrefIsSet =
+ element->mStringAttributes[SVGImageElement::HREF].IsExplicitlySet() ||
+ element->mStringAttributes[SVGImageElement::XLINK_HREF]
+ .IsExplicitlySet();
+ if (hrefIsSet) {
+ element->LoadSVGImage(true, true);
+ } else {
+ element->CancelImageRequests(true);
+ }
+ }
+
+ return NS_OK;
+}
+
+void SVGImageFrame::OnVisibilityChange(
+ Visibility aNewVisibility, const Maybe<OnNonvisible>& aNonvisibleAction) {
+ nsCOMPtr<nsIImageLoadingContent> imageLoader =
+ do_QueryInterface(GetContent());
+ if (imageLoader) {
+ imageLoader->OnVisibilityChange(aNewVisibility, aNonvisibleAction);
+ }
+
+ nsIFrame::OnVisibilityChange(aNewVisibility, aNonvisibleAction);
+}
+
+gfx::Matrix SVGImageFrame::GetRasterImageTransform(int32_t aNativeWidth,
+ int32_t aNativeHeight) {
+ float x, y, width, height;
+ SVGImageElement* element = static_cast<SVGImageElement*>(GetContent());
+ SVGGeometryProperty::ResolveAll<SVGT::X, SVGT::Y, SVGT::Width, SVGT::Height>(
+ element, &x, &y, &width, &height);
+
+ Matrix viewBoxTM = SVGContentUtils::GetViewBoxTransform(
+ width, height, 0, 0, aNativeWidth, aNativeHeight,
+ element->mPreserveAspectRatio);
+
+ return viewBoxTM * gfx::Matrix::Translation(x, y);
+}
+
+gfx::Matrix SVGImageFrame::GetVectorImageTransform() {
+ float x, y;
+ SVGImageElement* element = static_cast<SVGImageElement*>(GetContent());
+ SVGGeometryProperty::ResolveAll<SVGT::X, SVGT::Y>(element, &x, &y);
+
+ // No viewBoxTM needed here -- our height/width overrides any concept of
+ // "native size" that the SVG image has, and it will handle viewBox and
+ // preserveAspectRatio on its own once we give it a region to draw into.
+
+ return gfx::Matrix::Translation(x, y);
+}
+
+bool SVGImageFrame::GetIntrinsicImageDimensions(
+ mozilla::gfx::Size& aSize, mozilla::AspectRatio& aAspectRatio) const {
+ if (!mImageContainer) {
+ return false;
+ }
+
+ ImageResolution resolution = mImageContainer->GetResolution();
+
+ int32_t width, height;
+ if (NS_FAILED(mImageContainer->GetWidth(&width))) {
+ aSize.width = -1;
+ } else {
+ aSize.width = width;
+ resolution.ApplyXTo(aSize.width);
+ }
+
+ if (NS_FAILED(mImageContainer->GetHeight(&height))) {
+ aSize.height = -1;
+ } else {
+ aSize.height = height;
+ resolution.ApplyYTo(aSize.height);
+ }
+
+ Maybe<AspectRatio> asp = mImageContainer->GetIntrinsicRatio();
+ aAspectRatio = asp.valueOr(AspectRatio{});
+
+ return true;
+}
+
+bool SVGImageFrame::TransformContextForPainting(gfxContext* aGfxContext,
+ const gfxMatrix& aTransform) {
+ gfx::Matrix imageTransform;
+ if (mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) {
+ imageTransform = GetVectorImageTransform() * ToMatrix(aTransform);
+ } else {
+ int32_t nativeWidth, nativeHeight;
+ if (NS_FAILED(mImageContainer->GetWidth(&nativeWidth)) ||
+ NS_FAILED(mImageContainer->GetHeight(&nativeHeight)) ||
+ nativeWidth == 0 || nativeHeight == 0) {
+ return false;
+ }
+ mImageContainer->GetResolution().ApplyTo(nativeWidth, nativeHeight);
+ imageTransform = GetRasterImageTransform(nativeWidth, nativeHeight) *
+ ToMatrix(aTransform);
+
+ // NOTE: We need to cancel out the effects of Full-Page-Zoom, or else
+ // it'll get applied an extra time by DrawSingleUnscaledImage.
+ nscoord appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
+ gfxFloat pageZoomFactor =
+ nsPresContext::AppUnitsToFloatCSSPixels(appUnitsPerDevPx);
+ imageTransform.PreScale(pageZoomFactor, pageZoomFactor);
+ }
+
+ if (imageTransform.IsSingular()) {
+ return false;
+ }
+
+ aGfxContext->Multiply(ThebesMatrix(imageTransform));
+ return true;
+}
+
+//----------------------------------------------------------------------
+// ISVGDisplayableFrame methods
+
+void SVGImageFrame::PaintSVG(gfxContext& aContext, const gfxMatrix& aTransform,
+ imgDrawingParams& aImgParams) {
+ if (!StyleVisibility()->IsVisible()) {
+ return;
+ }
+
+ float x, y, width, height;
+ SVGImageElement* imgElem = static_cast<SVGImageElement*>(GetContent());
+ SVGGeometryProperty::ResolveAll<SVGT::X, SVGT::Y, SVGT::Width, SVGT::Height>(
+ imgElem, &x, &y, &width, &height);
+ NS_ASSERTION(width > 0 && height > 0,
+ "Should only be painting things with valid width/height");
+
+ if (!mImageContainer) {
+ nsCOMPtr<imgIRequest> currentRequest;
+ nsCOMPtr<nsIImageLoadingContent> imageLoader =
+ do_QueryInterface(GetContent());
+ if (imageLoader)
+ imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+ getter_AddRefs(currentRequest));
+
+ if (currentRequest)
+ currentRequest->GetImage(getter_AddRefs(mImageContainer));
+ }
+
+ if (mImageContainer) {
+ gfxClipAutoSaveRestore autoSaveClip(&aContext);
+
+ if (StyleDisplay()->IsScrollableOverflow()) {
+ gfxRect clipRect =
+ SVGUtils::GetClipRectForFrame(this, x, y, width, height);
+ autoSaveClip.TransformedClip(aTransform, clipRect);
+ }
+
+ gfxContextMatrixAutoSaveRestore autoSaveMatrix(&aContext);
+
+ if (!TransformContextForPainting(&aContext, aTransform)) {
+ return;
+ }
+
+ // fill-opacity doesn't affect <image>, so if we're allowed to
+ // optimize group opacity, the opacity used for compositing the
+ // image into the current canvas is just the group opacity.
+ float opacity = 1.0f;
+ if (SVGUtils::CanOptimizeOpacity(this)) {
+ opacity = StyleEffects()->mOpacity;
+ }
+
+ gfxGroupForBlendAutoSaveRestore autoGroupForBlend(&aContext);
+ if (opacity != 1.0f || StyleEffects()->HasMixBlendMode()) {
+ autoGroupForBlend.PushGroupForBlendBack(gfxContentType::COLOR_ALPHA,
+ opacity);
+ }
+
+ nscoord appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
+ uint32_t flags = aImgParams.imageFlags;
+ if (mForceSyncDecoding) {
+ flags |= imgIContainer::FLAG_SYNC_DECODE;
+ }
+
+ if (mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) {
+ // Package up the attributes of this image element which can override the
+ // attributes of mImageContainer's internal SVG document. The 'width' &
+ // 'height' values we're passing in here are in CSS units (though they
+ // come from width/height *attributes* in SVG). They influence the region
+ // of the SVG image's internal document that is visible, in combination
+ // with preserveAspectRatio and viewBox.
+ const SVGImageContext context(
+ Some(CSSIntSize::Ceil(width, height)),
+ Some(imgElem->mPreserveAspectRatio.GetAnimValue()));
+
+ // For the actual draw operation to draw crisply (and at the right size),
+ // our destination rect needs to be |width|x|height|, *in dev pixels*.
+ LayoutDeviceSize devPxSize(width, height);
+ nsRect destRect(nsPoint(), LayoutDevicePixel::ToAppUnits(
+ devPxSize, appUnitsPerDevPx));
+ nsCOMPtr<imgIRequest> currentRequest = GetCurrentRequest();
+ if (currentRequest) {
+ LCPHelpers::FinalizeLCPEntryForImage(
+ GetContent()->AsElement(),
+ static_cast<imgRequestProxy*>(currentRequest.get()), destRect);
+ }
+
+ // Note: Can't use DrawSingleUnscaledImage for the TYPE_VECTOR case.
+ // That method needs our image to have a fixed native width & height,
+ // and that's not always true for TYPE_VECTOR images.
+ aImgParams.result &= nsLayoutUtils::DrawSingleImage(
+ aContext, PresContext(), mImageContainer,
+ nsLayoutUtils::GetSamplingFilterForFrame(this), destRect, destRect,
+ context, flags);
+ } else { // mImageContainer->GetType() == TYPE_RASTER
+ aImgParams.result &= nsLayoutUtils::DrawSingleUnscaledImage(
+ aContext, PresContext(), mImageContainer,
+ nsLayoutUtils::GetSamplingFilterForFrame(this), nsPoint(0, 0),
+ nullptr, SVGImageContext(), flags);
+ }
+ }
+}
+
+void SVGImageFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+ const nsDisplayListSet& aLists) {
+ if (!static_cast<const SVGElement*>(GetContent())->HasValidDimensions()) {
+ return;
+ }
+
+ if (aBuilder->IsForPainting()) {
+ if (!IsVisibleForPainting()) {
+ return;
+ }
+ if (StyleEffects()->IsTransparent()) {
+ return;
+ }
+ aBuilder->BuildCompositorHitTestInfoIfNeeded(this,
+ aLists.BorderBackground());
+ }
+
+ DisplayOutline(aBuilder, aLists);
+ aLists.Content()->AppendNewToTop<DisplaySVGImage>(aBuilder, this);
+}
+
+bool SVGImageFrame::IsInvisible() const {
+ if (!StyleVisibility()->IsVisible()) {
+ return true;
+ }
+
+ // Anything below will round to zero later down the pipeline.
+ constexpr float opacity_threshold = 1.0 / 128.0;
+
+ return StyleEffects()->mOpacity <= opacity_threshold;
+}
+
+bool SVGImageFrame::CreateWebRenderCommands(
+ mozilla::wr::DisplayListBuilder& aBuilder,
+ mozilla::wr::IpcResourceUpdateQueue& aResources,
+ const mozilla::layers::StackingContextHelper& aSc,
+ mozilla::layers::RenderRootStateManager* aManager,
+ nsDisplayListBuilder* aDisplayListBuilder, DisplaySVGImage* aItem,
+ bool aDryRun) {
+ if (!StyleVisibility()->IsVisible()) {
+ return true;
+ }
+
+ float opacity = 1.0f;
+ if (SVGUtils::CanOptimizeOpacity(this)) {
+ opacity = StyleEffects()->mOpacity;
+ }
+
+ if (opacity != 1.0f) {
+ // FIXME: not implemented, might be trivial
+ return false;
+ }
+ if (StyleEffects()->HasMixBlendMode()) {
+ // FIXME: not implemented
+ return false;
+ }
+
+ // try to setup the image
+ if (!mImageContainer) {
+ nsCOMPtr<imgIRequest> currentRequest = GetCurrentRequest();
+ if (currentRequest) {
+ currentRequest->GetImage(getter_AddRefs(mImageContainer));
+ }
+ }
+
+ if (!mImageContainer) {
+ // nothing to draw (yet)
+ return true;
+ }
+
+ uint32_t flags = aDisplayListBuilder->GetImageDecodeFlags();
+ if (mForceSyncDecoding) {
+ flags |= imgIContainer::FLAG_SYNC_DECODE;
+ }
+
+ // Compute bounds of the image
+ nscoord appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
+ int32_t appUnitsPerCSSPixel = AppUnitsPerCSSPixel();
+
+ float x, y, width, height;
+ SVGImageElement* imgElem = static_cast<SVGImageElement*>(GetContent());
+ SVGGeometryProperty::ResolveAll<SVGT::X, SVGT::Y, SVGT::Width, SVGT::Height>(
+ imgElem, &x, &y, &width, &height);
+ NS_ASSERTION(width > 0 && height > 0,
+ "Should only be painting things with valid width/height");
+
+ auto toReferenceFrame = aItem->ToReferenceFrame();
+ auto appRect = nsLayoutUtils::RoundGfxRectToAppRect(Rect(0, 0, width, height),
+ appUnitsPerCSSPixel);
+ appRect += toReferenceFrame;
+ auto destRect = LayoutDeviceRect::FromAppUnits(appRect, appUnitsPerDevPx);
+ auto clipRect = destRect;
+
+ if (StyleDisplay()->IsScrollableOverflow()) {
+ // Apply potential non-trivial clip
+ auto cssClip = SVGUtils::GetClipRectForFrame(this, 0, 0, width, height);
+ auto appClip =
+ nsLayoutUtils::RoundGfxRectToAppRect(cssClip, appUnitsPerCSSPixel);
+ appClip += toReferenceFrame;
+ clipRect = LayoutDeviceRect::FromAppUnits(appClip, appUnitsPerDevPx);
+
+ // Apply preserveAspectRatio
+ if (mImageContainer->GetType() == imgIContainer::TYPE_RASTER) {
+ int32_t nativeWidth, nativeHeight;
+ if (NS_FAILED(mImageContainer->GetWidth(&nativeWidth)) ||
+ NS_FAILED(mImageContainer->GetHeight(&nativeHeight)) ||
+ nativeWidth == 0 || nativeHeight == 0) {
+ // Image has no size; nothing to draw
+ return true;
+ }
+
+ mImageContainer->GetResolution().ApplyTo(nativeWidth, nativeHeight);
+
+ auto preserveAspectRatio = imgElem->mPreserveAspectRatio.GetAnimValue();
+ uint16_t align = preserveAspectRatio.GetAlign();
+ uint16_t meetOrSlice = preserveAspectRatio.GetMeetOrSlice();
+
+ // default to the defaults
+ if (align == SVG_PRESERVEASPECTRATIO_UNKNOWN) {
+ align = SVG_PRESERVEASPECTRATIO_XMIDYMID;
+ }
+ if (meetOrSlice == SVG_MEETORSLICE_UNKNOWN) {
+ meetOrSlice = SVG_MEETORSLICE_MEET;
+ }
+
+ // aspect > 1 is horizontal
+ // aspect < 1 is vertical
+ float nativeAspect = ((float)nativeWidth) / ((float)nativeHeight);
+ float viewAspect = width / height;
+
+ // "Meet" is "fit image to view"; "Slice" is "cover view with image".
+ //
+ // Whether we meet or slice, one side of the destRect will always be
+ // perfectly spanned by our image. The only questions to answer are
+ // "which side won't span perfectly" and "should that side be grown
+ // or shrunk".
+ //
+ // Because we fit our image to the destRect, this all just reduces to:
+ // "if meet, shrink to fit. if slice, grow to fit."
+ if (align != SVG_PRESERVEASPECTRATIO_NONE && nativeAspect != viewAspect) {
+ // Slightly redundant bools, but they make the conditions clearer
+ bool tooTall = nativeAspect > viewAspect;
+ bool tooWide = nativeAspect < viewAspect;
+ if ((meetOrSlice == SVG_MEETORSLICE_MEET && tooTall) ||
+ (meetOrSlice == SVG_MEETORSLICE_SLICE && tooWide)) {
+ // Adjust height and realign y
+ auto oldHeight = destRect.height;
+ destRect.height = destRect.width / nativeAspect;
+ auto heightChange = oldHeight - destRect.height;
+ switch (align) {
+ case SVG_PRESERVEASPECTRATIO_XMINYMIN:
+ case SVG_PRESERVEASPECTRATIO_XMIDYMIN:
+ case SVG_PRESERVEASPECTRATIO_XMAXYMIN:
+ // align to top (no-op)
+ break;
+ case SVG_PRESERVEASPECTRATIO_XMINYMID:
+ case SVG_PRESERVEASPECTRATIO_XMIDYMID:
+ case SVG_PRESERVEASPECTRATIO_XMAXYMID:
+ // align to center
+ destRect.y += heightChange / 2.0f;
+ break;
+ case SVG_PRESERVEASPECTRATIO_XMINYMAX:
+ case SVG_PRESERVEASPECTRATIO_XMIDYMAX:
+ case SVG_PRESERVEASPECTRATIO_XMAXYMAX:
+ // align to bottom
+ destRect.y += heightChange;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unknown value for align");
+ }
+ } else if ((meetOrSlice == SVG_MEETORSLICE_MEET && tooWide) ||
+ (meetOrSlice == SVG_MEETORSLICE_SLICE && tooTall)) {
+ // Adjust width and realign x
+ auto oldWidth = destRect.width;
+ destRect.width = destRect.height * nativeAspect;
+ auto widthChange = oldWidth - destRect.width;
+ switch (align) {
+ case SVG_PRESERVEASPECTRATIO_XMINYMIN:
+ case SVG_PRESERVEASPECTRATIO_XMINYMID:
+ case SVG_PRESERVEASPECTRATIO_XMINYMAX:
+ // align to left (no-op)
+ break;
+ case SVG_PRESERVEASPECTRATIO_XMIDYMIN:
+ case SVG_PRESERVEASPECTRATIO_XMIDYMID:
+ case SVG_PRESERVEASPECTRATIO_XMIDYMAX:
+ // align to center
+ destRect.x += widthChange / 2.0f;
+ break;
+ case SVG_PRESERVEASPECTRATIO_XMAXYMIN:
+ case SVG_PRESERVEASPECTRATIO_XMAXYMID:
+ case SVG_PRESERVEASPECTRATIO_XMAXYMAX:
+ // align to right
+ destRect.x += widthChange;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unknown value for align");
+ }
+ }
+ }
+ }
+ }
+
+ SVGImageContext svgContext;
+ if (mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) {
+ if (StaticPrefs::image_svg_blob_image()) {
+ flags |= imgIContainer::FLAG_RECORD_BLOB;
+ }
+ // Forward preserveAspectRatio to inner SVGs
+ svgContext.SetViewportSize(Some(CSSIntSize::Ceil(width, height)));
+ svgContext.SetPreserveAspectRatio(
+ Some(imgElem->mPreserveAspectRatio.GetAnimValue()));
+ }
+
+ Maybe<ImageIntRegion> region;
+ IntSize decodeSize = nsLayoutUtils::ComputeImageContainerDrawingParameters(
+ mImageContainer, this, destRect, clipRect, aSc, flags, svgContext,
+ region);
+
+ if (nsCOMPtr<imgIRequest> currentRequest = GetCurrentRequest()) {
+ LCPHelpers::FinalizeLCPEntryForImage(
+ GetContent()->AsElement(),
+ static_cast<imgRequestProxy*>(currentRequest.get()),
+ LayoutDeviceRect::ToAppUnits(destRect, appUnitsPerDevPx) -
+ toReferenceFrame);
+ }
+
+ RefPtr<image::WebRenderImageProvider> provider;
+ ImgDrawResult drawResult = mImageContainer->GetImageProvider(
+ aManager->LayerManager(), decodeSize, svgContext, region, flags,
+ getter_AddRefs(provider));
+
+ // While we got a container, it may not contain a fully decoded surface. If
+ // that is the case, and we have an image we were previously displaying which
+ // has a fully decoded surface, then we should prefer the previous image.
+ switch (drawResult) {
+ case ImgDrawResult::NOT_READY:
+ case ImgDrawResult::TEMPORARY_ERROR:
+ // nothing to draw (yet)
+ return true;
+ case ImgDrawResult::NOT_SUPPORTED:
+ // things we haven't implemented for WR yet
+ return false;
+ default:
+ // image is ready to draw
+ break;
+ }
+
+ // Don't do any actual mutations to state if we're doing a dry run
+ // (used to decide if we're making this into an active layer)
+ if (!aDryRun) {
+ // If the image container is empty, we don't want to fallback. Any other
+ // failure will be due to resource constraints and fallback is unlikely to
+ // help us. Hence we can ignore the return value from PushImage.
+ if (provider) {
+ aManager->CommandBuilder().PushImageProvider(aItem, provider, drawResult,
+ aBuilder, aResources,
+ destRect, clipRect);
+ }
+ }
+
+ return true;
+}
+
+nsIFrame* SVGImageFrame::GetFrameForPoint(const gfxPoint& aPoint) {
+ if (!HasAnyStateBits(NS_STATE_SVG_CLIPPATH_CHILD) && IgnoreHitTest()) {
+ return nullptr;
+ }
+
+ Rect rect;
+ SVGImageElement* element = static_cast<SVGImageElement*>(GetContent());
+ SVGGeometryProperty::ResolveAll<SVGT::X, SVGT::Y, SVGT::Width, SVGT::Height>(
+ element, &rect.x, &rect.y, &rect.width, &rect.height);
+
+ if (!rect.Contains(ToPoint(aPoint))) {
+ return nullptr;
+ }
+
+ // Special case for raster images -- we only want to accept points that fall
+ // in the underlying image's (scaled to fit) native bounds. That region
+ // doesn't necessarily map to our <image> element's [x,y,width,height] if the
+ // raster image's aspect ratio is being preserved. We have to look up the
+ // native image size & our viewBox transform in order to filter out points
+ // that fall outside that area. (This special case doesn't apply to vector
+ // images because they don't limit their drawing to explicit "native
+ // bounds" -- they have an infinite canvas on which to place content.)
+ if (StyleDisplay()->IsScrollableOverflow() && mImageContainer) {
+ if (mImageContainer->GetType() == imgIContainer::TYPE_RASTER) {
+ int32_t nativeWidth, nativeHeight;
+ if (NS_FAILED(mImageContainer->GetWidth(&nativeWidth)) ||
+ NS_FAILED(mImageContainer->GetHeight(&nativeHeight)) ||
+ nativeWidth == 0 || nativeHeight == 0) {
+ return nullptr;
+ }
+ mImageContainer->GetResolution().ApplyTo(nativeWidth, nativeHeight);
+ Matrix viewBoxTM = SVGContentUtils::GetViewBoxTransform(
+ rect.width, rect.height, 0, 0, nativeWidth, nativeHeight,
+ element->mPreserveAspectRatio);
+ if (!SVGUtils::HitTestRect(viewBoxTM, 0, 0, nativeWidth, nativeHeight,
+ aPoint.x - rect.x, aPoint.y - rect.y)) {
+ return nullptr;
+ }
+ }
+ }
+
+ return this;
+}
+
+void SVGImageFrame::ReflowSVG() {
+ NS_ASSERTION(SVGUtils::OuterSVGIsCallingReflowSVG(this),
+ "This call is probably a wasteful mistake");
+
+ MOZ_ASSERT(!HasAnyStateBits(NS_FRAME_IS_NONDISPLAY),
+ "ReflowSVG mechanism not designed for this");
+
+ if (!SVGUtils::NeedsReflowSVG(this)) {
+ return;
+ }
+
+ float x, y, width, height;
+ SVGImageElement* element = static_cast<SVGImageElement*>(GetContent());
+ SVGGeometryProperty::ResolveAll<SVGT::X, SVGT::Y, SVGT::Width, SVGT::Height>(
+ element, &x, &y, &width, &height);
+
+ Rect extent(x, y, width, height);
+
+ if (!extent.IsEmpty()) {
+ mRect = nsLayoutUtils::RoundGfxRectToAppRect(extent, AppUnitsPerCSSPixel());
+ } else {
+ mRect.SetEmpty();
+ }
+
+ if (HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
+ // Make sure we have our filter property (if any) before calling
+ // FinishAndStoreOverflow (subsequent filter changes are handled off
+ // nsChangeHint_UpdateEffects):
+ SVGObserverUtils::UpdateEffects(this);
+
+ if (!mReflowCallbackPosted) {
+ mReflowCallbackPosted = true;
+ PresShell()->PostReflowCallback(this);
+ }
+ }
+
+ nsRect overflow = nsRect(nsPoint(0, 0), mRect.Size());
+ OverflowAreas overflowAreas(overflow, overflow);
+ FinishAndStoreOverflow(overflowAreas, mRect.Size());
+
+ RemoveStateBits(NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY |
+ NS_FRAME_HAS_DIRTY_CHILDREN);
+
+ // Invalidate, but only if this is not our first reflow (since if it is our
+ // first reflow then we haven't had our first paint yet).
+ if (!GetParent()->HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
+ InvalidateFrame();
+ }
+}
+
+bool SVGImageFrame::ReflowFinished() {
+ mReflowCallbackPosted = false;
+
+ // XXX(seth): We don't need this. The purpose of updating visibility
+ // synchronously is to ensure that animated images start animating
+ // immediately. In the short term, however,
+ // nsImageLoadingContent::OnUnlockedDraw() is enough to ensure that
+ // animations start as soon as the image is painted for the first time, and in
+ // the long term we want to update visibility information from the display
+ // list whenever we paint, so we don't actually need to do this. However, to
+ // avoid behavior changes during the transition from the old image visibility
+ // code, we'll leave it in for now.
+ UpdateVisibilitySynchronously();
+
+ return false;
+}
+
+void SVGImageFrame::ReflowCallbackCanceled() { mReflowCallbackPosted = false; }
+
+already_AddRefed<imgIRequest> SVGImageFrame::GetCurrentRequest() const {
+ nsCOMPtr<imgIRequest> request;
+ nsCOMPtr<nsIImageLoadingContent> imageLoader =
+ do_QueryInterface(GetContent());
+ if (imageLoader) {
+ imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+ getter_AddRefs(request));
+ }
+ return request.forget();
+}
+
+bool SVGImageFrame::IgnoreHitTest() const {
+ switch (Style()->PointerEvents()) {
+ case StylePointerEvents::None:
+ break;
+ case StylePointerEvents::Visiblepainted:
+ case StylePointerEvents::Auto:
+ if (StyleVisibility()->IsVisible()) {
+ /* XXX: should check pixel transparency */
+ return false;
+ }
+ break;
+ case StylePointerEvents::Visiblefill:
+ case StylePointerEvents::Visiblestroke:
+ case StylePointerEvents::Visible:
+ if (StyleVisibility()->IsVisible()) {
+ return false;
+ }
+ break;
+ case StylePointerEvents::Painted:
+ /* XXX: should check pixel transparency */
+ return false;
+ case StylePointerEvents::Fill:
+ case StylePointerEvents::Stroke:
+ case StylePointerEvents::All:
+ return false;
+ default:
+ NS_ERROR("not reached");
+ break;
+ }
+
+ return true;
+}
+
+void SVGImageFrame::NotifySVGChanged(uint32_t aFlags) {
+ MOZ_ASSERT(aFlags & (TRANSFORM_CHANGED | COORD_CONTEXT_CHANGED),
+ "Invalidation logic may need adjusting");
+}
+
+SVGBBox SVGImageFrame::GetBBoxContribution(const Matrix& aToBBoxUserspace,
+ uint32_t aFlags) {
+ if (aToBBoxUserspace.IsSingular()) {
+ // XXX ReportToConsole
+ return {};
+ }
+
+ if ((aFlags & SVGUtils::eForGetClientRects) &&
+ aToBBoxUserspace.PreservesAxisAlignedRectangles()) {
+ Rect rect = NSRectToRect(mRect, AppUnitsPerCSSPixel());
+ return aToBBoxUserspace.TransformBounds(rect);
+ }
+
+ auto* element = static_cast<SVGImageElement*>(GetContent());
+
+ return element->GeometryBounds(aToBBoxUserspace);
+}
+
+//----------------------------------------------------------------------
+// SVGImageListener implementation
+
+NS_IMPL_ISUPPORTS(SVGImageListener, imgINotificationObserver)
+
+SVGImageListener::SVGImageListener(SVGImageFrame* aFrame) : mFrame(aFrame) {}
+
+void SVGImageListener::Notify(imgIRequest* aRequest, int32_t aType,
+ const nsIntRect* aData) {
+ if (!mFrame) {
+ return;
+ }
+
+ if (aType == imgINotificationObserver::LOAD_COMPLETE) {
+ mFrame->InvalidateFrame();
+ nsLayoutUtils::PostRestyleEvent(mFrame->GetContent()->AsElement(),
+ RestyleHint{0},
+ nsChangeHint_InvalidateRenderingObservers);
+ SVGUtils::ScheduleReflowSVG(mFrame);
+ }
+
+ if (aType == imgINotificationObserver::FRAME_UPDATE) {
+ // No new dimensions, so we don't need to call
+ // SVGUtils::InvalidateAndScheduleBoundsUpdate.
+ nsLayoutUtils::PostRestyleEvent(mFrame->GetContent()->AsElement(),
+ RestyleHint{0},
+ nsChangeHint_InvalidateRenderingObservers);
+ mFrame->InvalidateFrame();
+ }
+
+ if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
+ // Called once the resource's dimensions have been obtained.
+ nsCOMPtr<imgIContainer> image;
+ aRequest->GetImage(getter_AddRefs(image));
+ if (image) {
+ StyleImageOrientation orientation =
+ mFrame->StyleVisibility()->UsedImageOrientation(aRequest);
+ image = nsLayoutUtils::OrientImage(image, orientation);
+ image->SetAnimationMode(mFrame->PresContext()->ImageAnimationMode());
+ mFrame->mImageContainer = std::move(image);
+ }
+ mFrame->InvalidateFrame();
+ nsLayoutUtils::PostRestyleEvent(mFrame->GetContent()->AsElement(),
+ RestyleHint{0},
+ nsChangeHint_InvalidateRenderingObservers);
+ SVGUtils::ScheduleReflowSVG(mFrame);
+ }
+}
+
+} // namespace mozilla