diff options
Diffstat (limited to 'layout/svg/SVGGradientFrame.cpp')
| -rw-r--r-- | layout/svg/SVGGradientFrame.cpp | 606 |
1 files changed, 606 insertions, 0 deletions
diff --git a/layout/svg/SVGGradientFrame.cpp b/layout/svg/SVGGradientFrame.cpp new file mode 100644 index 0000000000..42116a9851 --- /dev/null +++ b/layout/svg/SVGGradientFrame.cpp @@ -0,0 +1,606 @@ +/* -*- 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 "SVGGradientFrame.h" +#include <algorithm> + +// Keep others in (case-insensitive) order: +#include "AutoReferenceChainGuard.h" +#include "gfxPattern.h" +#include "gfxUtils.h" +#include "mozilla/PresShell.h" +#include "mozilla/SVGObserverUtils.h" +#include "mozilla/SVGUtils.h" +#include "mozilla/dom/SVGGradientElement.h" +#include "mozilla/dom/SVGGradientElementBinding.h" +#include "mozilla/dom/SVGStopElement.h" +#include "mozilla/dom/SVGUnitTypesBinding.h" +#include "nsContentUtils.h" +#include "SVGAnimatedTransformList.h" + +// XXX Tight coupling with content classes ahead! + +using namespace mozilla::dom; +using namespace mozilla::dom::SVGGradientElement_Binding; +using namespace mozilla::dom::SVGUnitTypes_Binding; +using namespace mozilla::gfx; + +namespace mozilla { + +//---------------------------------------------------------------------- +// Implementation + +SVGGradientFrame::SVGGradientFrame(ComputedStyle* aStyle, + nsPresContext* aPresContext, ClassID aID) + : SVGPaintServerFrame(aStyle, aPresContext, aID), + mSource(nullptr), + mLoopFlag(false), + mNoHRefURI(false) {} + +NS_QUERYFRAME_HEAD(SVGGradientFrame) + NS_QUERYFRAME_ENTRY(SVGGradientFrame) +NS_QUERYFRAME_TAIL_INHERITING(SVGPaintServerFrame) + +//---------------------------------------------------------------------- +// nsIFrame methods: + +nsresult SVGGradientFrame::AttributeChanged(int32_t aNameSpaceID, + nsAtom* aAttribute, + int32_t aModType) { + if (aNameSpaceID == kNameSpaceID_None && + (aAttribute == nsGkAtoms::gradientUnits || + aAttribute == nsGkAtoms::gradientTransform || + aAttribute == nsGkAtoms::spreadMethod)) { + SVGObserverUtils::InvalidateDirectRenderingObservers(this); + } else if ((aNameSpaceID == kNameSpaceID_XLink || + aNameSpaceID == kNameSpaceID_None) && + aAttribute == nsGkAtoms::href) { + // Blow away our reference, if any + SVGObserverUtils::RemoveTemplateObserver(this); + mNoHRefURI = false; + // And update whoever references us + SVGObserverUtils::InvalidateDirectRenderingObservers(this); + } + + return SVGPaintServerFrame::AttributeChanged(aNameSpaceID, aAttribute, + aModType); +} + +//---------------------------------------------------------------------- + +uint16_t SVGGradientFrame::GetEnumValue(uint32_t aIndex, nsIContent* aDefault) { + const SVGAnimatedEnumeration& thisEnum = + static_cast<dom::SVGGradientElement*>(GetContent()) + ->mEnumAttributes[aIndex]; + + if (thisEnum.IsExplicitlySet()) { + return thisEnum.GetAnimValue(); + } + + // Before we recurse, make sure we'll break reference loops and over long + // reference chains: + static int16_t sRefChainLengthCounter = AutoReferenceChainGuard::noChain; + AutoReferenceChainGuard refChainGuard(this, &mLoopFlag, + &sRefChainLengthCounter); + if (MOZ_UNLIKELY(!refChainGuard.Reference())) { + // Break reference chain + return static_cast<dom::SVGGradientElement*>(aDefault) + ->mEnumAttributes[aIndex] + .GetAnimValue(); + } + + SVGGradientFrame* next = GetReferencedGradient(); + + return next ? next->GetEnumValue(aIndex, aDefault) + : static_cast<dom::SVGGradientElement*>(aDefault) + ->mEnumAttributes[aIndex] + .GetAnimValue(); +} + +uint16_t SVGGradientFrame::GetGradientUnits() { + // This getter is called every time the others are called - maybe cache it? + return GetEnumValue(dom::SVGGradientElement::GRADIENTUNITS); +} + +uint16_t SVGGradientFrame::GetSpreadMethod() { + return GetEnumValue(dom::SVGGradientElement::SPREADMETHOD); +} + +const SVGAnimatedTransformList* SVGGradientFrame::GetGradientTransformList( + nsIContent* aDefault) { + SVGAnimatedTransformList* thisTransformList = + static_cast<dom::SVGGradientElement*>(GetContent()) + ->GetAnimatedTransformList(); + + if (thisTransformList && thisTransformList->IsExplicitlySet()) + return thisTransformList; + + // Before we recurse, make sure we'll break reference loops and over long + // reference chains: + static int16_t sRefChainLengthCounter = AutoReferenceChainGuard::noChain; + AutoReferenceChainGuard refChainGuard(this, &mLoopFlag, + &sRefChainLengthCounter); + if (MOZ_UNLIKELY(!refChainGuard.Reference())) { + // Break reference chain + return static_cast<const dom::SVGGradientElement*>(aDefault) + ->mGradientTransform.get(); + } + + SVGGradientFrame* next = GetReferencedGradient(); + + return next ? next->GetGradientTransformList(aDefault) + : static_cast<const dom::SVGGradientElement*>(aDefault) + ->mGradientTransform.get(); +} + +gfxMatrix SVGGradientFrame::GetGradientTransform( + nsIFrame* aSource, const gfxRect* aOverrideBounds) { + gfxMatrix bboxMatrix; + + uint16_t gradientUnits = GetGradientUnits(); + if (gradientUnits != SVG_UNIT_TYPE_USERSPACEONUSE) { + NS_ASSERTION(gradientUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX, + "Unknown gradientUnits type"); + // objectBoundingBox is the default anyway + + gfxRect bbox = aOverrideBounds + ? *aOverrideBounds + : SVGUtils::GetBBox( + aSource, SVGUtils::eUseFrameBoundsForOuterSVG | + SVGUtils::eBBoxIncludeFillGeometry); + bboxMatrix = + gfxMatrix(bbox.Width(), 0, 0, bbox.Height(), bbox.X(), bbox.Y()); + } + + const SVGAnimatedTransformList* animTransformList = + GetGradientTransformList(GetContent()); + if (!animTransformList) { + return bboxMatrix; + } + + gfxMatrix gradientTransform = + animTransformList->GetAnimValue().GetConsolidationMatrix(); + return bboxMatrix.PreMultiply(gradientTransform); +} + +dom::SVGLinearGradientElement* SVGGradientFrame::GetLinearGradientWithLength( + uint32_t aIndex, dom::SVGLinearGradientElement* aDefault) { + // If this was a linear gradient with the required length, we would have + // already found it in SVGLinearGradientFrame::GetLinearGradientWithLength. + // Since we didn't find the length, continue looking down the chain. + + // Before we recurse, make sure we'll break reference loops and over long + // reference chains: + static int16_t sRefChainLengthCounter = AutoReferenceChainGuard::noChain; + AutoReferenceChainGuard refChainGuard(this, &mLoopFlag, + &sRefChainLengthCounter); + if (MOZ_UNLIKELY(!refChainGuard.Reference())) { + // Break reference chain + return aDefault; + } + + SVGGradientFrame* next = GetReferencedGradient(); + return next ? next->GetLinearGradientWithLength(aIndex, aDefault) : aDefault; +} + +dom::SVGRadialGradientElement* SVGGradientFrame::GetRadialGradientWithLength( + uint32_t aIndex, dom::SVGRadialGradientElement* aDefault) { + // If this was a radial gradient with the required length, we would have + // already found it in SVGRadialGradientFrame::GetRadialGradientWithLength. + // Since we didn't find the length, continue looking down the chain. + + // Before we recurse, make sure we'll break reference loops and over long + // reference chains: + static int16_t sRefChainLengthCounter = AutoReferenceChainGuard::noChain; + AutoReferenceChainGuard refChainGuard(this, &mLoopFlag, + &sRefChainLengthCounter); + if (MOZ_UNLIKELY(!refChainGuard.Reference())) { + // Break reference chain + return aDefault; + } + + SVGGradientFrame* next = GetReferencedGradient(); + return next ? next->GetRadialGradientWithLength(aIndex, aDefault) : aDefault; +} + +//---------------------------------------------------------------------- +// SVGPaintServerFrame methods: + +// helper +static void GetStopInformation(nsIFrame* aStopFrame, float* aOffset, + nscolor* aStopColor, float* aStopOpacity) { + nsIContent* stopContent = aStopFrame->GetContent(); + MOZ_ASSERT(stopContent && stopContent->IsSVGElement(nsGkAtoms::stop)); + + static_cast<SVGStopElement*>(stopContent) + ->GetAnimatedNumberValues(aOffset, nullptr); + + const nsStyleSVGReset* styleSVGReset = aStopFrame->StyleSVGReset(); + *aOffset = mozilla::clamped(*aOffset, 0.0f, 1.0f); + *aStopColor = styleSVGReset->mStopColor.CalcColor(aStopFrame); + *aStopOpacity = styleSVGReset->mStopOpacity; +} + +already_AddRefed<gfxPattern> SVGGradientFrame::GetPaintServerPattern( + nsIFrame* aSource, const DrawTarget* aDrawTarget, + const gfxMatrix& aContextMatrix, StyleSVGPaint nsStyleSVG::*aFillOrStroke, + float aGraphicOpacity, imgDrawingParams& aImgParams, + const gfxRect* aOverrideBounds) { + uint16_t gradientUnits = GetGradientUnits(); + MOZ_ASSERT(gradientUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX || + gradientUnits == SVG_UNIT_TYPE_USERSPACEONUSE); + if (gradientUnits == SVG_UNIT_TYPE_USERSPACEONUSE) { + // Set mSource for this consumer. + // If this gradient is applied to text, our caller will be the glyph, which + // is not an element, so we need to get the parent + mSource = aSource->GetContent()->IsText() ? aSource->GetParent() : aSource; + } + + AutoTArray<nsIFrame*, 8> stopFrames; + GetStopFrames(&stopFrames); + + uint32_t nStops = stopFrames.Length(); + + // SVG specification says that no stops should be treated like + // the corresponding fill or stroke had "none" specified. + if (nStops == 0) { + RefPtr<gfxPattern> pattern = new gfxPattern(DeviceColor()); + return do_AddRef(new gfxPattern(DeviceColor())); + } + + if (nStops == 1 || GradientVectorLengthIsZero()) { + auto* lastStopFrame = stopFrames[nStops - 1]; + const auto* svgReset = lastStopFrame->StyleSVGReset(); + // The gradient paints a single colour, using the stop-color of the last + // gradient step if there are more than one. + float stopOpacity = svgReset->mStopOpacity; + nscolor stopColor = svgReset->mStopColor.CalcColor(lastStopFrame); + + sRGBColor stopColor2 = sRGBColor::FromABGR(stopColor); + stopColor2.a *= stopOpacity * aGraphicOpacity; + return do_AddRef(new gfxPattern(ToDeviceColor(stopColor2))); + } + + // Get the transform list (if there is one). We do this after the returns + // above since this call can be expensive when "gradientUnits" is set to + // "objectBoundingBox" (since that requiring a GetBBox() call). + gfxMatrix patternMatrix = GetGradientTransform(aSource, aOverrideBounds); + + if (patternMatrix.IsSingular()) { + return nullptr; + } + + // revert any vector effect transform so that the gradient appears unchanged + if (aFillOrStroke == &nsStyleSVG::mStroke) { + gfxMatrix userToOuterSVG; + if (SVGUtils::GetNonScalingStrokeTransform(aSource, &userToOuterSVG)) { + patternMatrix *= userToOuterSVG; + } + } + + if (!patternMatrix.Invert()) { + return nullptr; + } + + RefPtr<gfxPattern> gradient = CreateGradient(); + if (!gradient) { + return nullptr; + } + + uint16_t aSpread = GetSpreadMethod(); + if (aSpread == SVG_SPREADMETHOD_PAD) + gradient->SetExtend(ExtendMode::CLAMP); + else if (aSpread == SVG_SPREADMETHOD_REFLECT) + gradient->SetExtend(ExtendMode::REFLECT); + else if (aSpread == SVG_SPREADMETHOD_REPEAT) + gradient->SetExtend(ExtendMode::REPEAT); + + gradient->SetMatrix(patternMatrix); + + // setup stops + float lastOffset = 0.0f; + + for (uint32_t i = 0; i < nStops; i++) { + float offset, stopOpacity; + nscolor stopColor; + + GetStopInformation(stopFrames[i], &offset, &stopColor, &stopOpacity); + + if (offset < lastOffset) + offset = lastOffset; + else + lastOffset = offset; + + sRGBColor stopColor2 = sRGBColor::FromABGR(stopColor); + stopColor2.a *= stopOpacity * aGraphicOpacity; + gradient->AddColorStop(offset, ToDeviceColor(stopColor2)); + } + + return gradient.forget(); +} + +// Private (helper) methods + +SVGGradientFrame* SVGGradientFrame::GetReferencedGradient() { + if (mNoHRefURI) { + return nullptr; + } + + auto GetHref = [this](nsAString& aHref) { + dom::SVGGradientElement* grad = + static_cast<dom::SVGGradientElement*>(this->GetContent()); + if (grad->mStringAttributes[dom::SVGGradientElement::HREF] + .IsExplicitlySet()) { + grad->mStringAttributes[dom::SVGGradientElement::HREF].GetAnimValue(aHref, + grad); + } else { + grad->mStringAttributes[dom::SVGGradientElement::XLINK_HREF].GetAnimValue( + aHref, grad); + } + this->mNoHRefURI = aHref.IsEmpty(); + }; + + nsIFrame* tframe = SVGObserverUtils::GetAndObserveTemplate(this, GetHref); + if (tframe) { + return static_cast<SVGGradientFrame*>(do_QueryFrame(tframe)); + } + // We don't call SVGObserverUtils::RemoveTemplateObserver and set + // `mNoHRefURI = false` here since we want to be invalidated if the ID + // specified by our href starts resolving to a different/valid element. + + return nullptr; +} + +void SVGGradientFrame::GetStopFrames(nsTArray<nsIFrame*>* aStopFrames) { + nsIFrame* stopFrame = nullptr; + for (stopFrame = mFrames.FirstChild(); stopFrame; + stopFrame = stopFrame->GetNextSibling()) { + if (stopFrame->IsSVGStopFrame()) { + aStopFrames->AppendElement(stopFrame); + } + } + if (aStopFrames->Length() > 0) { + return; + } + + // Our gradient element doesn't have stops - try to "inherit" them + + // Before we recurse, make sure we'll break reference loops and over long + // reference chains: + static int16_t sRefChainLengthCounter = AutoReferenceChainGuard::noChain; + AutoReferenceChainGuard refChainGuard(this, &mLoopFlag, + &sRefChainLengthCounter); + if (MOZ_UNLIKELY(!refChainGuard.Reference())) { + // Break reference chain + return; + } + + SVGGradientFrame* next = GetReferencedGradient(); + if (next) { + next->GetStopFrames(aStopFrames); + } +} + +// ------------------------------------------------------------------------- +// Linear Gradients +// ------------------------------------------------------------------------- + +NS_QUERYFRAME_HEAD(SVGLinearGradientFrame) + NS_QUERYFRAME_ENTRY(SVGLinearGradientFrame) +NS_QUERYFRAME_TAIL_INHERITING(SVGGradientFrame) + +#ifdef DEBUG +void SVGLinearGradientFrame::Init(nsIContent* aContent, + nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) { + NS_ASSERTION(aContent->IsSVGElement(nsGkAtoms::linearGradient), + "Content is not an SVG linearGradient"); + + SVGGradientFrame::Init(aContent, aParent, aPrevInFlow); +} +#endif /* DEBUG */ + +nsresult SVGLinearGradientFrame::AttributeChanged(int32_t aNameSpaceID, + nsAtom* aAttribute, + int32_t aModType) { + if (aNameSpaceID == kNameSpaceID_None && + (aAttribute == nsGkAtoms::x1 || aAttribute == nsGkAtoms::y1 || + aAttribute == nsGkAtoms::x2 || aAttribute == nsGkAtoms::y2)) { + SVGObserverUtils::InvalidateDirectRenderingObservers(this); + } + + return SVGGradientFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType); +} + +//---------------------------------------------------------------------- + +float SVGLinearGradientFrame::GetLengthValue(uint32_t aIndex) { + dom::SVGLinearGradientElement* lengthElement = GetLinearGradientWithLength( + aIndex, static_cast<dom::SVGLinearGradientElement*>(GetContent())); + // We passed in mContent as a fallback, so, assuming mContent is non-null, the + // return value should also be non-null. + MOZ_ASSERT(lengthElement, + "Got unexpected null element from GetLinearGradientWithLength"); + const SVGAnimatedLength& length = lengthElement->mLengthAttributes[aIndex]; + + // Object bounding box units are handled by setting the appropriate + // transform in GetGradientTransform, but we need to handle user + // space units as part of the individual Get* routines. Fixes 323669. + + uint16_t gradientUnits = GetGradientUnits(); + if (gradientUnits == SVG_UNIT_TYPE_USERSPACEONUSE) { + return SVGUtils::UserSpace(mSource, &length); + } + + NS_ASSERTION(gradientUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX, + "Unknown gradientUnits type"); + + return length.GetAnimValue(static_cast<SVGViewportElement*>(nullptr)); +} + +dom::SVGLinearGradientElement* +SVGLinearGradientFrame::GetLinearGradientWithLength( + uint32_t aIndex, dom::SVGLinearGradientElement* aDefault) { + dom::SVGLinearGradientElement* thisElement = + static_cast<dom::SVGLinearGradientElement*>(GetContent()); + const SVGAnimatedLength& length = thisElement->mLengthAttributes[aIndex]; + + if (length.IsExplicitlySet()) { + return thisElement; + } + + return SVGGradientFrame::GetLinearGradientWithLength(aIndex, aDefault); +} + +bool SVGLinearGradientFrame::GradientVectorLengthIsZero() { + return GetLengthValue(dom::SVGLinearGradientElement::ATTR_X1) == + GetLengthValue(dom::SVGLinearGradientElement::ATTR_X2) && + GetLengthValue(dom::SVGLinearGradientElement::ATTR_Y1) == + GetLengthValue(dom::SVGLinearGradientElement::ATTR_Y2); +} + +already_AddRefed<gfxPattern> SVGLinearGradientFrame::CreateGradient() { + float x1, y1, x2, y2; + + x1 = GetLengthValue(dom::SVGLinearGradientElement::ATTR_X1); + y1 = GetLengthValue(dom::SVGLinearGradientElement::ATTR_Y1); + x2 = GetLengthValue(dom::SVGLinearGradientElement::ATTR_X2); + y2 = GetLengthValue(dom::SVGLinearGradientElement::ATTR_Y2); + + RefPtr<gfxPattern> pattern = new gfxPattern(x1, y1, x2, y2); + return pattern.forget(); +} + +// ------------------------------------------------------------------------- +// Radial Gradients +// ------------------------------------------------------------------------- + +NS_QUERYFRAME_HEAD(SVGRadialGradientFrame) + NS_QUERYFRAME_ENTRY(SVGRadialGradientFrame) +NS_QUERYFRAME_TAIL_INHERITING(SVGGradientFrame) + +#ifdef DEBUG +void SVGRadialGradientFrame::Init(nsIContent* aContent, + nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) { + NS_ASSERTION(aContent->IsSVGElement(nsGkAtoms::radialGradient), + "Content is not an SVG radialGradient"); + + SVGGradientFrame::Init(aContent, aParent, aPrevInFlow); +} +#endif /* DEBUG */ + +nsresult SVGRadialGradientFrame::AttributeChanged(int32_t aNameSpaceID, + nsAtom* aAttribute, + int32_t aModType) { + if (aNameSpaceID == kNameSpaceID_None && + (aAttribute == nsGkAtoms::r || aAttribute == nsGkAtoms::cx || + aAttribute == nsGkAtoms::cy || aAttribute == nsGkAtoms::fx || + aAttribute == nsGkAtoms::fy)) { + SVGObserverUtils::InvalidateDirectRenderingObservers(this); + } + + return SVGGradientFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType); +} + +//---------------------------------------------------------------------- + +float SVGRadialGradientFrame::GetLengthValue(uint32_t aIndex) { + dom::SVGRadialGradientElement* lengthElement = GetRadialGradientWithLength( + aIndex, static_cast<dom::SVGRadialGradientElement*>(GetContent())); + // We passed in mContent as a fallback, so, assuming mContent is non-null, + // the return value should also be non-null. + MOZ_ASSERT(lengthElement, + "Got unexpected null element from GetRadialGradientWithLength"); + return GetLengthValueFromElement(aIndex, *lengthElement); +} + +float SVGRadialGradientFrame::GetLengthValue(uint32_t aIndex, + float aDefaultValue) { + dom::SVGRadialGradientElement* lengthElement = + GetRadialGradientWithLength(aIndex, nullptr); + + return lengthElement ? GetLengthValueFromElement(aIndex, *lengthElement) + : aDefaultValue; +} + +float SVGRadialGradientFrame::GetLengthValueFromElement( + uint32_t aIndex, dom::SVGRadialGradientElement& aElement) { + const SVGAnimatedLength& length = aElement.mLengthAttributes[aIndex]; + + // Object bounding box units are handled by setting the appropriate + // transform in GetGradientTransform, but we need to handle user + // space units as part of the individual Get* routines. Fixes 323669. + + uint16_t gradientUnits = GetGradientUnits(); + if (gradientUnits == SVG_UNIT_TYPE_USERSPACEONUSE) { + return SVGUtils::UserSpace(mSource, &length); + } + + NS_ASSERTION(gradientUnits == SVG_UNIT_TYPE_OBJECTBOUNDINGBOX, + "Unknown gradientUnits type"); + + return length.GetAnimValue(static_cast<SVGViewportElement*>(nullptr)); +} + +dom::SVGRadialGradientElement* +SVGRadialGradientFrame::GetRadialGradientWithLength( + uint32_t aIndex, dom::SVGRadialGradientElement* aDefault) { + dom::SVGRadialGradientElement* thisElement = + static_cast<dom::SVGRadialGradientElement*>(GetContent()); + const SVGAnimatedLength& length = thisElement->mLengthAttributes[aIndex]; + + if (length.IsExplicitlySet()) { + return thisElement; + } + + return SVGGradientFrame::GetRadialGradientWithLength(aIndex, aDefault); +} + +bool SVGRadialGradientFrame::GradientVectorLengthIsZero() { + return GetLengthValue(dom::SVGRadialGradientElement::ATTR_R) == 0; +} + +already_AddRefed<gfxPattern> SVGRadialGradientFrame::CreateGradient() { + float cx, cy, r, fx, fy, fr; + + cx = GetLengthValue(dom::SVGRadialGradientElement::ATTR_CX); + cy = GetLengthValue(dom::SVGRadialGradientElement::ATTR_CY); + r = GetLengthValue(dom::SVGRadialGradientElement::ATTR_R); + // If fx or fy are not set, use cx/cy instead + fx = GetLengthValue(dom::SVGRadialGradientElement::ATTR_FX, cx); + fy = GetLengthValue(dom::SVGRadialGradientElement::ATTR_FY, cy); + fr = GetLengthValue(dom::SVGRadialGradientElement::ATTR_FR); + + RefPtr<gfxPattern> pattern = new gfxPattern(fx, fy, fr, cx, cy, r); + return pattern.forget(); +} + +} // namespace mozilla + +// ------------------------------------------------------------------------- +// Public functions +// ------------------------------------------------------------------------- + +nsIFrame* NS_NewSVGLinearGradientFrame(mozilla::PresShell* aPresShell, + mozilla::ComputedStyle* aStyle) { + return new (aPresShell) + mozilla::SVGLinearGradientFrame(aStyle, aPresShell->GetPresContext()); +} + +nsIFrame* NS_NewSVGRadialGradientFrame(mozilla::PresShell* aPresShell, + mozilla::ComputedStyle* aStyle) { + return new (aPresShell) + mozilla::SVGRadialGradientFrame(aStyle, aPresShell->GetPresContext()); +} + +namespace mozilla { + +NS_IMPL_FRAMEARENA_HELPERS(SVGLinearGradientFrame) +NS_IMPL_FRAMEARENA_HELPERS(SVGRadialGradientFrame) + +} // namespace mozilla |