ChangeLog

2011-11-10  Nikolas Zimmermann  <nzimmermann@rim.com>

        Move unit resolving for all resources to rendering/

        https://bugs.webkit.org/show_bug.cgi?id=72011

        Reviewed by NOBODY (OOPS!).

        Remove maskBoundingBox()/filterBoundingBox(), to avoid doing length resolution in svg/.

        RenderSVGResource* now uses SVGLengthContext::resolveRectangle, to do this while laying out.

        Move linear gradient start/end point, radial gradient focal/center point, radius calculations into

        their RenderSVGResource classes, cleanup code a bit.

        Convert filters to use SVGLengthContext. Fix DRT dumps for filters, while I'm at it, to give

        meaningful values, when objectBoundingBox is used as primitive units, when applying to <text>/<tspan>s.

        Several tests results need rebaselines on all platforms.

        * platform/graphics/filters/Filter.h:

        * rendering/svg/RenderSVGInlineText.h:

        (WebCore::RenderSVGInlineText::objectBoundingBox):

        * rendering/svg/RenderSVGResourceFilter.cpp:

        (WebCore::RenderSVGResourceFilter::buildPrimitives):

        (WebCore::RenderSVGResourceFilter::applyResource):

        (WebCore::RenderSVGResourceFilter::resourceBoundingBox):

        * rendering/svg/RenderSVGResourceFilter.h:

        * rendering/svg/RenderSVGResourceFilterPrimitive.cpp:

        (WebCore::RenderSVGResourceFilterPrimitive::determineFilterPrimitiveSubregion):

        * rendering/svg/RenderSVGResourceGradient.cpp:

        (WebCore::RenderSVGResourceGradient::applyResource):

        * rendering/svg/RenderSVGResourceGradient.h:

        * rendering/svg/RenderSVGResourceLinearGradient.cpp:

        (WebCore::RenderSVGResourceLinearGradient::startPoint):

        (WebCore::RenderSVGResourceLinearGradient::endPoint):

        (WebCore::RenderSVGResourceLinearGradient::buildGradient):

        * rendering/svg/RenderSVGResourceLinearGradient.h:

        * rendering/svg/RenderSVGResourceMasker.cpp:

        (WebCore::RenderSVGResourceMasker::resourceBoundingBox):

        * rendering/svg/RenderSVGResourceRadialGradient.cpp:

        (WebCore::RenderSVGResourceRadialGradient::centerPoint):

        (WebCore::RenderSVGResourceRadialGradient::focalPoint):

        (WebCore::RenderSVGResourceRadialGradient::radius):

        (WebCore::RenderSVGResourceRadialGradient::adjustFocalPointIfNeeded):

        (WebCore::RenderSVGResourceRadialGradient::buildGradient):

        * rendering/svg/RenderSVGResourceRadialGradient.h:

        * rendering/svg/SVGRenderTreeAsText.cpp:

        (WebCore::writeSVGResourceContainer):

        * svg/SVGFilterElement.cpp:

        * svg/SVGFilterElement.h:

        * svg/SVGFilterPrimitiveStandardAttributes.cpp:

        (WebCore::SVGFilterPrimitiveStandardAttributes::setStandardAttributes):

        * svg/SVGFilterPrimitiveStandardAttributes.h:

        * svg/SVGLinearGradientElement.cpp:

        * svg/SVGLinearGradientElement.h:

        * svg/SVGMaskElement.cpp:

        * svg/SVGMaskElement.h:

        * svg/SVGRadialGradientElement.cpp:

        * svg/SVGRadialGradientElement.h:

        * svg/graphics/filters/SVGFilter.h:

        (WebCore::SVGFilter::filterRegionInUserSpace):

2011-11-10  Pavel Feldman  <pfeldman@google.com>

        Web Inspector: do not highlight files larger than 10KLOC.

99847

Source/WebCore/platform/graphics/filters/Filter.h

#include "FloatRect.h"

#include "FloatSize.h"

#include "ImageBuffer.h"

27

28 #include <wtf/PassRefPtr.h>

2927#include <wtf/RefCounted.h>

30 #include <wtf/RefPtr.h>

31 #include <wtf/text/StringHash.h>

namespace WebCore {

35 class FilterEffect;

31class FilterEffect;

3632

    class Filter : public RefCounted<Filter> {

    public:

        virtual ~Filter() { }

        void setSourceImage(PassOwnPtr<ImageBuffer> sourceImage) { m_sourceImage = sourceImage; }

        ImageBuffer* sourceImage() { return m_sourceImage.get(); }

        FloatSize filterResolution() const { return m_filterResolution; }

        void setFilterResolution(const FloatSize& filterResolution) { m_filterResolution = filterResolution; }

        virtual float applyHorizontalScale(float value) const { return value * m_filterResolution.width(); }

        virtual float applyVerticalScale(float value) const { return value * m_filterResolution.height(); }

        virtual FloatRect sourceImageRect() const = 0;

        virtual FloatRect filterRegion() const = 0;

        virtual FloatPoint mapAbsolutePointToLocalPoint(const FloatPoint&) const { return FloatPoint(); }

        virtual FloatRect filterRegionInUserSpace() const { return FloatRect(); }

        virtual bool effectBoundingBoxMode() const = 0;

    private:

        OwnPtr<ImageBuffer> m_sourceImage;

        FloatSize m_filterResolution;

    };

class Filter : public RefCounted<Filter> {

public:

    virtual ~Filter() { }

    void setSourceImage(PassOwnPtr<ImageBuffer> sourceImage) { m_sourceImage = sourceImage; }

    ImageBuffer* sourceImage() { return m_sourceImage.get(); }

    FloatSize filterResolution() const { return m_filterResolution; }

    void setFilterResolution(const FloatSize& filterResolution) { m_filterResolution = filterResolution; }

    virtual float applyHorizontalScale(float value) const { return value * m_filterResolution.width(); }

    virtual float applyVerticalScale(float value) const { return value * m_filterResolution.height(); }

    virtual FloatRect sourceImageRect() const = 0;

    virtual FloatRect filterRegion() const = 0;

    virtual FloatPoint mapAbsolutePointToLocalPoint(const FloatPoint&) const { return FloatPoint(); }

private:

    OwnPtr<ImageBuffer> m_sourceImage;

    FloatSize m_filterResolution;

};

} // namespace WebCore

99838

Source/WebCore/rendering/svg/RenderSVGInlineText.h

@@private:

    virtual void setStyle(PassRefPtr<RenderStyle>);

    virtual void styleDidChange(StyleDifference, const RenderStyle*);

    // FIXME: We need objectBoundingBox for DRT results and filters at the moment.

    // This should be fixed to give back the objectBoundingBox of the text root.

    virtual FloatRect objectBoundingBox() const { return FloatRect(); }

56 virtual FloatRect objectBoundingBox() const { return linesBoundingBox(); }

    virtual bool requiresLayer() const { return false; }

    virtual bool isSVGInlineText() const { return true; }

99838

Source/WebCore/rendering/svg/RenderSVGResourceFilter.cpp

@@void RenderSVGResourceFilter::removeClie

    markClientForInvalidation(client, markForInvalidation ? BoundariesInvalidation : ParentOnlyInvalidation);

}

96 PassRefPtr<SVGFilterBuilder> RenderSVGResourceFilter::buildPrimitives(Filter* filter)

96PassRefPtr<SVGFilterBuilder> RenderSVGResourceFilter::buildPrimitives(SVGFilter* filter)

9797{

9898 SVGFilterElement* filterElement = static_cast<SVGFilterElement*>(node());

99 b~~ool~~ p~~rimitive~~BoundingBox~~Mode~~ = filter~~Element->p~~r~~imitiveUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX~~;

99 FloatRect targetBoundingBox = filter->targetBoundingBox();

    // Add effects to the builder

    RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(filter);

@@PassRefPtr<SVGFilterBuilder> RenderSVGRe

            return 0;

        }

        builder->appendEffectToEffectReferences(effect, effectElement->renderer());

118 effectElement->setStandardAttributes(primitiveBoundingBoxMode, effect.get());

118 effectElement->setStandardAttributes(effect.get());

119 effect->setEffectBoundaries(SVGLengthContext::resolveRectangle<SVGFilterPrimitiveStandardAttributes>(effectElement, filterElement->primitiveUnits(), targetBoundingBox));

        builder->add(effectElement->result(), effect);

    }

    return builder.release();

@@bool RenderSVGResourceFilter::applyResou

    FloatRect targetBoundingBox = object->objectBoundingBox();

    SVGFilterElement* filterElement = static_cast<SVGFilterElement*>(node());

163 filterData->boundaries = filterElement->filter~~Bou~~nd~~ingBox~~(targetBoundingBox);

164 filterData->boundaries = SVGLengthContext::resolveRectangle<SVGFilterElement>(filterElement, filterElement->filterUnits(), targetBoundingBox);

    if (filterData->boundaries.isEmpty())

        return false;

@@bool RenderSVGResourceFilter::applyResou

    filterData->filter = SVGFilter::create(filterData->shearFreeAbsoluteTransform, absoluteDrawingRegion, targetBoundingBox, filterData->boundaries, primitiveBoundingBoxMode);

    // Create all relevant filter primitives.

187 filterData->builder = buildPrimitives(filterData->filter.get());

188 filterData->builder = buildPrimitives(static_cast<SVGFilter*>(filterData->filter.get()));

    if (!filterData->builder)

        return false;

@@void RenderSVGResourceFilter::postApplyR

FloatRect RenderSVGResourceFilter::resourceBoundingBox(RenderObject* object)

{

    if (SVGFilterElement* element = static_cast<SVGFilterElement*>(node()))

333 return element->filter~~Bou~~nd~~ingBox~~(object->objectBoundingBox());

334 return SVGLengthContext::resolveRectangle<SVGFilterElement>(element, element->filterUnits(), object->objectBoundingBox());

    return FloatRect();

}

99838

Source/WebCore/rendering/svg/RenderSVGResourceFilter.h

@@public:

    virtual FloatRect resourceBoundingBox(RenderObject*);

79 PassRefPtr<SVGFilterBuilder> buildPrimitives(Filter*);

79 PassRefPtr<SVGFilterBuilder> buildPrimitives(SVGFilter*);

    SVGUnitTypes::SVGUnitType filterUnits() const { return static_cast<SVGFilterElement*>(node())->filterUnits(); }

    SVGUnitTypes::SVGUnitType primitiveUnits() const { return static_cast<SVGFilterElement*>(node())->primitiveUnits(); }

99838

Source/WebCore/rendering/svg/RenderSVGResourceFilterPrimitive.cpp

@@void RenderSVGResourceFilterPrimitive::s

FloatRect RenderSVGResourceFilterPrimitive::determineFilterPrimitiveSubregion(FilterEffect* effect)

{

    FloatRect uniteRect;

68 FloatRect subregionBoundingBox = effect->effectBoundaries();

69 FloatRect subregion = subregionBoundingBox;

68 FloatRect subregion = effect->effectBoundaries();

    SVGFilter* filter = static_cast<SVGFilter*>(effect->filter());

    ASSERT(filter);

@@FloatRect RenderSVGResourceFilterPrimiti

        uniteRect = filter->filterRegionInUserSpace();

    }

    if (filter->effectBoundingBoxMode()) {

        subregion = uniteRect;

        // Avoid the calling of a virtual method several times.

        FloatRect targetBoundingBox = filter->targetBoundingBox();

        if (effect->hasX())

            subregion.setX(targetBoundingBox.x() + subregionBoundingBox.x() * targetBoundingBox.width());

        if (effect->hasY())

            subregion.setY(targetBoundingBox.y() + subregionBoundingBox.y() * targetBoundingBox.height());

        if (effect->hasWidth())

            subregion.setWidth(subregionBoundingBox.width() * targetBoundingBox.width());

        if (effect->hasHeight())

            subregion.setHeight(subregionBoundingBox.height() * targetBoundingBox.height());

    } else {

        if (!effect->hasX())

            subregion.setX(uniteRect.x());

        if (!effect->hasY())

            subregion.setY(uniteRect.y());

        if (!effect->hasWidth())

            subregion.setWidth(uniteRect.width());

        if (!effect->hasHeight())

            subregion.setHeight(uniteRect.height());

    }

    if (!effect->hasX())

        subregion.setX(uniteRect.x());

    if (!effect->hasY())

        subregion.setY(uniteRect.y());

    if (!effect->hasWidth())

        subregion.setWidth(uniteRect.width());

    if (!effect->hasHeight())

        subregion.setHeight(uniteRect.height());

    effect->setFilterPrimitiveSubregion(subregion);

    FloatRect absoluteSubregion = filter->mapLocalRectToAbsoluteRect(subregion);

99838

Source/WebCore/rendering/svg/RenderSVGResourceGradient.cpp

@@bool RenderSVGResourceGradient::applyRes

    // Create gradient object

    if (!gradientData->gradient) {

178 buildGradient(gradientData~~, gradientElement~~);

178 buildGradient(gradientData);

        // CG platforms will handle the gradient space transform for text after applying the

        // resource, so don't apply it here. For non-CG platforms, we want the text bounding

99838

Source/WebCore/rendering/svg/RenderSVGResourceGradient.h

@@protected:

    virtual SVGUnitTypes::SVGUnitType gradientUnits() const = 0;

    virtual void calculateGradientTransform(AffineTransform&) = 0;

    virtual bool collectGradientAttributes(SVGGradientElement*) = 0;

62 virtual void buildGradient(GradientData*, SVGGradientElement*) const = 0;

62 virtual void buildGradient(GradientData*) const = 0;

    GradientSpreadMethod platformSpreadMethodFromSVGType(SVGSpreadMethodType) const;

99838

Source/WebCore/rendering/svg/RenderSVGResourceLinearGradient.cpp

@@bool RenderSVGResourceLinearGradient::co

    return static_cast<SVGLinearGradientElement*>(gradientElement)->collectGradientAttributes(m_attributes);

}

48 v~~oid~~ RenderSVGResourceLinearGradient::bu~~ild~~Gradient(G~~rad~~i~~entData* grad~~i~~entData, SVGGradientElement* gradientElement~~) const

48FloatPoint RenderSVGResourceLinearGradient::startPoint(const LinearGradientAttributes& attributes) const

4949{

50 SVGLinearGradientElement* linearGradientElement = static_cast<SVGLinearGradientElement*>(gradientElement);

50 return SVGLengthContext::resolvePoint(static_cast<const SVGElement*>(node()), attributes.gradientUnits(), attributes.x1(), attributes.y1());

51}

5152

    // Determine gradient start/end points

    FloatPoint startPoint;

    FloatPoint endPoint;

    linearGradientElement->calculateStartEndPoints(m_attributes, startPoint, endPoint);

FloatPoint RenderSVGResourceLinearGradient::endPoint(const LinearGradientAttributes& attributes) const

{

    return SVGLengthContext::resolvePoint(static_cast<const SVGElement*>(node()), attributes.gradientUnits(), attributes.x2(), attributes.y2());

}

5657

57 gradientData->gradient = Gradient::create(startPoint, endPoint);

void RenderSVGResourceLinearGradient::buildGradient(GradientData* gradientData) const

{

    gradientData->gradient = Gradient::create(startPoint(m_attributes), endPoint(m_attributes));

5861 gradientData->gradient->setSpreadMethod(platformSpreadMethodFromSVGType(m_attributes.spreadMethod()));

59

60 // Add stops

    addStops(gradientData, m_attributes.stops());

}

99838

Source/WebCore/rendering/svg/RenderSVGResourceLinearGradient.h

@@public:

    virtual SVGUnitTypes::SVGUnitType gradientUnits() const { return m_attributes.gradientUnits(); }

    virtual void calculateGradientTransform(AffineTransform& transform) { transform = m_attributes.gradientTransform(); }

    virtual bool collectGradientAttributes(SVGGradientElement*);

45 virtual void buildGradient(GradientData*, SVGGradientElement*) const;

    virtual void buildGradient(GradientData*) const;

    FloatPoint startPoint(const LinearGradientAttributes&) const;

    FloatPoint endPoint(const LinearGradientAttributes&) const;

private:

    LinearGradientAttributes m_attributes;

99838

Source/WebCore/rendering/svg/RenderSVGResourceMasker.cpp

@@FloatRect RenderSVGResourceMasker::resou

    ASSERT(maskElement);

    FloatRect objectBoundingBox = object->objectBoundingBox();

190 FloatRect maskBoundaries = maskElement->mask~~Bou~~nd~~ingBox~~(objectBoundingBox);

190 FloatRect maskBoundaries = SVGLengthContext::resolveRectangle<SVGMaskElement>(maskElement, maskElement->maskUnits(), objectBoundingBox);

    // Resource was not layouted yet. Give back clipping rect of the mask.

    if (selfNeedsLayout())

99838

Source/WebCore/rendering/svg/RenderSVGResourceRadialGradient.cpp

@@bool RenderSVGResourceRadialGradient::co

    return static_cast<SVGRadialGradientElement*>(gradientElement)->collectGradientAttributes(m_attributes);

}

48 v~~oid~~ RenderSVGResourceRadialGradient::buildGradient(G~~rad~~i~~entData* grad~~i~~entData, SVGGradientElement* gradientElement~~) const

48FloatPoint RenderSVGResourceRadialGradient::centerPoint(const RadialGradientAttributes& attributes) const

4949{

50 SVGRadialGradientElement* radialGradientElement = static_cast<SVGRadialGradientElement*>(gradientElement);

    return SVGLengthContext::resolvePoint(static_cast<const SVGElement*>(node()), attributes.gradientUnits(), attributes.cx(), attributes.cy());

}

FloatPoint RenderSVGResourceRadialGradient::focalPoint(const RadialGradientAttributes& attributes) const

{

    return SVGLengthContext::resolvePoint(static_cast<const SVGElement*>(node()), attributes.gradientUnits(), attributes.fx(), attributes.fy());

}

5157

float RenderSVGResourceRadialGradient::radius(const RadialGradientAttributes& attributes) const

{

    return SVGLengthContext::resolveLength(static_cast<const SVGElement*>(node()), attributes.gradientUnits(), attributes.r());

}

void RenderSVGResourceRadialGradient::adjustFocalPointIfNeeded(float radius, const FloatPoint& centerPoint, FloatPoint& focalPoint) const

{

    // Eventually adjust focal points, as described below

    float deltaX = focalPoint.x() - centerPoint.x();

    float deltaY = focalPoint.y() - centerPoint.y();

    float radiusMax = 0.99f * radius;

    // Spec: If (fx, fy) lies outside the circle defined by (cx, cy) and r, set

    // (fx, fy) to the point of intersection of the line through (fx, fy) and the circle.

    // We scale the radius by 0.99 to match the behavior of FireFox.

    if (sqrt(deltaX * deltaX + deltaY * deltaY) <= radiusMax)

        return;

    float angle = atan2f(deltaY, deltaX);

    deltaX = cosf(angle) * radiusMax;

    deltaY = sinf(angle) * radiusMax;

    focalPoint = FloatPoint(deltaX + centerPoint.x(), deltaY + centerPoint.y());

}

void RenderSVGResourceRadialGradient::buildGradient(GradientData* gradientData) const

{

5284 // Determine gradient focal/center points and radius

    FloatPoint focalPoint;

    FloatPoint centerPoint;

    float radius;

    radialGradientElement->calculateFocalCenterPointsAndRadius(m_attributes, focalPoint, centerPoint, radius);

    float radius = this->radius(m_attributes);

    FloatPoint centerPoint = this->centerPoint(m_attributes);

    FloatPoint focalPoint = this->focalPoint(m_attributes);

    adjustFocalPointIfNeeded(radius, centerPoint, focalPoint);

    gradientData->gradient = Gradient::create(focalPoint,

                                              0, // SVG does not support a "focus radius"

@@void RenderSVGResourceRadialGradient::bu

    gradientData->gradient->setSpreadMethod(platformSpreadMethodFromSVGType(m_attributes.spreadMethod()));

65 // Add stops

    addStops(gradientData, m_attributes.stops());

}

99838

Source/WebCore/rendering/svg/RenderSVGResourceRadialGradient.h

@@public:

    virtual SVGUnitTypes::SVGUnitType gradientUnits() const { return m_attributes.gradientUnits(); }

    virtual void calculateGradientTransform(AffineTransform& transform) { transform = m_attributes.gradientTransform(); }

    virtual bool collectGradientAttributes(SVGGradientElement*);

45 virtual void buildGradient(GradientData*, SVGGradientElement*) const;

    virtual void buildGradient(GradientData*) const;

    FloatPoint centerPoint(const RadialGradientAttributes&) const;

    FloatPoint focalPoint(const RadialGradientAttributes&) const;

    float radius(const RadialGradientAttributes&) const;

    void adjustFocalPointIfNeeded(float radius, const FloatPoint& centerPoint, FloatPoint&) const;

private:

    RadialGradientAttributes m_attributes;

99838

Source/WebCore/rendering/svg/SVGRenderTreeAsText.cpp

@@void writeSVGResourceContainer(TextStrea

        linearGradientElement->collectGradientAttributes(attributes);

        writeCommonGradientProperties(ts, attributes.spreadMethod(), attributes.gradientTransform(), attributes.gradientUnits());

        FloatPoint startPoint;

        FloatPoint endPoint;

        linearGradientElement->calculateStartEndPoints(attributes, startPoint, endPoint);

        ts << " [start=" << startPoint << "] [end=" << endPoint << "]\n";

578 ts << " [start=" << gradient->startPoint(attributes) << "] [end=" << gradient->endPoint(attributes) << "]\n";

    }  else if (resource->resourceType() == RadialGradientResourceType) {

        RenderSVGResourceRadialGradient* gradient = static_cast<RenderSVGResourceRadialGradient*>(resource);

@@void writeSVGResourceContainer(TextStrea

        radialGradientElement->collectGradientAttributes(attributes);

        writeCommonGradientProperties(ts, attributes.spreadMethod(), attributes.gradientTransform(), attributes.gradientUnits());

        FloatPoint focalPoint;

        FloatPoint centerPoint;

        float radius;

        radialGradientElement->calculateFocalCenterPointsAndRadius(attributes, focalPoint, centerPoint, radius);

        FloatPoint focalPoint = gradient->focalPoint(attributes);

        FloatPoint centerPoint = gradient->centerPoint(attributes);

        float radius = gradient->radius(attributes);

        gradient->adjustFocalPointIfNeeded(radius, centerPoint, focalPoint);;

        ts << " [center=" << centerPoint << "] [focal=" << focalPoint << "] [radius=" << radius << "]\n";

    } else

99838

Source/WebCore/svg/SVGFilterElement.cpp

@@void SVGFilterElement::childrenChanged(b

        object->setNeedsLayout(true);

}

FloatRect SVGFilterElement::filterBoundingBox(const FloatRect& objectBoundingBox) const

{

    // FIXME: A follow-up patch will make filters use SVGLengthContext::resolveRectangle.

    FloatRect filterBBox;

    if (filterUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)

        filterBBox = FloatRect(x().valueAsPercentage() * objectBoundingBox.width() + objectBoundingBox.x(),

                               y().valueAsPercentage() * objectBoundingBox.height() + objectBoundingBox.y(),

                               width().valueAsPercentage() * objectBoundingBox.width(),

                               height().valueAsPercentage() * objectBoundingBox.height());

    else

        filterBBox = FloatRect(x().value(this),

                               y().value(this),

                               width().value(this),

                               height().value(this));

    return filterBBox;

}

RenderObject* SVGFilterElement::createRenderer(RenderArena* arena, RenderStyle*)

{

    return new (arena) RenderSVGResourceFilter(this);

99838

Source/WebCore/svg/SVGFilterElement.h

@@public:

    static PassRefPtr<SVGFilterElement> create(const QualifiedName&, Document*);

    void setFilterRes(unsigned long filterResX, unsigned long filterResY);

47 FloatRect filterBoundingBox(const FloatRect&) const;

private:

    SVGFilterElement(const QualifiedName&, Document*);

99838

Source/WebCore/svg/SVGFilterPrimitiveStandardAttributes.cpp

@@void SVGFilterPrimitiveStandardAttribute

        invalidate();

}

129 void SVGFilterPrimitiveStandardAttributes::setStandardAttributes(~~bool primitiveBoundingBoxMode,~~ FilterEffect* filterEffect) const

129void SVGFilterPrimitiveStandardAttributes::setStandardAttributes(FilterEffect* filterEffect) const

{

    ASSERT(filterEffect);

    if (!filterEffect)

        return;

135 if (~~this->~~hasAttribute(SVGNames::xAttr))

135 if (hasAttribute(SVGNames::xAttr))

136136 filterEffect->setHasX(true);

137 if (~~this->~~hasAttribute(SVGNames::yAttr))

137 if (hasAttribute(SVGNames::yAttr))

138138 filterEffect->setHasY(true);

139 if (~~this->~~hasAttribute(SVGNames::widthAttr))

139 if (hasAttribute(SVGNames::widthAttr))

140140 filterEffect->setHasWidth(true);

141 if (~~this->~~hasAttribute(SVGNames::heightAttr))

141 if (hasAttribute(SVGNames::heightAttr))

142142 filterEffect->setHasHeight(true);

    FloatRect effectBBox;

    if (primitiveBoundingBoxMode)

        effectBBox = FloatRect(x().valueAsPercentage(),

                               y().valueAsPercentage(),

                               width().valueAsPercentage(),

                               height().valueAsPercentage());

    else

        effectBBox = FloatRect(x().value(this),

                               y().value(this),

                               width().value(this),

                               height().value(this));

    filterEffect->setEffectBoundaries(effectBBox);

}

RenderObject* SVGFilterPrimitiveStandardAttributes::createRenderer(RenderArena* arena, RenderStyle*)

99838

Source/WebCore/svg/SVGFilterPrimitiveStandardAttributes.h

@@class SVGFilterBuilder;

class SVGFilterPrimitiveStandardAttributes : public SVGStyledElement {

public:

42 void setStandardAttributes(~~bool,~~ FilterEffect*) const;

42 void setStandardAttributes(FilterEffect*) const;

    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter* filter) = 0;

    // Returns true, if the new value is different from the old one.

99838

Source/WebCore/svg/SVGLinearGradientElement.cpp

@@bool SVGLinearGradientElement::collectGr

    return true;

}

void SVGLinearGradientElement::calculateStartEndPoints(const LinearGradientAttributes& attributes, FloatPoint& startPoint, FloatPoint& endPoint)

{

    startPoint = SVGLengthContext::resolvePoint(this, attributes.gradientUnits(), attributes.x1(), attributes.y1());

    endPoint = SVGLengthContext::resolvePoint(this, attributes.gradientUnits(), attributes.x2(), attributes.y2());

}

bool SVGLinearGradientElement::selfHasRelativeLengths() const

{

    return x1().isRelative()

99838

Source/WebCore/svg/SVGLinearGradientElement.h

@@public:

    static PassRefPtr<SVGLinearGradientElement> create(const QualifiedName&, Document*);

    bool collectGradientAttributes(LinearGradientAttributes&);

37 void calculateStartEndPoints(const LinearGradientAttributes&, FloatPoint& startPoint, FloatPoint& endPoint);

private:

    SVGLinearGradientElement(const QualifiedName&, Document*);

99838

Source/WebCore/svg/SVGMaskElement.cpp

@@void SVGMaskElement::childrenChanged(boo

        object->setNeedsLayout(true);

}

FloatRect SVGMaskElement::maskBoundingBox(const FloatRect& objectBoundingBox) const

{

    return SVGLengthContext::resolveRectangle<SVGMaskElement>(this, maskUnits(), objectBoundingBox);

}

RenderObject* SVGMaskElement::createRenderer(RenderArena* arena, RenderStyle*)

{

    return new (arena) RenderSVGResourceMasker(this);

99838

Source/WebCore/svg/SVGMaskElement.h

@@class SVGMaskElement : public SVGStyledL

public:

    static PassRefPtr<SVGMaskElement> create(const QualifiedName&, Document*);

42 FloatRect maskBoundingBox(const FloatRect&) const;

43

private:

    SVGMaskElement(const QualifiedName&, Document*);

99838

Source/WebCore/svg/SVGRadialGradientElement.cpp

@@bool SVGRadialGradientElement::collectGr

    return true;

}

void SVGRadialGradientElement::calculateFocalCenterPointsAndRadius(const RadialGradientAttributes& attributes, FloatPoint& focalPoint, FloatPoint& centerPoint, float& radius)

{

    // Determine gradient focal/center points and radius

    focalPoint = SVGLengthContext::resolvePoint(this, attributes.gradientUnits(), attributes.fx(), attributes.fy());

    centerPoint = SVGLengthContext::resolvePoint(this, attributes.gradientUnits(), attributes.cx(), attributes.cy());

    radius = SVGLengthContext::resolveLength(this, attributes.gradientUnits(), attributes.r());

    // Eventually adjust focal points, as described below

    float deltaX = focalPoint.x() - centerPoint.x();

    float deltaY = focalPoint.y() - centerPoint.y();

    float radiusMax = 0.99f * radius;

    // Spec: If (fx, fy) lies outside the circle defined by (cx, cy) and r, set

    // (fx, fy) to the point of intersection of the line through (fx, fy) and the circle.

    // We scale the radius by 0.99 to match the behavior of FireFox.

    if (sqrt(deltaX * deltaX + deltaY * deltaY) > radiusMax) {

        float angle = atan2f(deltaY, deltaX);

        deltaX = cosf(angle) * radiusMax;

        deltaY = sinf(angle) * radiusMax;

        focalPoint = FloatPoint(deltaX + centerPoint.x(), deltaY + centerPoint.y());

    }

}

bool SVGRadialGradientElement::selfHasRelativeLengths() const

{

    return cx().isRelative()

99838

Source/WebCore/svg/SVGRadialGradientElement.h

@@public:

    static PassRefPtr<SVGRadialGradientElement> create(const QualifiedName&, Document*);

    bool collectGradientAttributes(RadialGradientAttributes&);

37 void calculateFocalCenterPointsAndRadius(const RadialGradientAttributes&, FloatPoint& focalPoint, FloatPoint& centerPoint, float& radius);

private:

    SVGRadialGradientElement(const QualifiedName&, Document*);

99838

Source/WebCore/svg/graphics/filters/SVGFilter.h

@@class SVGFilter : public Filter {

public:

    static PassRefPtr<SVGFilter> create(const AffineTransform&, const FloatRect&, const FloatRect&, const FloatRect&, bool);

    virtual bool effectBoundingBoxMode() const { return m_effectBBoxMode; }

    virtual FloatRect filterRegionInUserSpace() const { return m_filterRegion; }

40 FloatRect filterRegionInUserSpace() const { return m_filterRegion; }

    virtual FloatRect filterRegion() const { return m_absoluteFilterRegion; }

    virtual FloatPoint mapAbsolutePointToLocalPoint(const FloatPoint& point) const { return m_absoluteTransform.inverse().mapPoint(point); }

99838

LayoutTests/ChangeLog

2011-11-10  Nikolas Zimmermann  <nzimmermann@rim.com>

        Move unit resolving for all resources to rendering/

        https://bugs.webkit.org/show_bug.cgi?id=72011

        Reviewed by NOBODY (OOPS!).

        Update expected results for some filters tests, now that their bounding box is correctly dumped.

        * platform/mac/svg/batik/text/textEffect-expected.txt:

        * platform/mac/svg/batik/text/textEffect3-expected.txt:

        * platform/mac/svg/custom/text-filter-expected.txt:

        * platform/mac/svg/filters/feColorMatrix-values-expected.txt:

        * platform/mac/svg/filters/feMerge-wrong-input-expected.txt:

        * platform/mac/svg/filters/filter-on-filter-for-text-expected.txt:

        * platform/mac/svg/filters/filter-on-tspan-expected.txt:

2011-11-10  Csaba Osztrogonác  <ossy@webkit.org>

        [Qt] Unreviewed trivial fix after r99721.

99847

LayoutTests/platform/mac/svg/batik/text/textEffect3-expected.txt

@@layer at (0,0) size 450x500

      RenderSVGText {text} at (54,292) size 146x80 contains 1 chunk(s)

        [filter="dropShadow"] RenderSVGResourceFilter {filter} at (39.40,284) size 175.20x96

        RenderSVGInlineText {#text} at (0,20) size 36x60

87 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (0,0) size ~~0x0~~

87 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (50.40,306) size 43.20x72

          chunk 1 (middle anchor) text run 1 at (54.50,360.00) startOffset 0 endOffset 1 width 35.00: "B"

        RenderSVGTSpan {tspan} at (0,0) size 19x31

          RenderSVGInlineText {#text} at (35,23) size 19x31

            chunk 1 (middle anchor) text run 1 at (89.50,340.00) startOffset 0 endOffset 1 width 18.00: "A"

        RenderSVGInlineText {#text} at (53,0) size 33x60

93 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (~~0,0~~) size ~~0x0~~

93 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (103.70,286) size 39.60x72

          chunk 1 (middle anchor) text run 1 at (107.50,340.00) startOffset 0 endOffset 1 width 32.00: "T"

        RenderSVGTSpan {tspan} at (0,0) size 12x46

          RenderSVGInlineText {#text} at (85,11) size 12x46

@@layer at (0,0) size 450x500

          RenderSVGInlineText {#text} at (92,2) size 54x69

            chunk 1 (middle anchor) text run 1 at (150.50,340.00) startOffset 0 endOffset 1 width 35.00: "K"

        RenderSVGInlineText {#text} at (0,0) size 0x0

102 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

102 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (-45,-50) size 540x600

      RenderSVGText {text} at (263,292) size 148x80 contains 1 chunk(s)

        [filter="dropShadow"] RenderSVGResourceFilter {filter} at (248.20,284) size 177.60x96

        RenderSVGInlineText {#text} at (0,20) size 37x60

106 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (0,0) size ~~0x0~~

106 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (259.30,306) size 44.40x72

          chunk 1 (middle anchor) text run 1 at (263.90,360.00) startOffset 0 endOffset 1 width 35.35: "B"

        RenderSVGTSpan {tspan} at (0,0) size 19x31

          RenderSVGInlineText {#text} at (36,23) size 19x31

            chunk 1 (middle anchor) text run 1 at (299.25,340.00) startOffset 0 endOffset 1 width 18.01: "A"

        RenderSVGInlineText {#text} at (54,0) size 33x60

112 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (~~0,0~~) size ~~0x0~~

112 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (313.70,286) size 39.60x72

          chunk 1 (middle anchor) text run 1 at (317.26,340.00) startOffset 0 endOffset 1 width 32.37: "T"

        RenderSVGTSpan {tspan} at (0,0) size 12x46

          RenderSVGInlineText {#text} at (86,11) size 12x46

@@layer at (0,0) size 450x500

          RenderSVGInlineText {#text} at (93,2) size 55x69

            chunk 1 (middle anchor) text run 1 at (360.75,340.00) startOffset 0 endOffset 1 width 35.35: "K"

        RenderSVGInlineText {#text} at (0,0) size 0x0

121 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

121 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (-45,-50) size 540x600

      RenderSVGText {text} at (87,389) size 66x14 contains 1 chunk(s)

        RenderSVGInlineText {#text} at (0,0) size 66x14

          chunk 1 (middle anchor) text run 1 at (87.50,400.00) startOffset 0 endOffset 13 width 65.00: "(System font)"

99838

LayoutTests/platform/mac/svg/batik/text/textEffect-expected.txt

@@layer at (0,0) size 450x500

      RenderSVGText {text} at (44,312) size 152x60 contains 1 chunk(s)

        [filter="dropShadow"] RenderSVGResourceFilter {filter} at (28.80,306) size 182.40x72

        RenderSVGInlineText {#text} at (0,0) size 152x60

39 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (0,0) size ~~0x0~~

39 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (28.80,306) size 182.40x72

          chunk 1 (middle anchor) text run 1 at (44.00,360.00) startOffset 0 endOffset 5 width 152.00: "BATIK"

      RenderSVGText {text} at (253,312) size 154x60 contains 1 chunk(s)

        [filter="dropShadow"] RenderSVGResourceFilter {filter} at (237.60,306) size 184.80x72

        RenderSVGInlineText {#text} at (0,0) size 154x60

44 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (0,0) size ~~0x0~~

44 [filter="dropShadow"] RenderSVGResourceFilter {filter} at (237.60,306) size 184.80x72

          chunk 1 (middle anchor) text run 1 at (253.42,360.00) startOffset 0 endOffset 5 width 153.15: "BATIK"

      RenderSVGText {text} at (87,389) size 66x14 contains 1 chunk(s)

        RenderSVGInlineText {#text} at (0,0) size 66x14

99838

LayoutTests/platform/mac/svg/custom/text-filter-expected.txt

@@layer at (0,0) size 800x600

    RenderSVGText {text} at (4,10) size 567x64 contains 1 chunk(s)

      [filter="myfilter"] RenderSVGResourceFilter {filter} at (-52.70,3.60) size 680.40x76.80

      RenderSVGInlineText {#text} at (0,0) size 567x64

12 [filter="myfilter"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

12 [filter="myfilter"] RenderSVGResourceFilter {filter} at (-52.70,3.60) size 680.40x76.80

1313 chunk 1 text run 1 at (4.00,60.00) startOffset 0 endOffset 26 width 567.00: "This text should be blury."

99838

LayoutTests/platform/mac/svg/filters/feColorMatrix-values-expected.txt

@@layer at (0,0) size 800x600

      RenderSVGText {text} at (210,18) size 139x28 contains 1 chunk(s)

        [filter="matbad"] RenderSVGResourceFilter {filter} at (196.10,15.20) size 166.80x33.60

        RenderSVGInlineText {#text} at (0,0) size 139x28

66 [filter="matbad"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

66 [filter="matbad"] RenderSVGResourceFilter {filter} at (196.10,15.20) size 166.80x33.60

          chunk 1 text run 1 at (210.00,40.00) startOffset 0 endOffset 14 width 139.00: "Invalid matrix"

      RenderSVGText {text} at (210,48) size 156x28 contains 1 chunk(s)

        [filter="matbad"] RenderSVGResourceFilter {filter} at (194.40,45.20) size 187.20x33.60

        RenderSVGInlineText {#text} at (0,0) size 156x28

71 [filter="matbad"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

71 [filter="matbad"] RenderSVGResourceFilter {filter} at (194.40,45.20) size 187.20x33.60

          chunk 1 text run 1 at (210.00,70.00) startOffset 0 endOffset 17 width 156.00: "values attribute."

      RenderSVGPath {rect} at (182,92) size 236x116 [fill={[type=SOLID] [color=#FF0000]}] [x=202.00] [y=102.00] [width=196.00] [height=96.00]

        [filter="huebad"] RenderSVGResourceFilter {filter} at (182.40,92.40) size 235.20x115.20

      RenderSVGText {text} at (210,118) size 151x28 contains 1 chunk(s)

        [filter="huebad"] RenderSVGResourceFilter {filter} at (194.90,115.20) size 181.20x33.60

        RenderSVGInlineText {#text} at (0,0) size 151x28

78 [filter="huebad"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

78 [filter="huebad"] RenderSVGResourceFilter {filter} at (194.90,115.20) size 181.20x33.60

          chunk 1 text run 1 at (210.00,140.00) startOffset 0 endOffset 16 width 151.00: "Invalid saturate"

      RenderSVGText {text} at (210,148) size 156x28 contains 1 chunk(s)

        [filter="huebad"] RenderSVGResourceFilter {filter} at (194.40,145.20) size 187.20x33.60

        RenderSVGInlineText {#text} at (0,0) size 156x28

83 [filter="huebad"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

83 [filter="huebad"] RenderSVGResourceFilter {filter} at (194.40,145.20) size 187.20x33.60

          chunk 1 text run 1 at (210.00,170.00) startOffset 0 endOffset 17 width 156.00: "values attribute."

      RenderSVGPath {rect} at (182,192) size 236x116 [fill={[type=SOLID] [color=#FF0000]}] [x=202.00] [y=202.00] [width=196.00] [height=96.00]

        [filter="satbad"] RenderSVGResourceFilter {filter} at (182.40,192.40) size 235.20x115.20

      RenderSVGText {text} at (210,218) size 174x28 contains 1 chunk(s)

        [filter="satbad"] RenderSVGResourceFilter {filter} at (192.60,215.20) size 208.80x33.60

        RenderSVGInlineText {#text} at (0,0) size 174x28

90 [filter="satbad"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

90 [filter="satbad"] RenderSVGResourceFilter {filter} at (192.60,215.20) size 208.80x33.60

          chunk 1 text run 1 at (210.00,240.00) startOffset 0 endOffset 17 width 174.00: "Invalid hueRotate"

      RenderSVGText {text} at (210,248) size 156x28 contains 1 chunk(s)

        [filter="satbad"] RenderSVGResourceFilter {filter} at (194.40,245.20) size 187.20x33.60

        RenderSVGInlineText {#text} at (0,0) size 156x28

95 [filter="satbad"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

95 [filter="satbad"] RenderSVGResourceFilter {filter} at (194.40,245.20) size 187.20x33.60

          chunk 1 text run 1 at (210.00,270.00) startOffset 0 endOffset 17 width 156.00: "values attribute."

      RenderSVGPath {rect} at (182,292) size 236x116 [fill={[type=SOLID] [color=#FF0000]}] [x=202.00] [y=302.00] [width=196.00] [height=96.00]

        [filter="satrange"] RenderSVGResourceFilter {filter} at (182.40,292.40) size 235.20x115.20

      RenderSVGText {text} at (210,318) size 133x28 contains 1 chunk(s)

        [filter="satrange"] RenderSVGResourceFilter {filter} at (196.70,315.20) size 159.60x33.60

        RenderSVGInlineText {#text} at (0,0) size 133x28

102 [filter="satrange"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

102 [filter="satrange"] RenderSVGResourceFilter {filter} at (196.70,315.20) size 159.60x33.60

          chunk 1 text run 1 at (210.00,340.00) startOffset 0 endOffset 13 width 133.00: "Saturate must"

      RenderSVGText {text} at (210,348) size 152x28 contains 1 chunk(s)

        [filter="satrange"] RenderSVGResourceFilter {filter} at (194.80,345.20) size 182.40x33.60

        RenderSVGInlineText {#text} at (0,0) size 152x28

107 [filter="satrange"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

107 [filter="satrange"] RenderSVGResourceFilter {filter} at (194.80,345.20) size 182.40x33.60

108108 chunk 1 text run 1 at (210.00,370.00) startOffset 0 endOffset 15 width 152.00: "have one value."

99838

LayoutTests/platform/mac/svg/filters/feMerge-wrong-input-expected.txt

layer at (0,0) size 800x600

  RenderView at (0,0) size 800x600

layer at (0,0) size 800x600

4 RenderSVGRoot {svg} at (0,0) size 100x100

4 RenderSVGRoot {svg} at (0,0) size 800x600

55 RenderSVGHiddenContainer {defs} at (0,0) size 0x0

66 RenderSVGResourceFilter {filter} [id="filter"] [filterUnits=objectBoundingBox] [primitiveUnits=objectBoundingBox]

7 RenderSVGContainer {g} at (0,0) size 0x0

8 [filter="filter"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

7 RenderSVGContainer {g} at (0,0) size 800x600

8 [filter="filter"] RenderSVGResourceFilter {filter} at (-80,-60) size 960x720

99 RenderSVGPath {rect} at (0,0) size 100x100 [fill={[type=SOLID] [color=#008000]}] [x=0.00] [y=0.00] [width=100.00] [height=100.00]

99838

LayoutTests/platform/mac/svg/filters/filter-on-filter-for-text-expected.txt

@@layer at (0,0) size 800x600

    RenderSVGText {text} at (30,12) size 206x23 contains 1 chunk(s)

      [filter="filter"] RenderSVGResourceFilter {filter} at (9.40,9.70) size 247.20x27.60

      RenderSVGInlineText {#text} at (0,0) size 135x23

12 [filter="filter"] RenderSVGResourceFilter {filter} at (0,0) size ~~0x0~~

12 [filter="filter"] RenderSVGResourceFilter {filter} at (16.50,9.70) size 162x27.60

        chunk 1 text run 1 at (30.00,30.00) startOffset 0 endOffset 19 width 135.00: "This is for filter "

      RenderSVGTSpan {tspan} at (0,0) size 66x23

        RenderSVGInlineText {#text} at (135,0) size 66x23

16 [filter="filter"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

16 [filter="filter"] RenderSVGResourceFilter {filter} at (158.40,9.70) size 79.20x27.60

1717 chunk 1 text run 1 at (165.00,30.00) startOffset 0 endOffset 9 width 66.00: "on filter"

1818 RenderSVGInlineText {#text} at (201,0) size 5x23

19 [filter="filter"] RenderSVGResourceFilter {filter} at (0,0) size ~~0x0~~

19 [filter="filter"] RenderSVGResourceFilter {filter} at (230.50,9.70) size 6x27.60

2020 chunk 1 text run 1 at (231.00,30.00) startOffset 0 endOffset 1 width 5.00: "."

99838

LayoutTests/platform/mac/svg/filters/filter-on-tspan-expected.txt

@@layer at (0,0) size 800x600

        chunk 1 text run 1 at (100.00,100.00) startOffset 0 endOffset 12 width 68.00: "Die ist ein "

      RenderSVGTSpan {tspan} at (0,0) size 27x18

        RenderSVGInlineText {#text} at (68,0) size 27x18

13 [filter="filter"] RenderSVGResourceFilter {filter} at (0,0) size 0x0

13 [filter="filter"] RenderSVGResourceFilter {filter} at (165.30,84.20) size 32.40x21.60

          chunk 1 text run 1 at (168.00,100.00) startOffset 0 endOffset 4 width 27.00: "Test"

      RenderSVGInlineText {#text} at (95,0) size 4x18

        chunk 1 text run 1 at (195.00,100.00) startOffset 0 endOffset 1 width 4.00: "."

99838