diff options
Diffstat (limited to 'layout/svg/SVGIntegrationUtils.cpp')
| -rw-r--r-- | layout/svg/SVGIntegrationUtils.cpp | 1210 |
1 files changed, 1210 insertions, 0 deletions
diff --git a/layout/svg/SVGIntegrationUtils.cpp b/layout/svg/SVGIntegrationUtils.cpp new file mode 100644 index 0000000000..ab32ddee53 --- /dev/null +++ b/layout/svg/SVGIntegrationUtils.cpp @@ -0,0 +1,1210 @@ +/* -*- 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/. */ + +// Main header first: +#include "SVGIntegrationUtils.h" + +// Keep others in (case-insensitive) order: +#include "gfxDrawable.h" + +#include "nsCSSAnonBoxes.h" +#include "nsCSSRendering.h" +#include "nsDisplayList.h" +#include "nsLayoutUtils.h" +#include "gfxContext.h" +#include "SVGPaintServerFrame.h" +#include "mozilla/gfx/Point.h" +#include "mozilla/CSSClipPathInstance.h" +#include "mozilla/FilterInstance.h" +#include "mozilla/StaticPrefs_layers.h" +#include "mozilla/SVGClipPathFrame.h" +#include "mozilla/SVGObserverUtils.h" +#include "mozilla/SVGMaskFrame.h" +#include "mozilla/SVGUtils.h" +#include "mozilla/Unused.h" +#include "mozilla/dom/SVGElement.h" + +using namespace mozilla::dom; +using namespace mozilla::layers; +using namespace mozilla::gfx; +using namespace mozilla::image; + +namespace mozilla { + +/** + * This class is used to get the pre-effects ink overflow rect of a frame, + * or, in the case of a frame with continuations, to collect the union of the + * pre-effects ink overflow rects of all the continuations. The result is + * relative to the origin (top left corner of the border box) of the frame, or, + * if the frame has continuations, the origin of the _first_ continuation. + */ +class PreEffectsInkOverflowCollector : public nsLayoutUtils::BoxCallback { + public: + /** + * If the pre-effects ink overflow rect of the frame being examined + * happens to be known, it can be passed in as aCurrentFrame and its + * pre-effects ink overflow rect can be passed in as + * aCurrentFrameOverflowArea. This is just an optimization to save a + * frame property lookup - these arguments are optional. + */ + PreEffectsInkOverflowCollector(nsIFrame* aFirstContinuation, + nsIFrame* aCurrentFrame, + const nsRect& aCurrentFrameOverflowArea, + bool aInReflow) + : mFirstContinuation(aFirstContinuation), + mCurrentFrame(aCurrentFrame), + mCurrentFrameOverflowArea(aCurrentFrameOverflowArea), + mInReflow(aInReflow) { + NS_ASSERTION(!mFirstContinuation->GetPrevContinuation(), + "We want the first continuation here"); + } + + void AddBox(nsIFrame* aFrame) override { + nsRect overflow = (aFrame == mCurrentFrame) + ? mCurrentFrameOverflowArea + : PreEffectsInkOverflowRect(aFrame, mInReflow); + mResult.UnionRect(mResult, + overflow + aFrame->GetOffsetTo(mFirstContinuation)); + } + + nsRect GetResult() const { return mResult; } + + private: + static nsRect PreEffectsInkOverflowRect(nsIFrame* aFrame, bool aInReflow) { + nsRect* r = aFrame->GetProperty(nsIFrame::PreEffectsBBoxProperty()); + if (r) { + return *r; + } + +#ifdef DEBUG + // Having PreTransformOverflowAreasProperty cached means + // InkOverflowRect() will return post-effect rect, which is not what + // we want. This function intentional reports pre-effect rect. But it does + // not matter if there is no SVG effect on this frame, since no effect + // means post-effect rect matches pre-effect rect. + // + // This function may be called during reflow or painting. We should only + // do this check in painting process since the PreEffectsBBoxProperty of + // continuations are not set correctly while reflowing. + if (SVGIntegrationUtils::UsingOverflowAffectingEffects(aFrame) && + !aInReflow) { + OverflowAreas* preTransformOverflows = + aFrame->GetProperty(nsIFrame::PreTransformOverflowAreasProperty()); + + MOZ_ASSERT(!preTransformOverflows, + "InkOverflowRect() won't return the pre-effects rect!"); + } +#endif + return aFrame->InkOverflowRectRelativeToSelf(); + } + + nsIFrame* mFirstContinuation; + nsIFrame* mCurrentFrame; + const nsRect& mCurrentFrameOverflowArea; + nsRect mResult; + bool mInReflow; +}; + +/** + * Gets the union of the pre-effects ink overflow rects of all of a frame's + * continuations, in "user space". + */ +static nsRect GetPreEffectsInkOverflowUnion( + nsIFrame* aFirstContinuation, nsIFrame* aCurrentFrame, + const nsRect& aCurrentFramePreEffectsOverflow, + const nsPoint& aFirstContinuationToUserSpace, bool aInReflow) { + NS_ASSERTION(!aFirstContinuation->GetPrevContinuation(), + "Need first continuation here"); + PreEffectsInkOverflowCollector collector(aFirstContinuation, aCurrentFrame, + aCurrentFramePreEffectsOverflow, + aInReflow); + // Compute union of all overflow areas relative to aFirstContinuation: + nsLayoutUtils::GetAllInFlowBoxes(aFirstContinuation, &collector); + // Return the result in user space: + return collector.GetResult() + aFirstContinuationToUserSpace; +} + +/** + * Gets the pre-effects ink overflow rect of aCurrentFrame in "user space". + */ +static nsRect GetPreEffectsInkOverflow( + nsIFrame* aFirstContinuation, nsIFrame* aCurrentFrame, + const nsPoint& aFirstContinuationToUserSpace) { + NS_ASSERTION(!aFirstContinuation->GetPrevContinuation(), + "Need first continuation here"); + PreEffectsInkOverflowCollector collector(aFirstContinuation, nullptr, + nsRect(), false); + // Compute overflow areas of current frame relative to aFirstContinuation: + nsLayoutUtils::AddBoxesForFrame(aCurrentFrame, &collector); + // Return the result in user space: + return collector.GetResult() + aFirstContinuationToUserSpace; +} + +bool SVGIntegrationUtils::UsingOverflowAffectingEffects( + const nsIFrame* aFrame) { + // Currently overflow don't take account of SVG or other non-absolute + // positioned clipping, or masking. + return aFrame->StyleEffects()->HasFilters(); +} + +bool SVGIntegrationUtils::UsingEffectsForFrame(const nsIFrame* aFrame) { + // Even when SVG display lists are disabled, returning true for SVG frames + // does not adversely affect any of our callers. Therefore we don't bother + // checking the SDL prefs here, since we don't know if we're being called for + // painting or hit-testing anyway. + const nsStyleSVGReset* style = aFrame->StyleSVGReset(); + const nsStyleEffects* effects = aFrame->StyleEffects(); + // TODO(cbrewster): remove backdrop-filter from this list once it is supported + // in preserve-3d cases. + return effects->HasFilters() || effects->HasBackdropFilters() || + style->HasClipPath() || style->HasMask(); +} + +nsPoint SVGIntegrationUtils::GetOffsetToBoundingBox(nsIFrame* aFrame) { + if (aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) { + // Do NOT call GetAllInFlowRectsUnion for SVG - it will get the + // covered region relative to the SVGOuterSVGFrame, which is absolutely + // not what we want. SVG frames are always in user space, so they have + // no offset adjustment to make. + return nsPoint(); + } + + // The GetAllInFlowRectsUnion() call gets the union of the frame border-box + // rects over all continuations, relative to the origin (top-left of the + // border box) of its second argument (here, aFrame, the first continuation). + return -nsLayoutUtils::GetAllInFlowRectsUnion(aFrame, aFrame).TopLeft(); +} + +struct EffectOffsets { + // The offset between the reference frame and the bounding box of the + // target frame in app unit. + nsPoint offsetToBoundingBox; + // The offset between the reference frame and the bounding box of the + // target frame in app unit. + nsPoint offsetToUserSpace; + // The offset between the reference frame and the bounding box of the + // target frame in device unit. + gfxPoint offsetToUserSpaceInDevPx; +}; + +static EffectOffsets ComputeEffectOffset( + nsIFrame* aFrame, const SVGIntegrationUtils::PaintFramesParams& aParams) { + EffectOffsets result; + + result.offsetToBoundingBox = + aParams.builder->ToReferenceFrame(aFrame) - + SVGIntegrationUtils::GetOffsetToBoundingBox(aFrame); + if (!aFrame->IsSVGFrame()) { + /* Snap the offset if the reference frame is not a SVG frame, + * since other frames will be snapped to pixel when rendering. */ + result.offsetToBoundingBox = + nsPoint(aFrame->PresContext()->RoundAppUnitsToNearestDevPixels( + result.offsetToBoundingBox.x), + aFrame->PresContext()->RoundAppUnitsToNearestDevPixels( + result.offsetToBoundingBox.y)); + } + + // After applying only "aOffsetToBoundingBox", aParams.ctx would have its + // origin at the top left corner of frame's bounding box (over all + // continuations). + // However, SVG painting needs the origin to be located at the origin of the + // SVG frame's "user space", i.e. the space in which, for example, the + // frame's BBox lives. + // SVG geometry frames and foreignObject frames apply their own offsets, so + // their position is relative to their user space. So for these frame types, + // if we want aParams.ctx to be in user space, we first need to subtract the + // frame's position so that SVG painting can later add it again and the + // frame is painted in the right place. + gfxPoint toUserSpaceGfx = + SVGUtils::FrameSpaceInCSSPxToUserSpaceOffset(aFrame); + nsPoint toUserSpace = + nsPoint(nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.x)), + nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.y))); + + result.offsetToUserSpace = result.offsetToBoundingBox - toUserSpace; + +#ifdef DEBUG + bool hasSVGLayout = aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT); + NS_ASSERTION( + hasSVGLayout || result.offsetToBoundingBox == result.offsetToUserSpace, + "For non-SVG frames there shouldn't be any additional offset"); +#endif + + result.offsetToUserSpaceInDevPx = nsLayoutUtils::PointToGfxPoint( + result.offsetToUserSpace, aFrame->PresContext()->AppUnitsPerDevPixel()); + + return result; +} + +/** + * Setup transform matrix of a gfx context by a specific frame. Move the + * origin of aParams.ctx to the user space of aFrame. + */ +static EffectOffsets MoveContextOriginToUserSpace( + nsIFrame* aFrame, const SVGIntegrationUtils::PaintFramesParams& aParams) { + EffectOffsets offset = ComputeEffectOffset(aFrame, aParams); + + aParams.ctx.SetMatrixDouble(aParams.ctx.CurrentMatrixDouble().PreTranslate( + offset.offsetToUserSpaceInDevPx)); + + return offset; +} + +gfxPoint SVGIntegrationUtils::GetOffsetToUserSpaceInDevPx( + nsIFrame* aFrame, const PaintFramesParams& aParams) { + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame); + EffectOffsets offset = ComputeEffectOffset(firstFrame, aParams); + return offset.offsetToUserSpaceInDevPx; +} + +/* static */ +nsSize SVGIntegrationUtils::GetContinuationUnionSize(nsIFrame* aNonSVGFrame) { + NS_ASSERTION(!aNonSVGFrame->IsSVGFrame(), "SVG frames should not get here"); + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(aNonSVGFrame); + return nsLayoutUtils::GetAllInFlowRectsUnion(firstFrame, firstFrame).Size(); +} + +/* static */ gfx::Size SVGIntegrationUtils::GetSVGCoordContextForNonSVGFrame( + nsIFrame* aNonSVGFrame) { + NS_ASSERTION(!aNonSVGFrame->IsSVGFrame(), "SVG frames should not get here"); + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(aNonSVGFrame); + nsRect r = nsLayoutUtils::GetAllInFlowRectsUnion(firstFrame, firstFrame); + return gfx::Size(nsPresContext::AppUnitsToFloatCSSPixels(r.width), + nsPresContext::AppUnitsToFloatCSSPixels(r.height)); +} + +gfxRect SVGIntegrationUtils::GetSVGBBoxForNonSVGFrame( + nsIFrame* aNonSVGFrame, bool aUnionContinuations) { + // Except for SVGOuterSVGFrame, we shouldn't be getting here with SVG + // frames at all. This function is for elements that are laid out using the + // CSS box model rules. + NS_ASSERTION(!aNonSVGFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT), + "Frames with SVG layout should not get here"); + + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(aNonSVGFrame); + // 'r' is in "user space": + nsRect r = (aUnionContinuations) + ? GetPreEffectsInkOverflowUnion( + firstFrame, nullptr, nsRect(), + GetOffsetToBoundingBox(firstFrame), false) + : GetPreEffectsInkOverflow(firstFrame, aNonSVGFrame, + GetOffsetToBoundingBox(firstFrame)); + + return nsLayoutUtils::RectToGfxRect(r, AppUnitsPerCSSPixel()); +} + +// XXX Since we're called during reflow, this method is broken for frames with +// continuations. When we're called for a frame with continuations, we're +// called for each continuation in turn as it's reflowed. However, it isn't +// until the last continuation is reflowed that this method's +// GetOffsetToBoundingBox() and GetPreEffectsInkOverflowUnion() calls will +// obtain valid border boxes for all the continuations. As a result, we'll +// end up returning bogus post-filter ink overflow rects for all the prior +// continuations. Unfortunately, by the time the last continuation is +// reflowed, it's too late to go back and set and propagate the overflow +// rects on the previous continuations. +// +// The reason that we need to pass an override bbox to +// GetPreEffectsInkOverflowUnion rather than just letting it call into our +// GetSVGBBoxForNonSVGFrame method is because we get called by +// ComputeEffectsRect when it has been called with +// aStoreRectProperties set to false. In this case the pre-effects visual +// overflow rect that it has been passed may be different to that stored on +// aFrame, resulting in a different bbox. +// +// XXXjwatt The pre-effects ink overflow rect passed to +// ComputeEffectsRect won't include continuation overflows, so +// for frames with continuation the following filter analysis will likely end +// up being carried out with a bbox created as if the frame didn't have +// continuations. +// +// XXXjwatt Using aPreEffectsOverflowRect to create the bbox isn't really right +// for SVG frames, since for SVG frames the SVG spec defines the bbox to be +// something quite different to the pre-effects ink overflow rect. However, +// we're essentially calculating an invalidation area here, and using the +// pre-effects overflow rect will actually overestimate that area which, while +// being a bit wasteful, isn't otherwise a problem. +// +nsRect SVGIntegrationUtils::ComputePostEffectsInkOverflowRect( + nsIFrame* aFrame, const nsRect& aPreEffectsOverflowRect) { + MOZ_ASSERT(!aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT), + "Don't call this on SVG child frames"); + + MOZ_ASSERT(aFrame->StyleEffects()->HasFilters(), + "We should only be called if the frame is filtered, since filters " + "are the only effect that affects overflow."); + + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame); + // Note: we do not return here for eHasNoRefs since we must still handle any + // CSS filter functions. + // TODO: we should really return an empty rect for eHasRefsSomeInvalid since + // in that case we disable painting of the element. + nsTArray<SVGFilterFrame*> filterFrames; + if (SVGObserverUtils::GetAndObserveFilters(firstFrame, &filterFrames) == + SVGObserverUtils::eHasRefsSomeInvalid) { + return aPreEffectsOverflowRect; + } + + // Create an override bbox - see comment above: + nsPoint firstFrameToBoundingBox = GetOffsetToBoundingBox(firstFrame); + // overrideBBox is in "user space", in _CSS_ pixels: + // XXX Why are we rounding out to pixel boundaries? We don't do that in + // GetSVGBBoxForNonSVGFrame, and it doesn't appear to be necessary. + gfxRect overrideBBox = nsLayoutUtils::RectToGfxRect( + GetPreEffectsInkOverflowUnion(firstFrame, aFrame, aPreEffectsOverflowRect, + firstFrameToBoundingBox, true), + AppUnitsPerCSSPixel()); + overrideBBox.RoundOut(); + + Maybe<nsRect> overflowRect = FilterInstance::GetPostFilterBounds( + firstFrame, filterFrames, &overrideBBox); + if (!overflowRect) { + return aPreEffectsOverflowRect; + } + + // Return overflowRect relative to aFrame, rather than "user space": + return overflowRect.value() - + (aFrame->GetOffsetTo(firstFrame) + firstFrameToBoundingBox); +} + +nsRect SVGIntegrationUtils::GetRequiredSourceForInvalidArea( + nsIFrame* aFrame, const nsRect& aDirtyRect) { + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame); + + // If we have any filters to observe then we should have started doing that + // during reflow/ComputeFrameEffectsRect, so we use GetFiltersIfObserving + // here to avoid needless work (or masking bugs by setting up observers at + // the wrong time). + nsTArray<SVGFilterFrame*> filterFrames; + if (!aFrame->StyleEffects()->HasFilters() || + SVGObserverUtils::GetFiltersIfObserving(firstFrame, &filterFrames) == + SVGObserverUtils::eHasRefsSomeInvalid) { + return aDirtyRect; + } + + // Convert aDirtyRect into "user space" in app units: + nsPoint toUserSpace = + aFrame->GetOffsetTo(firstFrame) + GetOffsetToBoundingBox(firstFrame); + nsRect postEffectsRect = aDirtyRect + toUserSpace; + + // Return ther result, relative to aFrame, not in user space: + return FilterInstance::GetPreFilterNeededArea(firstFrame, filterFrames, + postEffectsRect) + .GetBounds() - + toUserSpace; +} + +bool SVGIntegrationUtils::HitTestFrameForEffects(nsIFrame* aFrame, + const nsPoint& aPt) { + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame); + // Convert aPt to user space: + nsPoint toUserSpace; + if (aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) { + // XXXmstange Isn't this wrong for svg:use and innerSVG frames? + toUserSpace = aFrame->GetPosition(); + } else { + toUserSpace = + aFrame->GetOffsetTo(firstFrame) + GetOffsetToBoundingBox(firstFrame); + } + nsPoint pt = aPt + toUserSpace; + gfxPoint userSpacePt = gfxPoint(pt.x, pt.y) / AppUnitsPerCSSPixel(); + return SVGUtils::HitTestClip(firstFrame, userSpacePt); +} + +using PaintFramesParams = SVGIntegrationUtils::PaintFramesParams; + +/** + * Paint css-positioned-mask onto a given target(aMaskDT). + * Return value indicates if mask is complete. + */ +static bool PaintMaskSurface(const PaintFramesParams& aParams, + DrawTarget* aMaskDT, float aOpacity, + const ComputedStyle* aSC, + const nsTArray<SVGMaskFrame*>& aMaskFrames, + const nsPoint& aOffsetToUserSpace) { + MOZ_ASSERT(aMaskFrames.Length() > 0); + MOZ_ASSERT(aMaskDT->GetFormat() == SurfaceFormat::A8); + MOZ_ASSERT(aOpacity == 1.0 || aMaskFrames.Length() == 1); + + const nsStyleSVGReset* svgReset = aSC->StyleSVGReset(); + gfxMatrix cssPxToDevPxMatrix = SVGUtils::GetCSSPxToDevPxMatrix(aParams.frame); + + nsPresContext* presContext = aParams.frame->PresContext(); + gfxPoint devPixelOffsetToUserSpace = nsLayoutUtils::PointToGfxPoint( + aOffsetToUserSpace, presContext->AppUnitsPerDevPixel()); + + gfxContext maskContext(aMaskDT, /* aPreserveTransform */ true); + + bool isMaskComplete = true; + + // Multiple SVG masks interleave with image mask. Paint each layer onto + // aMaskDT one at a time. + for (int i = aMaskFrames.Length() - 1; i >= 0; i--) { + SVGMaskFrame* maskFrame = aMaskFrames[i]; + CompositionOp compositionOp = + (i == int(aMaskFrames.Length() - 1)) + ? CompositionOp::OP_OVER + : nsCSSRendering::GetGFXCompositeMode( + svgReset->mMask.mLayers[i].mComposite); + + // maskFrame != nullptr means we get a SVG mask. + // maskFrame == nullptr means we get an image mask. + if (maskFrame) { + SVGMaskFrame::MaskParams params( + maskContext.GetDrawTarget(), aParams.frame, cssPxToDevPxMatrix, + aOpacity, svgReset->mMask.mLayers[i].mMaskMode, aParams.imgParams); + RefPtr<SourceSurface> svgMask = maskFrame->GetMaskForMaskedFrame(params); + if (svgMask) { + Matrix tmp = aMaskDT->GetTransform(); + aMaskDT->SetTransform(Matrix()); + aMaskDT->MaskSurface(ColorPattern(DeviceColor(0.0, 0.0, 0.0, 1.0)), + svgMask, Point(0, 0), + DrawOptions(1.0, compositionOp)); + aMaskDT->SetTransform(tmp); + } + } else if (svgReset->mMask.mLayers[i].mImage.IsResolved()) { + gfxContextMatrixAutoSaveRestore matRestore(&maskContext); + + maskContext.Multiply(gfxMatrix::Translation(-devPixelOffsetToUserSpace)); + nsCSSRendering::PaintBGParams params = + nsCSSRendering::PaintBGParams::ForSingleLayer( + *presContext, aParams.dirtyRect, aParams.borderArea, + aParams.frame, + aParams.builder->GetBackgroundPaintFlags() | + nsCSSRendering::PAINTBG_MASK_IMAGE, + i, compositionOp, aOpacity); + + aParams.imgParams.result &= nsCSSRendering::PaintStyleImageLayerWithSC( + params, maskContext, aSC, *aParams.frame->StyleBorder()); + } else { + isMaskComplete = false; + } + } + + return isMaskComplete; +} + +struct MaskPaintResult { + RefPtr<SourceSurface> maskSurface; + Matrix maskTransform; + bool transparentBlackMask; + bool opacityApplied; + + MaskPaintResult() : transparentBlackMask(false), opacityApplied(false) {} +}; + +static MaskPaintResult CreateAndPaintMaskSurface( + const PaintFramesParams& aParams, float aOpacity, const ComputedStyle* aSC, + const nsTArray<SVGMaskFrame*>& aMaskFrames, + const nsPoint& aOffsetToUserSpace) { + const nsStyleSVGReset* svgReset = aSC->StyleSVGReset(); + MOZ_ASSERT(aMaskFrames.Length() > 0); + MaskPaintResult paintResult; + + gfxContext& ctx = aParams.ctx; + + // Optimization for single SVG mask. + if (((aMaskFrames.Length() == 1) && aMaskFrames[0])) { + gfxMatrix cssPxToDevPxMatrix = + SVGUtils::GetCSSPxToDevPxMatrix(aParams.frame); + paintResult.opacityApplied = true; + SVGMaskFrame::MaskParams params( + ctx.GetDrawTarget(), aParams.frame, cssPxToDevPxMatrix, aOpacity, + svgReset->mMask.mLayers[0].mMaskMode, aParams.imgParams); + paintResult.maskSurface = aMaskFrames[0]->GetMaskForMaskedFrame(params); + paintResult.maskTransform = ctx.CurrentMatrix(); + paintResult.maskTransform.Invert(); + if (!paintResult.maskSurface) { + paintResult.transparentBlackMask = true; + } + + return paintResult; + } + + const LayoutDeviceRect& maskSurfaceRect = + aParams.maskRect.valueOr(LayoutDeviceRect()); + if (aParams.maskRect.isSome() && maskSurfaceRect.IsEmpty()) { + // XXX: Is this ever true? + paintResult.transparentBlackMask = true; + return paintResult; + } + + RefPtr<DrawTarget> maskDT = ctx.GetDrawTarget()->CreateClippedDrawTarget( + maskSurfaceRect.ToUnknownRect(), SurfaceFormat::A8); + if (!maskDT || !maskDT->IsValid()) { + return paintResult; + } + + // We can paint mask along with opacity only if + // 1. There is only one mask, or + // 2. No overlap among masks. + // Collision detect in #2 is not that trivial, we only accept #1 here. + paintResult.opacityApplied = (aMaskFrames.Length() == 1); + + // Set context's matrix on maskContext, offset by the maskSurfaceRect's + // position. This makes sure that we combine the masks in device space. + Matrix maskSurfaceMatrix = ctx.CurrentMatrix(); + + bool isMaskComplete = PaintMaskSurface( + aParams, maskDT, paintResult.opacityApplied ? aOpacity : 1.0, aSC, + aMaskFrames, aOffsetToUserSpace); + + if (!isMaskComplete || + (aParams.imgParams.result != ImgDrawResult::SUCCESS && + aParams.imgParams.result != ImgDrawResult::SUCCESS_NOT_COMPLETE && + aParams.imgParams.result != ImgDrawResult::WRONG_SIZE)) { + // Now we know the status of mask resource since we used it while painting. + // According to the return value of PaintMaskSurface, we know whether mask + // resource is resolvable or not. + // + // For a HTML doc: + // According to css-masking spec, always create a mask surface when + // we have any item in maskFrame even if all of those items are + // non-resolvable <mask-sources> or <images>. + // Set paintResult.transparentBlackMask as true, the caller should stop + // painting masked content as if this mask is a transparent black one. + // For a SVG doc: + // SVG 1.1 say that if we fail to resolve a mask, we should draw the + // object unmasked. + // Left paintResult.maskSurface empty, the caller should paint all + // masked content as if this mask is an opaque white one(no mask). + paintResult.transparentBlackMask = + !aParams.frame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT); + + MOZ_ASSERT(!paintResult.maskSurface); + return paintResult; + } + + paintResult.maskTransform = maskSurfaceMatrix; + if (!paintResult.maskTransform.Invert()) { + return paintResult; + } + + paintResult.maskSurface = maskDT->Snapshot(); + return paintResult; +} + +static bool ValidateSVGFrame(nsIFrame* aFrame) { + NS_ASSERTION( + !aFrame->HasAllStateBits(NS_FRAME_SVG_LAYOUT | NS_FRAME_IS_NONDISPLAY), + "Should not use SVGIntegrationUtils on this SVG frame"); + + if (aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) { +#ifdef DEBUG + ISVGDisplayableFrame* svgFrame = do_QueryFrame(aFrame); + MOZ_ASSERT(svgFrame && aFrame->GetContent()->IsSVGElement(), + "A non-SVG frame carries NS_FRAME_SVG_LAYOUT flag?"); +#endif + + const nsIContent* content = aFrame->GetContent(); + if (!static_cast<const SVGElement*>(content)->HasValidDimensions()) { + // The SVG spec says not to draw _anything_ + return false; + } + } + + return true; +} + +bool SVGIntegrationUtils::PaintMask(const PaintFramesParams& aParams, + bool& aOutIsMaskComplete) { + aOutIsMaskComplete = true; + + SVGUtils::MaskUsage maskUsage = + SVGUtils::DetermineMaskUsage(aParams.frame, aParams.handleOpacity); + if (!maskUsage.ShouldDoSomething()) { + return false; + } + + nsIFrame* frame = aParams.frame; + if (!ValidateSVGFrame(frame)) { + return false; + } + + gfxContext& ctx = aParams.ctx; + RefPtr<DrawTarget> maskTarget = ctx.GetDrawTarget(); + + if (maskUsage.ShouldGenerateMaskLayer() && maskUsage.HasSVGClip()) { + // We will paint both mask of positioned mask and clip-path into + // maskTarget. + // + // Create one extra draw target for drawing positioned mask, so that we do + // not have to copy the content of maskTarget before painting + // clip-path into it. + maskTarget = maskTarget->CreateClippedDrawTarget(Rect(), SurfaceFormat::A8); + } + + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(frame); + nsTArray<SVGMaskFrame*> maskFrames; + // XXX check return value? + SVGObserverUtils::GetAndObserveMasks(firstFrame, &maskFrames); + + gfxGroupForBlendAutoSaveRestore autoPop(&ctx); + bool shouldPushOpacity = !maskUsage.IsOpaque() && maskFrames.Length() != 1; + if (shouldPushOpacity) { + autoPop.PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, + maskUsage.Opacity()); + } + + gfxContextMatrixAutoSaveRestore matSR; + + // Paint clip-path-basic-shape onto ctx + gfxContextAutoSaveRestore basicShapeSR; + if (maskUsage.ShouldApplyBasicShapeOrPath()) { + matSR.SetContext(&ctx); + + MoveContextOriginToUserSpace(firstFrame, aParams); + + basicShapeSR.SetContext(&ctx); + gfxMatrix mat = SVGUtils::GetCSSPxToDevPxMatrix(frame); + if (!maskUsage.ShouldGenerateMaskLayer()) { + // Only have basic-shape clip-path effect. Fill clipped region by + // opaque white. + ctx.SetDeviceColor(DeviceColor::MaskOpaqueWhite()); + RefPtr<Path> path = CSSClipPathInstance::CreateClipPathForFrame( + ctx.GetDrawTarget(), frame, mat); + if (path) { + ctx.SetPath(path); + ctx.Fill(); + } + + return true; + } + CSSClipPathInstance::ApplyBasicShapeOrPathClip(ctx, frame, mat); + } + + // Paint mask into maskTarget. + if (maskUsage.ShouldGenerateMaskLayer()) { + matSR.Restore(); + matSR.SetContext(&ctx); + + EffectOffsets offsets = ComputeEffectOffset(frame, aParams); + maskTarget->SetTransform(maskTarget->GetTransform().PreTranslate( + ToPoint(offsets.offsetToUserSpaceInDevPx))); + aOutIsMaskComplete = PaintMaskSurface( + aParams, maskTarget, shouldPushOpacity ? 1.0f : maskUsage.Opacity(), + firstFrame->Style(), maskFrames, offsets.offsetToUserSpace); + } + + // Paint clip-path onto ctx. + if (maskUsage.HasSVGClip()) { + matSR.Restore(); + matSR.SetContext(&ctx); + + MoveContextOriginToUserSpace(firstFrame, aParams); + Matrix clipMaskTransform; + gfxMatrix cssPxToDevPxMatrix = SVGUtils::GetCSSPxToDevPxMatrix(frame); + + SVGClipPathFrame* clipPathFrame; + // XXX check return value? + SVGObserverUtils::GetAndObserveClipPath(firstFrame, &clipPathFrame); + RefPtr<SourceSurface> maskSurface = + maskUsage.ShouldGenerateMaskLayer() ? maskTarget->Snapshot() : nullptr; + clipPathFrame->PaintClipMask(ctx, frame, cssPxToDevPxMatrix, maskSurface); + } + + return true; +} + +template <class T> +void PaintMaskAndClipPathInternal(const PaintFramesParams& aParams, + const T& aPaintChild) { +#ifdef DEBUG + const nsStyleSVGReset* style = aParams.frame->StyleSVGReset(); + MOZ_ASSERT(style->HasClipPath() || style->HasMask(), + "Should not use this method when no mask or clipPath effect" + "on this frame"); +#endif + + /* SVG defines the following rendering model: + * + * 1. Render geometry + * 2. Apply filter + * 3. Apply clipping, masking, group opacity + * + * We handle #3 here and perform a couple of optimizations: + * + * + Use cairo's clipPath when representable natively (single object + * clip region). + * + * + Merge opacity and masking if both used together. + */ + nsIFrame* frame = aParams.frame; + if (!ValidateSVGFrame(frame)) { + return; + } + + SVGUtils::MaskUsage maskUsage = + SVGUtils::DetermineMaskUsage(aParams.frame, aParams.handleOpacity); + + if (maskUsage.IsTransparent()) { + return; + } + + gfxContext& context = aParams.ctx; + gfxContextMatrixAutoSaveRestore matrixAutoSaveRestore(&context); + + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(frame); + + SVGClipPathFrame* clipPathFrame; + // XXX check return value? + SVGObserverUtils::GetAndObserveClipPath(firstFrame, &clipPathFrame); + + nsTArray<SVGMaskFrame*> maskFrames; + // XXX check return value? + SVGObserverUtils::GetAndObserveMasks(firstFrame, &maskFrames); + + gfxMatrix cssPxToDevPxMatrix = SVGUtils::GetCSSPxToDevPxMatrix(frame); + + bool shouldPushMask = false; + + gfxGroupForBlendAutoSaveRestore autoGroupForBlend(&context); + + /* Check if we need to do additional operations on this child's + * rendering, which necessitates rendering into another surface. */ + if (maskUsage.ShouldGenerateMask()) { + gfxContextMatrixAutoSaveRestore matSR; + + RefPtr<SourceSurface> maskSurface; + bool opacityApplied = false; + + if (maskUsage.ShouldGenerateMaskLayer()) { + matSR.SetContext(&context); + + // For css-mask, we want to generate a mask for each continuation frame, + // so we setup context matrix by the position of the current frame, + // instead of the first continuation frame. + EffectOffsets offsets = MoveContextOriginToUserSpace(frame, aParams); + MaskPaintResult paintResult = CreateAndPaintMaskSurface( + aParams, maskUsage.Opacity(), firstFrame->Style(), maskFrames, + offsets.offsetToUserSpace); + + if (paintResult.transparentBlackMask) { + return; + } + + maskSurface = paintResult.maskSurface; + if (maskSurface) { + shouldPushMask = true; + + opacityApplied = paintResult.opacityApplied; + } + } + + if (maskUsage.ShouldGenerateClipMaskLayer()) { + matSR.Restore(); + matSR.SetContext(&context); + + MoveContextOriginToUserSpace(firstFrame, aParams); + RefPtr<SourceSurface> clipMaskSurface = clipPathFrame->GetClipMask( + context, frame, cssPxToDevPxMatrix, maskSurface); + + if (clipMaskSurface) { + maskSurface = clipMaskSurface; + } else { + // Either entire surface is clipped out, or gfx buffer allocation + // failure in SVGClipPathFrame::GetClipMask. + return; + } + + shouldPushMask = true; + } + + // opacity != 1.0f. + if (!maskUsage.ShouldGenerateLayer()) { + MOZ_ASSERT(!maskUsage.IsOpaque()); + + matSR.SetContext(&context); + MoveContextOriginToUserSpace(firstFrame, aParams); + shouldPushMask = true; + } + + if (shouldPushMask) { + // We want the mask to be untransformed so use the inverse of the + // current transform as the maskTransform to compensate. + Matrix maskTransform = context.CurrentMatrix(); + maskTransform.Invert(); + + autoGroupForBlend.PushGroupForBlendBack( + gfxContentType::COLOR_ALPHA, + opacityApplied ? 1.0f : maskUsage.Opacity(), maskSurface, + maskTransform); + } + } + + /* If this frame has only a trivial clipPath, set up cairo's clipping now so + * we can just do normal painting and get it clipped appropriately. + */ + if (maskUsage.ShouldApplyClipPath() || + maskUsage.ShouldApplyBasicShapeOrPath()) { + gfxContextMatrixAutoSaveRestore matSR(&context); + + MoveContextOriginToUserSpace(firstFrame, aParams); + + MOZ_ASSERT(!maskUsage.ShouldApplyClipPath() || + !maskUsage.ShouldApplyBasicShapeOrPath()); + if (maskUsage.ShouldApplyClipPath()) { + clipPathFrame->ApplyClipPath(context, frame, cssPxToDevPxMatrix); + } else { + CSSClipPathInstance::ApplyBasicShapeOrPathClip(context, frame, + cssPxToDevPxMatrix); + } + } + + /* Paint the child */ + context.SetMatrix(matrixAutoSaveRestore.Matrix()); + aPaintChild(); + + if (StaticPrefs::layers_draw_mask_debug()) { + gfxContextAutoSaveRestore saver(&context); + + context.NewPath(); + gfxRect drawingRect = nsLayoutUtils::RectToGfxRect( + aParams.borderArea, frame->PresContext()->AppUnitsPerDevPixel()); + context.SnappedRectangle(drawingRect); + sRGBColor overlayColor(0.0f, 0.0f, 0.0f, 0.8f); + if (maskUsage.ShouldGenerateMaskLayer()) { + overlayColor.r = 1.0f; // red represents css positioned mask. + } + if (maskUsage.HasSVGClip()) { + overlayColor.g = 1.0f; // green represents clip-path:<clip-source>. + } + if (maskUsage.ShouldApplyBasicShapeOrPath()) { + overlayColor.b = 1.0f; // blue represents + // clip-path:<basic-shape>||<geometry-box>. + } + + context.SetColor(overlayColor); + context.Fill(); + } + + if (maskUsage.ShouldApplyClipPath() || + maskUsage.ShouldApplyBasicShapeOrPath()) { + context.PopClip(); + } +} + +void SVGIntegrationUtils::PaintMaskAndClipPath( + const PaintFramesParams& aParams, + const std::function<void()>& aPaintChild) { + PaintMaskAndClipPathInternal(aParams, aPaintChild); +} + +void SVGIntegrationUtils::PaintFilter(const PaintFramesParams& aParams, + Span<const StyleFilter> aFilters, + const SVGFilterPaintCallback& aCallback) { + MOZ_ASSERT(!aParams.builder->IsForGenerateGlyphMask(), + "Filter effect is discarded while generating glyph mask."); + MOZ_ASSERT(!aFilters.IsEmpty(), + "Should not use this method when no filter effect on this frame"); + + nsIFrame* frame = aParams.frame; + if (!ValidateSVGFrame(frame)) { + return; + } + + float opacity = SVGUtils::ComputeOpacity(frame, aParams.handleOpacity); + if (opacity == 0.0f) { + return; + } + + // Properties are added lazily and may have been removed by a restyle, so make + // sure all applicable ones are set again. + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(frame); + // Note: we do not return here for eHasNoRefs since we must still handle any + // CSS filter functions. + // XXX: Do we need to check for eHasRefsSomeInvalid here given that + // nsDisplayFilter::BuildLayer returns nullptr for eHasRefsSomeInvalid? + // Or can we just assert !eHasRefsSomeInvalid? + nsTArray<SVGFilterFrame*> filterFrames; + if (SVGObserverUtils::GetAndObserveFilters(firstFrame, &filterFrames) == + SVGObserverUtils::eHasRefsSomeInvalid) { + aCallback(aParams.ctx, aParams.imgParams, nullptr, nullptr); + return; + } + + gfxContext& context = aParams.ctx; + + gfxContextAutoSaveRestore autoSR(&context); + EffectOffsets offsets = MoveContextOriginToUserSpace(firstFrame, aParams); + + /* Paint the child and apply filters */ + nsRegion dirtyRegion = aParams.dirtyRect - offsets.offsetToBoundingBox; + + FilterInstance::PaintFilteredFrame(frame, aFilters, filterFrames, &context, + aCallback, &dirtyRegion, aParams.imgParams, + opacity); +} + +bool SVGIntegrationUtils::CreateWebRenderCSSFilters( + Span<const StyleFilter> aFilters, nsIFrame* aFrame, + WrFiltersHolder& aWrFilters) { + // All CSS filters are supported by WebRender. SVG filters are not fully + // supported, those use NS_STYLE_FILTER_URL and are handled separately. + + // If there are too many filters to render, then just pretend that we + // succeeded, and don't render any of them. + if (aFilters.Length() > + StaticPrefs::gfx_webrender_max_filter_ops_per_chain()) { + return true; + } + aWrFilters.filters.SetCapacity(aFilters.Length()); + auto& wrFilters = aWrFilters.filters; + for (const StyleFilter& filter : aFilters) { + switch (filter.tag) { + case StyleFilter::Tag::Brightness: + wrFilters.AppendElement( + wr::FilterOp::Brightness(filter.AsBrightness())); + break; + case StyleFilter::Tag::Contrast: + wrFilters.AppendElement(wr::FilterOp::Contrast(filter.AsContrast())); + break; + case StyleFilter::Tag::Grayscale: + wrFilters.AppendElement(wr::FilterOp::Grayscale(filter.AsGrayscale())); + break; + case StyleFilter::Tag::Invert: + wrFilters.AppendElement(wr::FilterOp::Invert(filter.AsInvert())); + break; + case StyleFilter::Tag::Opacity: { + float opacity = filter.AsOpacity(); + wrFilters.AppendElement(wr::FilterOp::Opacity( + wr::PropertyBinding<float>::Value(opacity), opacity)); + break; + } + case StyleFilter::Tag::Saturate: + wrFilters.AppendElement(wr::FilterOp::Saturate(filter.AsSaturate())); + break; + case StyleFilter::Tag::Sepia: + wrFilters.AppendElement(wr::FilterOp::Sepia(filter.AsSepia())); + break; + case StyleFilter::Tag::HueRotate: { + wrFilters.AppendElement( + wr::FilterOp::HueRotate(filter.AsHueRotate().ToDegrees())); + break; + } + case StyleFilter::Tag::Blur: { + // TODO(emilio): we should go directly from css pixels -> device pixels. + float appUnitsPerDevPixel = + aFrame->PresContext()->AppUnitsPerDevPixel(); + float radius = NSAppUnitsToFloatPixels(filter.AsBlur().ToAppUnits(), + appUnitsPerDevPixel); + wrFilters.AppendElement(wr::FilterOp::Blur(radius, radius)); + break; + } + case StyleFilter::Tag::DropShadow: { + float appUnitsPerDevPixel = + aFrame->PresContext()->AppUnitsPerDevPixel(); + const StyleSimpleShadow& shadow = filter.AsDropShadow(); + nscolor color = shadow.color.CalcColor(aFrame); + + wr::Shadow wrShadow; + wrShadow.offset = { + NSAppUnitsToFloatPixels(shadow.horizontal.ToAppUnits(), + appUnitsPerDevPixel), + NSAppUnitsToFloatPixels(shadow.vertical.ToAppUnits(), + appUnitsPerDevPixel)}; + wrShadow.blur_radius = NSAppUnitsToFloatPixels(shadow.blur.ToAppUnits(), + appUnitsPerDevPixel); + wrShadow.color = {NS_GET_R(color) / 255.0f, NS_GET_G(color) / 255.0f, + NS_GET_B(color) / 255.0f, NS_GET_A(color) / 255.0f}; + wrFilters.AppendElement(wr::FilterOp::DropShadow(wrShadow)); + break; + } + default: + return false; + } + } + + return true; +} + +bool SVGIntegrationUtils::BuildWebRenderFilters( + nsIFrame* aFilteredFrame, Span<const StyleFilter> aFilters, + StyleFilterType aStyleFilterType, WrFiltersHolder& aWrFilters, + bool& aInitialized) { + return FilterInstance::BuildWebRenderFilters( + aFilteredFrame, aFilters, aStyleFilterType, aWrFilters, aInitialized); +} + +bool SVGIntegrationUtils::CanCreateWebRenderFiltersForFrame(nsIFrame* aFrame) { + WrFiltersHolder wrFilters; + auto filterChain = aFrame->StyleEffects()->mFilters.AsSpan(); + bool initialized = true; + return CreateWebRenderCSSFilters(filterChain, aFrame, wrFilters) || + BuildWebRenderFilters(aFrame, filterChain, StyleFilterType::Filter, + wrFilters, initialized); +} + +bool SVGIntegrationUtils::UsesSVGEffectsNotSupportedInCompositor( + nsIFrame* aFrame) { + // WebRender supports masks / clip-paths and some filters in the compositor. + if (aFrame->StyleEffects()->HasFilters()) { + return !SVGIntegrationUtils::CanCreateWebRenderFiltersForFrame(aFrame); + } + return false; +} + +class PaintFrameCallback : public gfxDrawingCallback { + public: + PaintFrameCallback(nsIFrame* aFrame, const nsSize aPaintServerSize, + const IntSize aRenderSize, uint32_t aFlags) + : mFrame(aFrame), + mPaintServerSize(aPaintServerSize), + mRenderSize(aRenderSize), + mFlags(aFlags) {} + virtual bool operator()(gfxContext* aContext, const gfxRect& aFillRect, + const SamplingFilter aSamplingFilter, + const gfxMatrix& aTransform) override; + + private: + nsIFrame* mFrame; + nsSize mPaintServerSize; + IntSize mRenderSize; + uint32_t mFlags; +}; + +bool PaintFrameCallback::operator()(gfxContext* aContext, + const gfxRect& aFillRect, + const SamplingFilter aSamplingFilter, + const gfxMatrix& aTransform) { + if (mFrame->HasAnyStateBits(NS_FRAME_DRAWING_AS_PAINTSERVER)) { + return false; + } + + AutoSetRestorePaintServerState paintServer(mFrame); + + aContext->Save(); + + // Clip to aFillRect so that we don't paint outside. + aContext->Clip(aFillRect); + + gfxMatrix invmatrix = aTransform; + if (!invmatrix.Invert()) { + return false; + } + aContext->Multiply(invmatrix); + + // nsLayoutUtils::PaintFrame will anchor its painting at mFrame. But we want + // to have it anchored at the top left corner of the bounding box of all of + // mFrame's continuations. So we add a translation transform. + int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel(); + nsPoint offset = SVGIntegrationUtils::GetOffsetToBoundingBox(mFrame); + gfxPoint devPxOffset = gfxPoint(offset.x, offset.y) / appUnitsPerDevPixel; + aContext->Multiply(gfxMatrix::Translation(devPxOffset)); + + gfxSize paintServerSize = + gfxSize(mPaintServerSize.width, mPaintServerSize.height) / + mFrame->PresContext()->AppUnitsPerDevPixel(); + + // nsLayoutUtils::PaintFrame wants to render with paintServerSize, but we + // want it to render with mRenderSize, so we need to set up a scale transform. + gfxFloat scaleX = mRenderSize.width / paintServerSize.width; + gfxFloat scaleY = mRenderSize.height / paintServerSize.height; + aContext->Multiply(gfxMatrix::Scaling(scaleX, scaleY)); + + // Draw. + nsRect dirty(-offset.x, -offset.y, mPaintServerSize.width, + mPaintServerSize.height); + + using PaintFrameFlags = nsLayoutUtils::PaintFrameFlags; + PaintFrameFlags flags = PaintFrameFlags::InTransform; + if (mFlags & SVGIntegrationUtils::FLAG_SYNC_DECODE_IMAGES) { + flags |= PaintFrameFlags::SyncDecodeImages; + } + nsLayoutUtils::PaintFrame(aContext, mFrame, dirty, NS_RGBA(0, 0, 0, 0), + nsDisplayListBuilderMode::Painting, flags); + + nsIFrame* currentFrame = mFrame; + while ((currentFrame = currentFrame->GetNextContinuation()) != nullptr) { + offset = currentFrame->GetOffsetToCrossDoc(mFrame); + devPxOffset = gfxPoint(offset.x, offset.y) / appUnitsPerDevPixel; + + aContext->Save(); + aContext->Multiply(gfxMatrix::Scaling(1 / scaleX, 1 / scaleY)); + aContext->Multiply(gfxMatrix::Translation(devPxOffset)); + aContext->Multiply(gfxMatrix::Scaling(scaleX, scaleY)); + + nsLayoutUtils::PaintFrame(aContext, currentFrame, dirty - offset, + NS_RGBA(0, 0, 0, 0), + nsDisplayListBuilderMode::Painting, flags); + + aContext->Restore(); + } + + aContext->Restore(); + + return true; +} + +/* static */ +already_AddRefed<gfxDrawable> SVGIntegrationUtils::DrawableFromPaintServer( + nsIFrame* aFrame, nsIFrame* aTarget, const nsSize& aPaintServerSize, + const IntSize& aRenderSize, const DrawTarget* aDrawTarget, + const gfxMatrix& aContextMatrix, uint32_t aFlags) { + // aPaintServerSize is 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. + // aRenderSize is what we will be actually filling after accounting for + // background-size. + if (SVGPaintServerFrame* server = do_QueryFrame(aFrame)) { + // aFrame is either a pattern or a gradient. These fill the whole target + // frame by default, so aPaintServerSize is the whole target background fill + // area. + gfxRect overrideBounds(0, 0, aPaintServerSize.width, + aPaintServerSize.height); + overrideBounds.Scale(1.0 / aFrame->PresContext()->AppUnitsPerDevPixel()); + uint32_t imgFlags = imgIContainer::FLAG_ASYNC_NOTIFY; + if (aFlags & SVGIntegrationUtils::FLAG_SYNC_DECODE_IMAGES) { + imgFlags |= imgIContainer::FLAG_SYNC_DECODE; + } + imgDrawingParams imgParams(imgFlags); + RefPtr<gfxPattern> pattern = server->GetPaintServerPattern( + aTarget, aDrawTarget, aContextMatrix, &nsStyleSVG::mFill, 1.0, + imgParams, &overrideBounds); + + if (!pattern) { + return nullptr; + } + + // pattern is now set up to fill aPaintServerSize. But we want it to + // fill aRenderSize, so we need to add a scaling transform. + // We couldn't just have set overrideBounds to aRenderSize - it would have + // worked for gradients, but for patterns it would result in a different + // pattern size. + gfxFloat scaleX = overrideBounds.Width() / aRenderSize.width; + gfxFloat scaleY = overrideBounds.Height() / aRenderSize.height; + gfxMatrix scaleMatrix = gfxMatrix::Scaling(scaleX, scaleY); + pattern->SetMatrix(scaleMatrix * pattern->GetMatrix()); + return do_AddRef(new gfxPatternDrawable(pattern, aRenderSize)); + } + + if (aFrame->IsSVGFrame() && + !static_cast<ISVGDisplayableFrame*>(do_QueryFrame(aFrame))) { + MOZ_ASSERT_UNREACHABLE( + "We should prevent painting of unpaintable SVG " + "before we get here"); + return nullptr; + } + + // We don't want to paint into a surface as long as we don't need to, so we + // set up a drawing callback. + RefPtr<gfxDrawingCallback> cb = + new PaintFrameCallback(aFrame, aPaintServerSize, aRenderSize, aFlags); + return do_AddRef(new gfxCallbackDrawable(cb, aRenderSize)); +} + +} // namespace mozilla |