The Tor Browser: comparison layout/svg/nsSVGIntegrationUtils.cpp

--1:000000000000
+:5fc54ab750cd
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// Main header first:
+#include "nsSVGIntegrationUtils.h"
+// Keep others in (case-insensitive) order:
+#include "gfxDrawable.h"
+#include "nsCSSAnonBoxes.h"
+#include "nsDisplayList.h"
+#include "nsFilterInstance.h"
+#include "nsLayoutUtils.h"
+#include "nsRenderingContext.h"
+#include "nsSVGClipPathFrame.h"
+#include "nsSVGEffects.h"
+#include "nsSVGElement.h"
+#include "nsSVGFilterPaintCallback.h"
+#include "nsSVGMaskFrame.h"
+#include "nsSVGPaintServerFrame.h"
+#include "nsSVGUtils.h"
+#include "FrameLayerBuilder.h"
+#include "BasicLayers.h"
+#include "mozilla/gfx/Point.h"
+using namespace mozilla;
+using namespace mozilla::layers;
+// ----------------------------------------------------------------------
+/**
+* This class is used to get the pre-effects visual overflow rect of a frame,
+* or, in the case of a frame with continuations, to collect the union of the
+* pre-effects visual 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 PreEffectsVisualOverflowCollector : public nsLayoutUtils::BoxCallback
+{
+public:
+/**
+* If the pre-effects visual overflow rect of the frame being examined
+* happens to be known, it can be passed in as aCurrentFrame and its
+* pre-effects visual overflow rect can be passed in as
+* aCurrentFrameOverflowArea. This is just an optimization to save a
+* frame property lookup - these arguments are optional.
+*/
+PreEffectsVisualOverflowCollector(nsIFrame* aFirstContinuation,
+nsIFrame* aCurrentFrame,
+const nsRect& aCurrentFrameOverflowArea)
+: mFirstContinuation(aFirstContinuation)
+, mCurrentFrame(aCurrentFrame)
+, mCurrentFrameOverflowArea(aCurrentFrameOverflowArea)
+{
+NS_ASSERTION(!mFirstContinuation->GetPrevContinuation(),
+"We want the first continuation here");
+}
+virtual void AddBox(nsIFrame* aFrame) MOZ_OVERRIDE {
+nsRect overflow = (aFrame == mCurrentFrame) ?
+mCurrentFrameOverflowArea : GetPreEffectsVisualOverflowRect(aFrame);
+mResult.UnionRect(mResult, overflow + aFrame->GetOffsetTo(mFirstContinuation));
+}
+nsRect GetResult() const {
+return mResult;
+}
+private:
+static nsRect GetPreEffectsVisualOverflowRect(nsIFrame* aFrame) {
+nsRect* r = static_cast<nsRect*>
+(aFrame->Properties().Get(nsIFrame::PreEffectsBBoxProperty()));
+if (r) {
+return *r;
+}
+// Despite the fact that we're invoked for frames with SVG effects applied,
+// we can actually get here. All continuations and IB split siblings of a
+// frame with SVG effects applied will have the PreEffectsBBoxProperty
+// property set on them. Therefore, the frames that are passed to us will
+// always have that property set...well, with one exception. If the frames
+// for an element with SVG effects applied have been subject to an "IB
+// split", then the block frame(s) that caused the split will have been
+// wrapped in anonymous, inline-block, nsBlockFrames of pseudo-type
+// nsCSSAnonBoxes::mozAnonymousBlock. These "IB split sibling" anonymous
+// blocks will have the PreEffectsBBoxProperty property set on them, but
+// they will never be passed to us. Instead, we'll be passed the block
+// children that they wrap, which don't have the PreEffectsBBoxProperty
+// property set on them. This is actually okay. What we care about is
+// collecting the _pre_ effects visual overflow rects of the frames to
+// which the SVG effects have been applied. Since the IB split results in
+// any overflow rect adjustments for transforms, effects, etc. taking
+// place on the anonymous block wrappers, the wrapped children are left
+// with their overflow rects unaffected. In other words, calling
+// GetVisualOverflowRect() on the children will return their pre-effects
+// visual overflow rects, just as we need.
+//
+// A couple of tests that demonstrate the IB split and cause us to get here
+// are:
+//
+//  * reftests/svg/svg-integration/clipPath-html-06.xhtml
+//  * reftests/svg/svg-integration/clipPath-html-06-extref.xhtml
+//
+// If we ever got passed a frame with the PreTransformOverflowAreasProperty
+// property set, that would be bad, since then our GetVisualOverflowRect()
+// call would give us the post-effects, and post-transform, overflow rect.
+//
+NS_ASSERTION(aFrame->GetParent()->StyleContext()->GetPseudo() ==
+nsCSSAnonBoxes::mozAnonymousBlock,
+"How did we getting here, then?");
+NS_ASSERTION(!aFrame->Properties().Get(
+aFrame->PreTransformOverflowAreasProperty()),
+"GetVisualOverflowRect() won't return the pre-effects rect!");
+return aFrame->GetVisualOverflowRect();
+}
+nsIFrame*     mFirstContinuation;
+nsIFrame*     mCurrentFrame;
+const nsRect& mCurrentFrameOverflowArea;
+nsRect        mResult;
+};
+/**
+* Gets the union of the pre-effects visual overflow rects of all of a frame's
+* continuations, in "user space".
+*/
+static nsRect
+GetPreEffectsVisualOverflowUnion(nsIFrame* aFirstContinuation,
+nsIFrame* aCurrentFrame,
+const nsRect& aCurrentFramePreEffectsOverflow,
+const nsPoint& aFirstContinuationToUserSpace)
+{
+NS_ASSERTION(!aFirstContinuation->GetPrevContinuation(),
+"Need first continuation here");
+PreEffectsVisualOverflowCollector collector(aFirstContinuation,
+aCurrentFrame,
+aCurrentFramePreEffectsOverflow);
+// Compute union of all overflow areas relative to aFirstContinuation:
+nsLayoutUtils::GetAllInFlowBoxes(aFirstContinuation, &collector);
+// Return the result in user space:
+return collector.GetResult() + aFirstContinuationToUserSpace;
+}
+bool
+nsSVGIntegrationUtils::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();
+return (style->HasFilters() || style->mClipPath || style->mMask);
+}
+// For non-SVG frames, this gives the offset to the frame's "user space".
+// For SVG frames, this returns a zero offset.
+static nsPoint
+GetOffsetToBoundingBox(nsIFrame* aFrame)
+{
+if ((aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT)) {
+// Do NOT call GetAllInFlowRectsUnion for SVG - it will get the
+// covered region relative to the nsSVGOuterSVGFrame, which is absolutely
+// not what we want. SVG frames are always in user space, so they have
+// no offset adjustment to make.
+return nsPoint();
+}
+// We could allow aFrame to be any continuation, but since that would require
+// a GetPrevContinuation() virtual call and conditional returns, and since
+// all our current consumers always pass in the first continuation, we don't
+// currently bother.
+NS_ASSERTION(!aFrame->GetPrevContinuation(), "Not first continuation");
+// 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();
+}
+/* static */ nsSize
+nsSVGIntegrationUtils::GetContinuationUnionSize(nsIFrame* aNonSVGFrame)
+{
+NS_ASSERTION(!aNonSVGFrame->IsFrameOfType(nsIFrame::eSVG),
+"SVG frames should not get here");
+nsIFrame* firstFrame =
+nsLayoutUtils::FirstContinuationOrIBSplitSibling(aNonSVGFrame);
+return nsLayoutUtils::GetAllInFlowRectsUnion(firstFrame, firstFrame).Size();
+}
+/* static */ gfx::Size
+nsSVGIntegrationUtils::GetSVGCoordContextForNonSVGFrame(nsIFrame* aNonSVGFrame)
+{
+NS_ASSERTION(!aNonSVGFrame->IsFrameOfType(nsIFrame::eSVG),
+"SVG frames should not get here");
+nsIFrame* firstFrame =
+nsLayoutUtils::FirstContinuationOrIBSplitSibling(aNonSVGFrame);
+nsRect r = nsLayoutUtils::GetAllInFlowRectsUnion(firstFrame, firstFrame);
+nsPresContext* presContext = firstFrame->PresContext();
+return gfx::Size(presContext->AppUnitsToFloatCSSPixels(r.width),
+presContext->AppUnitsToFloatCSSPixels(r.height));
+}
+gfxRect
+nsSVGIntegrationUtils::GetSVGBBoxForNonSVGFrame(nsIFrame* aNonSVGFrame)
+{
+NS_ASSERTION(!aNonSVGFrame->IsFrameOfType(nsIFrame::eSVG),
+"SVG frames should not get here");
+nsIFrame* firstFrame =
+nsLayoutUtils::FirstContinuationOrIBSplitSibling(aNonSVGFrame);
+// 'r' is in "user space":
+nsRect r = GetPreEffectsVisualOverflowUnion(firstFrame, nullptr, nsRect(),
+GetOffsetToBoundingBox(firstFrame));
+return nsLayoutUtils::RectToGfxRect(r,
+aNonSVGFrame->PresContext()->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 GetPreEffectsVisualOverflowUnion() calls will
+// obtain valid border boxes for all the continuations. As a result, we'll
+// end up returning bogus post-filter visual 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
+// GetPreEffectsVisualOverflowUnion 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 visual 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 visual 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
+nsSVGIntegrationUtils::
+ComputePostEffectsVisualOverflowRect(nsIFrame* aFrame,
+const nsRect& aPreEffectsOverflowRect)
+{
+NS_ASSERTION(!(aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT),
+"Don't call this on SVG child frames");
+nsIFrame* firstFrame =
+nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame);
+nsSVGEffects::EffectProperties effectProperties =
+nsSVGEffects::GetEffectProperties(firstFrame);
+if (!effectProperties.HasValidFilter()) {
+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(
+GetPreEffectsVisualOverflowUnion(firstFrame, aFrame,
+aPreEffectsOverflowRect,
+firstFrameToBoundingBox),
+aFrame->PresContext()->AppUnitsPerCSSPixel());
+overrideBBox.RoundOut();
+nsRect overflowRect =
+nsFilterInstance::GetPostFilterBounds(firstFrame, &overrideBBox);
+// Return overflowRect relative to aFrame, rather than "user space":
+return overflowRect - (aFrame->GetOffsetTo(firstFrame) + firstFrameToBoundingBox);
+}
+nsIntRegion
+nsSVGIntegrationUtils::AdjustInvalidAreaForSVGEffects(nsIFrame* aFrame,
+const nsPoint& aToReferenceFrame,
+const nsIntRegion& aInvalidRegion)
+{
+if (aInvalidRegion.IsEmpty()) {
+return nsIntRect();
+}
+// Don't bother calling GetEffectProperties; the filter property should
+// already have been set up during reflow/ComputeFrameEffectsRect
+nsIFrame* firstFrame =
+nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame);
+nsSVGFilterProperty *prop = nsSVGEffects::GetFilterProperty(firstFrame);
+if (!prop || !prop->IsInObserverLists()) {
+return aInvalidRegion;
+}
+int32_t appUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
+if (!prop || !prop->ReferencesValidResources()) {
+// The frame is either not there or not currently available,
+// perhaps because we're in the middle of tearing stuff down.
+// Be conservative, return our visual overflow rect relative
+// to the reference frame.
+nsRect overflow = aFrame->GetVisualOverflowRect() + aToReferenceFrame;
+return overflow.ToOutsidePixels(appUnitsPerDevPixel);
+}
+// Convert aInvalidRegion into bounding box frame space in app units:
+nsPoint toBoundingBox =
+aFrame->GetOffsetTo(firstFrame) + GetOffsetToBoundingBox(firstFrame);
+// The initial rect was relative to the reference frame, so we need to
+// remove that offset to get a rect relative to the current frame.
+toBoundingBox -= aToReferenceFrame;
+nsRegion preEffectsRegion = aInvalidRegion.ToAppUnits(appUnitsPerDevPixel).MovedBy(toBoundingBox);
+// Adjust the dirty area for effects, and shift it back to being relative to
+// the reference frame.
+nsRegion result = nsFilterInstance::GetPostFilterDirtyArea(firstFrame,
+preEffectsRegion).MovedBy(-toBoundingBox);
+// Return the result, in pixels relative to the reference frame.
+return result.ToOutsidePixels(appUnitsPerDevPixel);
+}
+nsRect
+nsSVGIntegrationUtils::GetRequiredSourceForInvalidArea(nsIFrame* aFrame,
+const nsRect& aDirtyRect)
+{
+// Don't bother calling GetEffectProperties; the filter property should
+// already have been set up during reflow/ComputeFrameEffectsRect
+nsIFrame* firstFrame =
+nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame);
+nsSVGFilterProperty *prop = nsSVGEffects::GetFilterProperty(firstFrame);
+if (!prop || !prop->ReferencesValidResources()) {
+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 nsFilterInstance::GetPreFilterNeededArea(firstFrame, postEffectsRect).GetBounds()
+- toUserSpace;
+}
+bool
+nsSVGIntegrationUtils::HitTestFrameForEffects(nsIFrame* aFrame, const nsPoint& aPt)
+{
+nsIFrame* firstFrame =
+nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame);
+// Convert aPt to user space:
+nsPoint toUserSpace;
+if (aFrame->GetStateBits() & 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;
+return nsSVGUtils::HitTestClip(firstFrame, pt);
+}
+class RegularFramePaintCallback : public nsSVGFilterPaintCallback
+{
+public:
+RegularFramePaintCallback(nsDisplayListBuilder* aBuilder,
+LayerManager* aManager,
+const nsPoint& aOffset)
+: mBuilder(aBuilder), mLayerManager(aManager),
+mOffset(aOffset) {}
+virtual void Paint(nsRenderingContext *aContext, nsIFrame *aTarget,
+const nsIntRect* aDirtyRect,
+nsIFrame* aTransformRoot) MOZ_OVERRIDE
+{
+BasicLayerManager* basic = static_cast<BasicLayerManager*>(mLayerManager);
+basic->SetTarget(aContext->ThebesContext());
+nsRenderingContext::AutoPushTranslation push(aContext, -mOffset);
+mLayerManager->EndTransaction(FrameLayerBuilder::DrawThebesLayer, mBuilder);
+}
+private:
+nsDisplayListBuilder* mBuilder;
+LayerManager* mLayerManager;
+nsPoint mOffset;
+};
+void
+nsSVGIntegrationUtils::PaintFramesWithEffects(nsRenderingContext* aCtx,
+nsIFrame* aFrame,
+const nsRect& aDirtyRect,
+nsDisplayListBuilder* aBuilder,
+LayerManager *aLayerManager)
+{
+#ifdef DEBUG
+NS_ASSERTION(!(aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT) ||
+(NS_SVGDisplayListPaintingEnabled() &&
+!(aFrame->GetStateBits() & NS_FRAME_IS_NONDISPLAY)),
+"Should not use nsSVGIntegrationUtils on this SVG frame");
+#endif
+/* SVG defines the following rendering model:
+*
+*  1. Render geometry
+*  2. Apply filter
+*  3. Apply clipping, masking, group opacity
+*
+* We follow this, but perform a couple of optimizations:
+*
+* + Use cairo's clipPath when representable natively (single object
+*   clip region).
+*
+* + Merge opacity and masking if both used together.
+*/
+const nsIContent* content = aFrame->GetContent();
+bool hasSVGLayout = (aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT);
+if (hasSVGLayout) {
+nsISVGChildFrame *svgChildFrame = do_QueryFrame(aFrame);
+if (!svgChildFrame || !aFrame->GetContent()->IsSVG()) {
+NS_ASSERTION(false, "why?");
+return;
+}
+if (!static_cast<const nsSVGElement*>(content)->HasValidDimensions()) {
+return; // The SVG spec says not to draw _anything_
+}
+}
+float opacity = aFrame->StyleDisplay()->mOpacity;
+if (opacity == 0.0f) {
+return;
+}
+if (opacity != 1.0f &&
+hasSVGLayout && nsSVGUtils::CanOptimizeOpacity(aFrame)) {
+opacity = 1.0f;
+}
+/* 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(aFrame);
+nsSVGEffects::EffectProperties effectProperties =
+nsSVGEffects::GetEffectProperties(firstFrame);
+bool isOK = effectProperties.HasNoFilterOrHasValidFilter();
+nsSVGClipPathFrame *clipPathFrame = effectProperties.GetClipPathFrame(&isOK);
+nsSVGMaskFrame *maskFrame = effectProperties.GetMaskFrame(&isOK);
+if (!isOK) {
+return; // Some resource is missing. We shouldn't paint anything.
+}
+bool isTrivialClip = clipPathFrame ? clipPathFrame->IsTrivial() : true;
+gfxContext* gfx = aCtx->ThebesContext();
+gfxContextMatrixAutoSaveRestore matrixAutoSaveRestore(gfx);
+nsPoint firstFrameOffset = GetOffsetToBoundingBox(firstFrame);
+nsPoint offsetToBoundingBox = aBuilder->ToReferenceFrame(firstFrame) - firstFrameOffset;
+if (!firstFrame->IsFrameOfType(nsIFrame::eSVG)) {
+/* Snap the offset if the reference frame is not a SVG frame,
+* since other frames will be snapped to pixel when rendering. */
+offsetToBoundingBox = nsPoint(
+aFrame->PresContext()->RoundAppUnitsToNearestDevPixels(offsetToBoundingBox.x),
+aFrame->PresContext()->RoundAppUnitsToNearestDevPixels(offsetToBoundingBox.y));
+}
+// After applying only "offsetToBoundingBox", aCtx would have its origin at
+// the top left corner of aFrame'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 aCtx 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 = nsSVGUtils::FrameSpaceInCSSPxToUserSpaceOffset(aFrame);
+nsPoint toUserSpace(nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.x)),
+nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.y)));
+nsPoint offsetToUserSpace = offsetToBoundingBox - toUserSpace;
+NS_ASSERTION(hasSVGLayout || offsetToBoundingBox == offsetToUserSpace,
+"For non-SVG frames there shouldn't be any additional offset");
+aCtx->Translate(offsetToUserSpace);
+gfxMatrix cssPxToDevPxMatrix = GetCSSPxToDevPxMatrix(aFrame);
+bool complexEffects = false;
+/* Check if we need to do additional operations on this child's
+* rendering, which necessitates rendering into another surface. */
+if (opacity != 1.0f || maskFrame || (clipPathFrame && !isTrivialClip)
+|| aFrame->StyleDisplay()->mMixBlendMode != NS_STYLE_BLEND_NORMAL) {
+complexEffects = true;
+gfx->Save();
+aCtx->IntersectClip(aFrame->GetVisualOverflowRectRelativeToSelf() +
+toUserSpace);
+gfx->PushGroup(gfxContentType::COLOR_ALPHA);
+}
+/* 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 (clipPathFrame && isTrivialClip) {
+gfx->Save();
+clipPathFrame->ClipPaint(aCtx, aFrame, cssPxToDevPxMatrix);
+}
+/* Paint the child */
+if (effectProperties.HasValidFilter()) {
+RegularFramePaintCallback callback(aBuilder, aLayerManager,
+offsetToUserSpace);
+nsRegion dirtyRegion = aDirtyRect - offsetToBoundingBox;
+nsFilterInstance::PaintFilteredFrame(aCtx, aFrame, &callback, &dirtyRegion);
+} else {
+gfx->SetMatrix(matrixAutoSaveRestore.Matrix());
+aLayerManager->EndTransaction(FrameLayerBuilder::DrawThebesLayer, aBuilder);
+aCtx->Translate(offsetToUserSpace);
+}
+if (clipPathFrame && isTrivialClip) {
+gfx->Restore();
+}
+/* No more effects, we're done. */
+if (!complexEffects) {
+return;
+}
+gfx->PopGroupToSource();
+nsRefPtr<gfxPattern> maskSurface =
+maskFrame ? maskFrame->ComputeMaskAlpha(aCtx, aFrame,
+cssPxToDevPxMatrix, opacity) : nullptr;
+nsRefPtr<gfxPattern> clipMaskSurface;
+if (clipPathFrame && !isTrivialClip) {
+gfx->PushGroup(gfxContentType::COLOR_ALPHA);
+nsresult rv = clipPathFrame->ClipPaint(aCtx, aFrame, cssPxToDevPxMatrix);
+clipMaskSurface = gfx->PopGroup();
+if (NS_SUCCEEDED(rv) && clipMaskSurface) {
+// Still more set after clipping, so clip to another surface
+if (maskSurface || opacity != 1.0f) {
+gfx->PushGroup(gfxContentType::COLOR_ALPHA);
+gfx->Mask(clipMaskSurface);
+gfx->PopGroupToSource();
+} else {
+gfx->Mask(clipMaskSurface);
+}
+}
+}
+if (maskSurface) {
+gfx->Mask(maskSurface);
+} else if (opacity != 1.0f) {
+gfx->Paint(opacity);
+}
+gfx->Restore();
+}
+gfxMatrix
+nsSVGIntegrationUtils::GetCSSPxToDevPxMatrix(nsIFrame* aNonSVGFrame)
+{
+int32_t appUnitsPerDevPixel = aNonSVGFrame->PresContext()->AppUnitsPerDevPixel();
+float devPxPerCSSPx =
+1 / nsPresContext::AppUnitsToFloatCSSPixels(appUnitsPerDevPixel);
+return gfxMatrix(devPxPerCSSPx, 0.0,
+0.0, devPxPerCSSPx,
+0.0, 0.0);
+}
+class PaintFrameCallback : public gfxDrawingCallback {
+public:
+PaintFrameCallback(nsIFrame* aFrame,
+const nsSize aPaintServerSize,
+const gfxIntSize aRenderSize,
+uint32_t aFlags)
+: mFrame(aFrame)
+, mPaintServerSize(aPaintServerSize)
+, mRenderSize(aRenderSize)
+, mFlags (aFlags)
+{}
+virtual bool operator()(gfxContext* aContext,
+const gfxRect& aFillRect,
+const GraphicsFilter& aFilter,
+const gfxMatrix& aTransform) MOZ_OVERRIDE;
+private:
+nsIFrame* mFrame;
+nsSize mPaintServerSize;
+gfxIntSize mRenderSize;
+uint32_t mFlags;
+};
+bool
+PaintFrameCallback::operator()(gfxContext* aContext,
+const gfxRect& aFillRect,
+const GraphicsFilter& aFilter,
+const gfxMatrix& aTransform)
+{
+if (mFrame->GetStateBits() & NS_FRAME_DRAWING_AS_PAINTSERVER)
+return false;
+mFrame->AddStateBits(NS_FRAME_DRAWING_AS_PAINTSERVER);
+nsRefPtr<nsRenderingContext> context(new nsRenderingContext());
+context->Init(mFrame->PresContext()->DeviceContext(), aContext);
+aContext->Save();
+// Clip to aFillRect so that we don't paint outside.
+aContext->NewPath();
+aContext->Rectangle(aFillRect);
+aContext->Clip();
+aContext->Multiply(gfxMatrix(aTransform).Invert());
+// 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 = GetOffsetToBoundingBox(mFrame);
+gfxPoint devPxOffset = gfxPoint(offset.x, offset.y) / appUnitsPerDevPixel;
+aContext->Multiply(gfxMatrix().Translate(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;
+gfxMatrix scaleMatrix = gfxMatrix().Scale(scaleX, scaleY);
+aContext->Multiply(scaleMatrix);
+// Draw.
+nsRect dirty(-offset.x, -offset.y,
+mPaintServerSize.width, mPaintServerSize.height);
+uint32_t flags = nsLayoutUtils::PAINT_IN_TRANSFORM |
+nsLayoutUtils::PAINT_ALL_CONTINUATIONS;
+if (mFlags & nsSVGIntegrationUtils::FLAG_SYNC_DECODE_IMAGES) {
+flags |= nsLayoutUtils::PAINT_SYNC_DECODE_IMAGES;
+}
+nsLayoutUtils::PaintFrame(context, mFrame,
+dirty, NS_RGBA(0, 0, 0, 0),
+flags);
+aContext->Restore();
+mFrame->RemoveStateBits(NS_FRAME_DRAWING_AS_PAINTSERVER);
+return true;
+}
+/* static */ already_AddRefed<gfxDrawable>
+nsSVGIntegrationUtils::DrawableFromPaintServer(nsIFrame*         aFrame,
+nsIFrame*         aTarget,
+const nsSize&     aPaintServerSize,
+const gfxIntSize& aRenderSize,
+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 (aFrame->IsFrameOfType(nsIFrame::eSVGPaintServer)) {
+// 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.
+nsSVGPaintServerFrame* server =
+static_cast<nsSVGPaintServerFrame*>(aFrame);
+gfxRect overrideBounds(0, 0,
+aPaintServerSize.width, aPaintServerSize.height);
+overrideBounds.ScaleInverse(aFrame->PresContext()->AppUnitsPerDevPixel());
+nsRefPtr<gfxPattern> pattern =
+server->GetPaintServerPattern(aTarget, aContextMatrix,
+&nsStyleSVG::mFill, 1.0, &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().Scale(scaleX, scaleY);
+pattern->SetMatrix(scaleMatrix.Multiply(pattern->GetMatrix()));
+nsRefPtr<gfxDrawable> drawable =
+new gfxPatternDrawable(pattern, aRenderSize);
+return drawable.forget();
+}
+// We don't want to paint into a surface as long as we don't need to, so we
+// set up a drawing callback.
+nsRefPtr<gfxDrawingCallback> cb =
+new PaintFrameCallback(aFrame, aPaintServerSize, aRenderSize, aFlags);
+nsRefPtr<gfxDrawable> drawable = new gfxCallbackDrawable(cb, aRenderSize);
+return drawable.forget();
+}

The Tor Browser / file comparison

comparison: layout/svg/nsSVGIntegrationUtils.cpp

layout/svg/nsSVGIntegrationUtils.cpp