Attachment #333961 for bug #168586

View Details Raw Unified Return to Bug 168586

| Differences between



2018-02-15  Said Abou-Hallawa  <sabouhallawa@apple.com>

        Make all the SVGElements' attributes be RefCounted objects
        https://bugs.webkit.org/show_bug.cgi?id=168586

        Reviewed by NOBODY (OOPS!).

        The SVG tear-off objects have been causing many memory which have been
        difficult to track. The SVG tear-off objects are created on demand. More
        specifically, they are created when animating the SVGElement's attribute
        or when creating a DOM object for that attribute. The problem is these
        tear-off objects hold a raw reference to the SVGElement's attribute. To
        keep this reference valid, both the SVGElement and the tear-off object
        used to hold a RefPtr to each other which was causing a memory leak. When
        this strong double referencing was relaxed by using WeakPtr or raw pointer
        from one side to the other, memory bugs started to occur. A more  subtle
        problem can happen when the tear-off object is created for an element in
        a list attribute. Even if both the SVGElement and the tear-off exist in
        memory, accessing freed memory may still happen if the list attribute was
        reallocated.

        The current state of the code can not guarantee the validity of the reference
        which is held by the tear-off object to the SVGElement's attribute. To fix
        this issue, all the SVGElement's attributes have to be RefCounted objects.

        Creating different classes for every data type of the SVG attributes does
        not look the cleanest solution. Besides, there are cases where the union
        SVGAnimatedType is used to represent all the data types. So here is the
        outline of this patch:

        -- Create the class SVGValue which is a variant of all the SVG attribute
        basic data types including the type of the elements in the SVG attribute
        lists.

        -- Change SVGAnimatedType to hold two SVGValues. The second one is optional
        and only used for animated types which requires two data types.

        -- Change all the attributes of all the SVGElement to be of type RefPtr<SVGValue>.

        -- Change all the list attributes to be of type Vector<RefPtr<SVGValue>>.

        -- Change all the tear-off objects to hold RefPtr<SVGValue> instead of
        holding a raw reference.

        * Sources.txt:
        * WebCore.xcodeproj/project.pbxproj:
        Add new files for SVGValue and SVGListVlaues. Move definitions from
        SVGMarkerElement.h to SVGMarkerTypes.h. Move definitions of SVGRectTraits.h
        to SVGPropertyTraits.h.

        * rendering/svg/SVGPathData.cpp:
        (WebCore::pathFromPolygonElement):
        (WebCore::pathFromPolylineElement):
        * rendering/svg/SVGTextLayoutAttributesBuilder.cpp:
        (WebCore::updateCharacterData):
        * svg/SVGAngle.h:
        (WebCore::SVGAngle::create): Replace the parameter SVGAngleValue& by
        RefPtr<SVGValue>.
        (WebCore::SVGAngle::SVGAngle):
        * svg/SVGAnimateMotionElement.cpp:
        (WebCore::parsePoint): Deleted. Moved to SVGParserUtilities.cpp.

        * svg/SVGAnimatedAngle.cpp:
        (WebCore::SVGAnimatedAngleAnimator::constructFromString):
        Use the SVGPropertyTraits::fromString to create the data members of the
        SVGAnimatedType.
        (WebCore::SVGAnimatedAngleAnimator::startAnimValAnimation):
        constructFromBaseValues() now returns a unique_ptr<SVGAnimatedType>.
        (WebCore::SVGAnimatedAngleAnimator::resetAnimValToBaseVal):
        Don't pass SVGAnimatedType getter to resetFromBaseValues(). The PropertyTYpe
        can be used to get the data element from the SVGAnimatedType.
        (WebCore::SVGAnimatedAngleAnimator::addAnimatedTypes):
        Cast the SVGValue elements to the required data members.
        (WebCore::SVGAnimatedAngleAnimator::calculateAnimatedValue): Ditto.

        * svg/SVGAnimatedBoolean.cpp:
        (WebCore::SVGAnimatedBooleanAnimator::constructFromString):
        (WebCore::SVGAnimatedBooleanAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedBooleanAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedBooleanAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedColor.cpp:
        (WebCore::SVGAnimatedColorAnimator::constructFromString):
        (WebCore::SVGAnimatedColorAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedColorAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedEnumeration.cpp:
        (WebCore::SVGAnimatedEnumerationAnimator::constructFromString):
        (WebCore::SVGAnimatedEnumerationAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedEnumerationAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedEnumerationAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedInteger.cpp:
        (WebCore::SVGAnimatedIntegerAnimator::constructFromString):
        (WebCore::SVGAnimatedIntegerAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedIntegerAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedIntegerAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedIntegerAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedIntegerOptionalInteger.cpp:
        (WebCore::SVGAnimatedIntegerOptionalIntegerAnimator::constructFromString):
        (WebCore::SVGAnimatedIntegerOptionalIntegerAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedIntegerOptionalIntegerAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedIntegerOptionalIntegerAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedIntegerOptionalIntegerAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedLength.cpp:
        (WebCore::SVGAnimatedLengthAnimator::constructFromString):
        (WebCore::SVGAnimatedLengthAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedLengthAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedLengthAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedLengthAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedLengthList.cpp:
        (WebCore::SVGAnimatedLengthListAnimator::constructFromString):
        (WebCore::SVGAnimatedLengthListAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedLengthListAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedLengthListAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedLengthListAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedNumber.cpp:
        (WebCore::SVGAnimatedNumberAnimator::constructFromString):
        (WebCore::SVGAnimatedNumberAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedNumberAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedNumberAnimator::addAnimatedTypes):
        (WebCore::parseNumberFromString):
        (WebCore::SVGAnimatedNumberAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedNumberList.cpp:
        (WebCore::SVGAnimatedNumberListAnimator::constructFromString):
        (WebCore::SVGAnimatedNumberListAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedNumberListAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedNumberListAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedNumberListAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedNumberOptionalNumber.cpp:
        (WebCore::SVGAnimatedNumberOptionalNumberAnimator::constructFromString):
        (WebCore::SVGAnimatedNumberOptionalNumberAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedNumberOptionalNumberAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedNumberOptionalNumberAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedNumberOptionalNumberAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedPath.cpp:
        (WebCore::SVGAnimatedPathAnimator::constructFromString):
        (WebCore::SVGAnimatedPathAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedPathAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedPathAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedPathAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedPointList.cpp:
        (WebCore::SVGAnimatedPointListAnimator::constructFromString):
        (WebCore::SVGAnimatedPointListAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedPointListAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedPointListAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedPointListAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedPreserveAspectRatio.cpp:
        (WebCore::SVGAnimatedPreserveAspectRatioAnimator::constructFromString):
        (WebCore::SVGAnimatedPreserveAspectRatioAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedPreserveAspectRatioAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedPreserveAspectRatioAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedRect.cpp:
        (WebCore::SVGAnimatedRectAnimator::constructFromString):
        (WebCore::SVGAnimatedRectAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedRectAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedRectAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedRectAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedString.cpp:
        (WebCore::SVGAnimatedStringAnimator::constructFromString):
        (WebCore::SVGAnimatedStringAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedStringAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedStringAnimator::calculateAnimatedValue):
        Ditto.

        * svg/SVGAnimatedTransformList.cpp:
        (WebCore::SVGAnimatedTransformListAnimator::constructFromString):
        (WebCore::SVGAnimatedTransformListAnimator::startAnimValAnimation):
        (WebCore::SVGAnimatedTransformListAnimator::resetAnimValToBaseVal):
        (WebCore::SVGAnimatedTransformListAnimator::addAnimatedTypes):
        (WebCore::SVGAnimatedTransformListAnimator::calculateAnimatedValue):
        (WebCore::SVGAnimatedTransformListAnimator::calculateDistance):
        Ditto.

        * svg/SVGAnimatedType.cpp: Removed.
        * svg/SVGAnimatedType.h:
        (WebCore::SVGAnimatedType::SVGAnimatedType):
        (WebCore::SVGAnimatedType::create):
        (WebCore::SVGAnimatedType::type const):
        (WebCore::SVGAnimatedType::valueAsString const):
        (WebCore::SVGAnimatedType::setValueAsString):
        (WebCore::SVGAnimatedType::supportsAnimVal):
        (WebCore::SVGAnimatedType::valueAnimatedType):
        (WebCore::SVGAnimatedType::angleAndEnumeration const): Deleted.
        (WebCore::SVGAnimatedType::boolean const): Deleted.
        (WebCore::SVGAnimatedType::color const): Deleted.
        (WebCore::SVGAnimatedType::enumeration const): Deleted.
        (WebCore::SVGAnimatedType::integer const): Deleted.
        (WebCore::SVGAnimatedType::integerOptionalInteger const): Deleted.
        (WebCore::SVGAnimatedType::length const): Deleted.
        (WebCore::SVGAnimatedType::lengthList const): Deleted.
        (WebCore::SVGAnimatedType::number const): Deleted.
        (WebCore::SVGAnimatedType::numberList const): Deleted.
        (WebCore::SVGAnimatedType::numberOptionalNumber const): Deleted.
        (WebCore::SVGAnimatedType::path const): Deleted.
        (WebCore::SVGAnimatedType::pointList const): Deleted.
        (WebCore::SVGAnimatedType::preserveAspectRatio const): Deleted.
        (WebCore::SVGAnimatedType::rect const): Deleted.
        (WebCore::SVGAnimatedType::string const): Deleted.
        (WebCore::SVGAnimatedType::transformList const): Deleted.
        (WebCore::SVGAnimatedType::angleAndEnumeration): Deleted.
        (WebCore::SVGAnimatedType::boolean): Deleted.
        (WebCore::SVGAnimatedType::color): Deleted.
        (WebCore::SVGAnimatedType::enumeration): Deleted.
        (WebCore::SVGAnimatedType::integer): Deleted.
        (WebCore::SVGAnimatedType::integerOptionalInteger): Deleted.
        (WebCore::SVGAnimatedType::length): Deleted.
        (WebCore::SVGAnimatedType::lengthList): Deleted.
        (WebCore::SVGAnimatedType::number): Deleted.
        (WebCore::SVGAnimatedType::numberList): Deleted.
        (WebCore::SVGAnimatedType::numberOptionalNumber): Deleted.
        (WebCore::SVGAnimatedType::path): Deleted.
        (WebCore::SVGAnimatedType::pointList): Deleted.
        (WebCore::SVGAnimatedType::preserveAspectRatio): Deleted.
        (WebCore::SVGAnimatedType::rect): Deleted.
        (WebCore::SVGAnimatedType::string): Deleted.
        (WebCore::SVGAnimatedType::transformList): Deleted.
        Simplify SVGAnimatedType. It is now a struct which has two RefPtr<SVGValue>.
        The second pointer can be null expect with the types with two values.

        * svg/SVGAnimatedTypeAnimator.h:
        (WebCore::SVGAnimatedTypeAnimator::constructFromBaseValue): Construct the 
        animated SVGValue from the SVGValue of the base value before starting the
        animation.
        (WebCore::SVGAnimatedTypeAnimator::resetFromBaseValue): Reset the animated
        SVGVAlue to the SVGValue of the base value before ending the animation.
        (WebCore::SVGAnimatedTypeAnimator::constructFromBaseValues): Same as 
        constructFromBaseValue() but for two-SVGAvlues animated types.
        (WebCore::SVGAnimatedTypeAnimator::resetFromBaseValues): Same as
        resetFromBaseValue() but for two-SVGAvlues animated types.
        (WebCore::SVGAnimatedTypeAnimator::executeAction):

        * svg/SVGAnimationElement.h:
        * svg/SVGComponentTransferFunctionElement.cpp:
        (WebCore::SVGComponentTransferFunctionElement::transferFunction const):
        * svg/SVGCursorElement.cpp:
        (WebCore::SVGCursorElement::SVGCursorElement): Explicitly create an
        SVGLengthValue which will implicitly force calling the constructor of
        SVGSynchronizableAnimatedProperty.

        * svg/SVGEllipseElement.cpp:
        (WebCore::SVGEllipseElement::SVGEllipseElement):
        * svg/SVGFEColorMatrixElement.cpp:
        (WebCore::SVGFEColorMatrixElement::setFilterEffectAttribute):
        (WebCore::SVGFEColorMatrixElement::build):
        * svg/SVGFEConvolveMatrixElement.cpp:
        (WebCore::SVGFEConvolveMatrixElement::build):
        * svg/SVGFilterElement.cpp:
        (WebCore::SVGFilterElement::SVGFilterElement):
        * svg/SVGFilterPrimitiveStandardAttributes.cpp:
        (WebCore::SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes):
        * svg/SVGForeignObjectElement.cpp:
        (WebCore::SVGForeignObjectElement::SVGForeignObjectElement):
        * svg/SVGImageElement.cpp:
        (WebCore::SVGImageElement::SVGImageElement):
        Ditto.

        * svg/SVGLength.h:
        (WebCore::SVGLength::create):
        (WebCore::SVGLength::SVGLength):
        * svg/SVGLengthList.h:
        (WebCore::SVGLengthList::create):
        (WebCore::SVGLengthList::SVGLengthList):
        * svg/SVGLengthListValues.cpp:
        (WebCore::SVGLengthListValues::parse):
        (WebCore::SVGLengthListValues::valueAsString const):
        * svg/SVGLengthListValues.h:
        (WebCore::SVGPropertyTraits<SVGLengthListValues>::initialValue):
        (WebCore::SVGPropertyTraits<SVGLengthListValues>::fromString):
        (WebCore::SVGPropertyTraits<SVGLengthListValues>::parse):
        (WebCore::SVGPropertyTraits<SVGLengthListValues>::toString):
        SVGLengthListValues is now a vector of RefPtr<SVGValue>. However the
        only expected value in the elements of this vector is SVGLengthValue.

        * svg/SVGLengthValue.h:
        (WebCore::SVGPropertyTraits<SVGLengthValue>::parse):
        (WebCore::SVGPropertyTraits<SVGLengthValue>::toString):
        * svg/SVGLinearGradientElement.cpp:
        (WebCore::SVGLinearGradientElement::SVGLinearGradientElement):
        * svg/SVGListValues.cpp: Added.
        (WebCore::SVGListValues<PropertyType>::resize):
        (WebCore::SVGListValues<PropertyType>::deepCopy const):

        * svg/SVGListValues.h: Added.
        (WebCore::SVGListValues::SVGListValues):
        (WebCore::SVGListValues::propertyAt const):
        (WebCore::SVGListValues::propertyAt):
        (WebCore::SVGListValues::firstProperty const):
        (WebCore::SVGListValues::firstProperty):
        (WebCore::SVGListValues::lastProperty const):
        (WebCore::SVGListValues::lastProperty):
        (WebCore::SVGListValues::properties const):
        This is the base class of all the SVG list attributes. We need to have
        the implementation of some function be in a source file to work around
        header file dependency issues. The SVG list attributes can be one of
        SVGValue data members but at the same time it is vector of RefPtr<SVGValue>.

        * svg/SVGMarkerElement.cpp:
        (WebCore::SVGMarkerElement::SVGMarkerElement):
        (WebCore::SVGMarkerElement::synchronizeOrientType):
        (WebCore::SVGMarkerElement::orientType const):
        * svg/SVGMarkerElement.h:
        (WebCore::SVGPropertyTraits<SVGMarkerUnitsType>::highestEnumValue): Deleted.
        (WebCore::SVGPropertyTraits<SVGMarkerUnitsType>::toString): Deleted.
        (WebCore::SVGPropertyTraits<SVGMarkerUnitsType>::fromString): Deleted.
        (WebCore::SVGIDLEnumLimits<SVGMarkerOrientType>::highestExposedEnumValue): Deleted.
        (WebCore::SVGPropertyTraits<SVGMarkerOrientType>::highestEnumValue): Deleted.
        (WebCore::SVGPropertyTraits<SVGMarkerOrientType>::fromString): Deleted.
        This code is moved to the new file SVGMarkerTypes.h.

        * svg/SVGMarkerTypes.h: Added.
        (WebCore::SVGPropertyTraits<SVGMarkerUnitsType>::highestEnumValue):
        (WebCore::SVGPropertyTraits<SVGMarkerUnitsType>::toString):
        (WebCore::SVGPropertyTraits<SVGMarkerUnitsType>::fromString):
        (WebCore::SVGPropertyTraits<SVGMarkerOrientType>::highestEnumValue):
        (WebCore::SVGPropertyTraits<SVGMarkerOrientType>::fromString):
        (WebCore::SVGIDLEnumLimits<SVGMarkerOrientType>::highestExposedEnumValue):
        * svg/SVGMaskElement.cpp:
        (WebCore::SVGMaskElement::SVGMaskElement):
        * svg/SVGMatrix.h:
        (WebCore::SVGMatrix::create):
        (WebCore::SVGMatrix::translate):
        (WebCore::SVGMatrix::scale):
        (WebCore::SVGMatrix::scaleNonUniform):
        (WebCore::SVGMatrix::rotate):
        (WebCore::SVGMatrix::rotateFromVector):
        (WebCore::SVGMatrix::flipX):
        (WebCore::SVGMatrix::flipY):
        (WebCore::SVGMatrix::skewX):
        (WebCore::SVGMatrix::skewY):
        (WebCore::SVGMatrix::SVGMatrix):
        * svg/SVGNumber.h:
        (WebCore::SVGNumber::create):
        (WebCore::SVGNumber::SVGNumber):
        * svg/SVGNumberList.h:
        (WebCore::SVGNumberList::create):
        (WebCore::SVGNumberList::SVGNumberList):
        * svg/SVGNumberListValues.cpp:
        (WebCore::SVGNumberListValues::parse):
        (WebCore::SVGNumberListValues::valueAsString const):
        * svg/SVGNumberListValues.h:
        (WebCore::SVGPropertyTraits<SVGNumberListValues>::fromString):
        (WebCore::SVGPropertyTraits<SVGNumberListValues>::toString):

        * svg/SVGParserUtilities.cpp:
        (WebCore::parsePoint): This function was moved from SVGAnimateMotionElement.cpp.
        (WebCore::pointsListFromSVGData):

        * svg/SVGParserUtilities.h:

        * svg/SVGPathByteStream.h:
        (WebCore::SVGPathByteStream::SVGPathByteStream):
        (WebCore::SVGPathByteStream::operator=):
        (WebCore::SVGPathByteStream::operator== const):
        (WebCore::SVGPathByteStream::operator!= const):
        (WebCore::SVGPathByteStream::copy const):
        (WebCore::SVGPathByteStream::append):
        (WebCore::SVGPathByteStream::isEmpty const):
        (WebCore::SVGPropertyTraits<SVGPathByteStream>::initialValue):
        (WebCore::SVGPropertyTraits<SVGPathByteStream>::fromString):
        Add copy constructor and assignment operator.

        * svg/SVGPathElement.cpp:
        (WebCore::SVGPathElement::SVGPathElement):
        (WebCore::SVGPathElement::svgAttributeChanged):
        (WebCore::SVGPathElement::lookupOrCreateDWrapper):
        (WebCore::SVGPathElement::synchronizeD):
        (WebCore::SVGPathElement::pathSegListChanged):

        * svg/SVGPathSegList.cpp:
        (WebCore::SVGPathSegList::clearContextAndRoles):
        (WebCore::SVGPathSegList::clear):
        (WebCore::SVGPathSegList::replaceItem):
        * svg/SVGPathSegList.h:
        Access SVGPathSegListValues through valuesProperty() instead of m_values
        which is now a RefPtr<SVGValue>.

        * svg/SVGPathSegListBuilder.cpp:
        (WebCore::SVGPathSegListBuilder::moveTo):
        (WebCore::SVGPathSegListBuilder::lineTo):
        (WebCore::SVGPathSegListBuilder::lineToHorizontal):
        (WebCore::SVGPathSegListBuilder::lineToVertical):
        (WebCore::SVGPathSegListBuilder::curveToCubic):
        (WebCore::SVGPathSegListBuilder::curveToCubicSmooth):
        (WebCore::SVGPathSegListBuilder::curveToQuadratic):
        (WebCore::SVGPathSegListBuilder::curveToQuadraticSmooth):
        (WebCore::SVGPathSegListBuilder::arcTo):
        (WebCore::SVGPathSegListBuilder::closePath):
        Store a new RefPtr<SVGValue> for every SVGPathSeg.

        * svg/SVGPathSegListSource.cpp:
        (WebCore::SVGPathSegListSource::parseSVGSegmentType):
        (WebCore::SVGPathSegListSource::nextCommand):
        * svg/SVGPathSegListValues.h:

        * svg/SVGPathUtilities.cpp:
        (WebCore::appendSVGPathByteStreamFromSVGPathSeg):
        (WebCore::addToSVGPathByteStream):
        Answer Simon's questions which were added in r190844.

        * svg/SVGPoint.h:
        (WebCore::SVGPoint::create):
        (WebCore::SVGPoint::SVGPoint):
        * svg/SVGPointList.h:
        (WebCore::SVGPointList::create):
        (WebCore::SVGPointList::SVGPointList):
        * svg/SVGPointListValues.cpp:
        (WebCore::SVGPointListValues::valueAsString const):
        * svg/SVGPointListValues.h:
        (WebCore::SVGPropertyTraits<SVGPointListValues>::fromString):
        * svg/SVGPolyElement.cpp:
        (WebCore::SVGPolyElement::parseAttribute):
        (WebCore::SVGPolyElement::synchronizePoints):
        * svg/SVGPolyElement.h:
        (WebCore::SVGPolyElement::pointList const):
        * svg/SVGPreserveAspectRatio.h:
        (WebCore::SVGPreserveAspectRatio::create):
        (WebCore::SVGPreserveAspectRatio::SVGPreserveAspectRatio):
        * svg/SVGPreserveAspectRatioValue.cpp:
        (WebCore::SVGPreserveAspectRatioValue::SVGPreserveAspectRatioValue):
        * svg/SVGPreserveAspectRatioValue.h:
        (WebCore::SVGPropertyTraits<SVGPreserveAspectRatioValue>::fromString):
        * svg/SVGRadialGradientElement.cpp:
        (WebCore::SVGRadialGradientElement::SVGRadialGradientElement):
        * svg/SVGRect.h:
        (WebCore::SVGRect::create):
        (WebCore::SVGRect::SVGRect):

        * svg/SVGRectTraits.h: Removed. This struct was moved to SVGPropertyTraits.h

        * svg/SVGSVGElement.cpp:
        (WebCore::SVGSVGElement::SVGSVGElement):
        (WebCore::SVGSVGElement::setCurrentTranslate):
        * svg/SVGSVGElement.h:
        (WebCore::SVGSVGElement::currentTranslateValue):
        * svg/SVGStringList.h:
        * svg/SVGStringListValues.cpp:
        (WebCore::SVGStringListValues::reset):
        (WebCore::SVGStringListValues::parse):
        (WebCore::SVGStringListValues::valueAsString const):
        * svg/SVGStringListValues.h:
        * svg/SVGTests.cpp:
        (WebCore::SVGTests::SVGTests):
        (WebCore::SVGTests::isValid const):
        (WebCore::SVGTests::parseAttribute):
        (WebCore::SVGTests::synchronizeAttribute):
        * svg/SVGTextContentElement.cpp:
        (WebCore::SVGTextContentElement::SVGTextContentElement):
        (WebCore::SVGTextContentElement::textLengthAnimated):
        (WebCore::SVGTextContentElement::parseAttribute):
        (WebCore::SVGTextContentElement::svgAttributeChanged):
        * svg/SVGTextPathElement.cpp:
        (WebCore::SVGTextPathElement::SVGTextPathElement):
        * svg/SVGTransform.h:
        (WebCore::SVGTransform::create):
        (WebCore::SVGTransform::SVGTransform):
        * svg/SVGTransformList.h:
        * svg/SVGTransformListValues.cpp:
        (WebCore::SVGTransformListValues::consolidate):
        (WebCore::SVGTransformListValues::concatenate const):
        (WebCore::SVGTransformListValues::valueAsString const):
        * svg/SVGTransformListValues.h:
        (WebCore::SVGPropertyTraits<SVGTransformListValues>::fromString):
        * svg/SVGTransformValue.h:
        (WebCore::SVGPropertyTraits<SVGTransformValue>::initialValue):
        (WebCore::SVGPropertyTraits<SVGTransformValue>::toString):
        * svg/SVGTransformable.cpp:
        (WebCore::SVGTransformable::parseTransformAttribute):
        * svg/SVGUseElement.cpp:
        (WebCore::SVGUseElement::SVGUseElement):

        * svg/SVGValue.h: Added.
        (WebCore::toStringVisitor::operator()): This visitor returns the string
        of the alternative of SVGValueVariant.
        (WebCore::parseVisitor::parseVisitor):
        (WebCore::parseVisitor::operator()): This replaces the alternative of
        SVGValueVariant with the value we get from parsing the string of an
        attribute.
        (WebCore::SVGValue::create):
        (WebCore::SVGValue::is const):
        (WebCore::SVGValue::operator const PropertyType& const):
        (WebCore::SVGValue::operator PropertyType&):
        (WebCore::SVGValue::toString const):
        (WebCore::SVGValue::parse):
        (WebCore::SVGValue::SVGValue):

        * svg/SVGViewElement.cpp:
        (WebCore::SVGViewElement::SVGViewElement):
        (WebCore::SVGViewElement::parseAttribute):
        * svg/SVGViewElement.h:

        * svg/SVGViewSpec.cpp:
        (WebCore::SVGViewSpec::SVGViewSpec): Initialize pointers with the default
        values.
        (WebCore::SVGViewSpec::transformString const):
        (WebCore::SVGViewSpec::viewBoxString const):
        (WebCore::SVGViewSpec::preserveAspectRatioString const):
        (WebCore::SVGViewSpec::reset):
        (WebCore::SVGViewSpec::parseViewSpec):
        * svg/SVGViewSpec.h:

        * svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:
        No need for the casting currentAnimatedValue() method since the base class
        method now returns a RefPtr<SVGValue>. The casting will happen when getting
        the enum value from the SVGValue.

        * svg/properties/SVGAnimatedListPropertyTearOff.h:
        (WebCore::SVGAnimatedListPropertyTearOff::create):
        (WebCore::SVGAnimatedListPropertyTearOff::currentAnimatedValue):
        (WebCore::SVGAnimatedListPropertyTearOff::currentAnimatedValue const):
        (WebCore::SVGAnimatedListPropertyTearOff::currentBaseValue const):
        (WebCore::SVGAnimatedListPropertyTearOff::animationStarted):
        (WebCore::SVGAnimatedListPropertyTearOff::animationEnded):
        (WebCore::SVGAnimatedListPropertyTearOff::synchronizeWrappersIfNeeded):
        (WebCore::SVGAnimatedListPropertyTearOff::animValWillChange):
        (WebCore::SVGAnimatedListPropertyTearOff::animValDidChange):
        (WebCore::SVGAnimatedListPropertyTearOff::SVGAnimatedListPropertyTearOff):
        * svg/properties/SVGAnimatedPathSegListPropertyTearOff.h:
        * svg/properties/SVGAnimatedProperty.h:
        (WebCore::SVGAnimatedProperty::lookupOrCreateWrapper):
        * svg/properties/SVGAnimatedPropertyMacros.h:
        (WebCore::SVGSynchronizableAnimatedProperty::SVGSynchronizableAnimatedProperty):
        * svg/properties/SVGAnimatedPropertyTearOff.h:
        * svg/properties/SVGAnimatedStaticPropertyTearOff.h:
        (WebCore::SVGAnimatedStaticPropertyTearOff::baseVal):
        (WebCore::SVGAnimatedStaticPropertyTearOff::animVal):
        (WebCore::SVGAnimatedStaticPropertyTearOff::setBaseVal):
        (WebCore::SVGAnimatedStaticPropertyTearOff::create):
        (WebCore::SVGAnimatedStaticPropertyTearOff::currentAnimatedValue):
        (WebCore::SVGAnimatedStaticPropertyTearOff::currentAnimatedValue const):
        (WebCore::SVGAnimatedStaticPropertyTearOff::currentBaseValue const):
        (WebCore::SVGAnimatedStaticPropertyTearOff::animationStarted):
        (WebCore::SVGAnimatedStaticPropertyTearOff::animationEnded):
        (WebCore::SVGAnimatedStaticPropertyTearOff::SVGAnimatedStaticPropertyTearOff):
        * svg/properties/SVGAnimatedTransformListPropertyTearOff.h:

        * svg/properties/SVGListProperty.h:
        (WebCore::SVGListProperty::setValuesAndWrappers):
        (WebCore::SVGListProperty::clearValues):
        (WebCore::SVGListProperty::clearValuesAndWrappers):
        (WebCore::SVGListProperty::numberOfItems const):
        (WebCore::SVGListProperty::initializeValues):
        (WebCore::SVGListProperty::initializeValuesAndWrappers):
        (WebCore::SVGListProperty::canGetItem):
        (WebCore::SVGListProperty::getItemValues):
        (WebCore::SVGListProperty::getItemValuesAndWrappers):
        (WebCore::SVGListProperty::insertItemBeforeValues):
        (WebCore::SVGListProperty::insertItemBeforeValuesAndWrappers):
        (WebCore::SVGListProperty::canReplaceItem):
        (WebCore::SVGListProperty::replaceItemValues):
        (WebCore::SVGListProperty::replaceItemValuesAndWrappers):
        (WebCore::SVGListProperty::canRemoveItem):
        (WebCore::SVGListProperty::removeItemValues):
        (WebCore::SVGListProperty::removeItemValuesAndWrappers):
        (WebCore::SVGListProperty::appendItemValues):
        (WebCore::SVGListProperty::appendItemValuesAndWrappers):
        (WebCore::SVGListProperty::values const):
        (WebCore::SVGListProperty::valuesProperty const):
        (WebCore::SVGListProperty::SVGListProperty):
        (WebCore::SVGListProperty::values): Deleted.
        (WebCore::SVGListProperty::~SVGListProperty): Deleted.
        No need for m_ownsValues anymore. m_values is now a RefPtr<SVGValue>. It
        will be deleted once the ref-count becomes zero.

        * svg/properties/SVGListPropertyTearOff.h:
        (WebCore::SVGListPropertyTearOff::create):
        (WebCore::SVGListPropertyTearOff::findItem const):
        (WebCore::SVGListPropertyTearOff::removeItemFromList):
        (WebCore::SVGListPropertyTearOff::SVGListPropertyTearOff):
        * svg/properties/SVGMatrixTearOff.h:
        * svg/properties/SVGPropertyTearOff.h:
        (WebCore::SVGPropertyTearOff::value const):
        (WebCore::SVGPropertyTearOff::propertyReference):
        (WebCore::SVGPropertyTearOff::setValue):
        (WebCore::SVGPropertyTearOff::SVGPropertyTearOff):
        (WebCore::SVGPropertyTearOff::~SVGPropertyTearOff):

        * svg/properties/SVGPropertyTraits.h:
        (WebCore::SVGPropertyTraits<bool>::fromString):
        (WebCore::SVGPropertyTraits<Color>::initialValue):
        (WebCore::SVGPropertyTraits<Color>::fromString):
        (WebCore::SVGPropertyTraits<Color>::parse):
        (WebCore::SVGPropertyTraits<Color>::toString):
        (WebCore::SVGPropertyTraits<int>::fromString):
        (WebCore::SVGPropertyTraits<float>::fromString):
        (WebCore::SVGPropertyTraits<float>::parse):
        (WebCore::SVGPropertyTraits<FloatPoint>::initialValue):
        (WebCore::SVGPropertyTraits<FloatPoint>::fromString):
        (WebCore::SVGPropertyTraits<FloatPoint>::parse):
        (WebCore::SVGPropertyTraits<FloatPoint>::toString):
        (WebCore::SVGPropertyTraits<FloatRect>::initialValue):
        (WebCore::SVGPropertyTraits<FloatRect>::fromString):
        (WebCore::SVGPropertyTraits<FloatRect>::parse):
        (WebCore::SVGPropertyTraits<FloatRect>::toString):
        (WebCore::SVGPropertyTraits<String>::fromString):
        (WebCore::SVGPropertyTraits<String>::parse):
        (WebCore::SVGPropertyTraits<String>::toString):
        Have all the SVGPropertyTraits with no specific SVG type be in one file.

        * svg/properties/SVGStaticListPropertyTearOff.h:
        (WebCore::SVGStaticListPropertyTearOff::SVGStaticListPropertyTearOff):
        * svg/properties/SVGStaticPropertyTearOff.h:

2018-02-15  Zan Dobersek  <zdobersek@igalia.com>

        HarfBuzzFace: rework cache entry reference holding



svg/SVGAnimatedRect.cpp
svg/SVGAnimatedString.cpp
svg/SVGAnimatedTransformList.cpp
svg/SVGAnimatedType.cpp
svg/SVGAnimatedTypeAnimator.cpp
svg/SVGAnimationElement.cpp
svg/SVGCircleElement.cpp

svg/SVGLengthValue.cpp
svg/SVGLineElement.cpp
svg/SVGLinearGradientElement.cpp
svg/SVGListValues.cpp
svg/SVGLocatable.cpp
svg/SVGMPathElement.cpp
svg/SVGMarkerElement.cpp




static Path pathFromPolygonElement(SVGElement& element)
{
    auto& points = downcast<SVGPolygonElement>(element).animatedPoints()->valuesProperty();
    if (points.isEmpty())
        return { };

    Path path;
    path.moveTo(points.firstProperty());

    unsigned size = points.size();
    for (unsigned i = 1; i < size; ++i)
        path.addLineTo(points.propertyAt(i));

    path.closeSubpath();
    return path;


static Path pathFromPolylineElement(SVGElement& element)
{
    auto& points = downcast<SVGPolylineElement>(element).animatedPoints()->valuesProperty();
    if (points.isEmpty())
        return { };

    Path path;
    path.moveTo(points.firstProperty());

    unsigned size = points.size();
    for (unsigned i = 1; i < size; ++i)
        path.addLineTo(points.propertyAt(i));
    return path;
}




static inline void updateCharacterData(unsigned i, float& lastRotation, SVGCharacterData& data, const SVGLengthContext& lengthContext, const SVGLengthListValues* xList, const SVGLengthListValues* yList, const SVGLengthListValues* dxList, const SVGLengthListValues* dyList, const SVGNumberListValues* rotateList)
{
    if (xList)
        data.x = xList->propertyAt(i).value(lengthContext);
    if (yList)
        data.y = yList->propertyAt(i).value(lengthContext);
    if (dxList)
        data.dx = dxList->propertyAt(i).value(lengthContext);
    if (dyList)
        data.dy = dyList->propertyAt(i).value(lengthContext);
    if (rotateList) {
        data.rotate = rotateList->propertyAt(i);
        lastRotation = data.rotate;
    }
}




class SVGAngle : public SVGPropertyTearOff<SVGAngleValue> {
public:
    static Ref<SVGAngle> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
    {
        return adoptRef(*new SVGAngle(animatedProperty, role, value));
    }

        return adoptRef(*new SVGAngle(initialValue));
    }

    static Ref<SVGAngle> create(const SVGAngleValue* initialValue)
    {
        return adoptRef(*new SVGAngle(initialValue));
    }

    template<typename T> static ExceptionOr<Ref<SVGAngle>> create(ExceptionOr<T>&& initialValue)
    {
        if (initialValue.hasException())

    }

private:
    SVGAngle(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : SVGPropertyTearOff<SVGAngleValue>(&animatedProperty, role, value)
    {
    }

        : SVGPropertyTearOff<SVGAngleValue>(initialValue)
    {
    }

    explicit SVGAngle(const SVGAngleValue* initialValue)
        : SVGPropertyTearOff<SVGAngleValue>(initialValue)
    {
    }
};

} // namespace WebCore



    updateAnimationMode();
}

static bool parsePoint(const String& s, FloatPoint& point)
{
    if (s.isEmpty())
        return false;
    auto upconvertedCharacters = StringView(s).upconvertedCharacters();
    const UChar* cur = upconvertedCharacters;
    const UChar* end = cur + s.length();
    
    if (!skipOptionalSVGSpaces(cur, end))
        return false;
    
    float x = 0;
    if (!parseNumber(cur, end, x))
        return false;
    
    float y = 0;
    if (!parseNumber(cur, end, y))
        return false;
    
    point = FloatPoint(x, y);
    
    // disallow anything except spaces at the end
    return !skipOptionalSVGSpaces(cur, end);
}
    
void SVGAnimateMotionElement::resetAnimatedType()
{
    if (!hasValidAttributeType())




std::unique_ptr<SVGAnimatedType> SVGAnimatedAngleAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<std::pair<SVGAngleValue, unsigned>>::fromString(string));
    auto& animatedPair = animatedType->angleAndEnumeration();

    SVGAngleValue angle;
    SVGMarkerOrientType orientType = SVGPropertyTraits<SVGMarkerOrientType>::fromString(string, angle);
    if (orientType > 0)
        animatedPair.second = orientType;
    if (orientType == SVGMarkerOrientAngle)
        animatedPair.first = angle;

    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedAngleAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValues<SVGAnimatedAngle, SVGAnimatedEnumeration>(animatedTypes);
}

void SVGAnimatedAngleAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedAngleAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValues<SVGAnimatedAngle, SVGAnimatedEnumeration>(animatedTypes, type);
}

void SVGAnimatedAngleAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedAngle);
    ASSERT(from->type() == to->type());

    const auto& fromAngle = static_cast<SVGAngleValue&>(*from->values[0]);
    const auto& fromEnumeration = static_cast<unsigned&>(*from->values[1]);
    auto& toAngle = static_cast<SVGAngleValue&>(*to->values[0]);
    auto& toEnumeration = static_cast<unsigned&>(*to->values[1]);
    // Only respect by animations, if from and by are both specified in angles (and not eg. 'auto').
    if (fromEnumeration != toEnumeration || fromEnumeration != SVGMarkerOrientAngle)
        return;
    const auto& fromAngle = fromAngleAndEnumeration.first;
    auto& toAngle = toAngleAndEnumeration.first;
    toAngle.setValue(toAngle.value() + fromAngle.value());
}


    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    const auto& fromAngle = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGAngleValue&>(*animated->values[0]) : static_cast<SVGAngleValue&>(*from->values[0]);
    const auto& fromEnumeration = m_animationElement->animationMode() == ToAnimation ? static_cast<unsigned&>(*animated->values[1]) : static_cast<unsigned&>(*from->values[1]);
    auto& toAngle = static_cast<SVGAngleValue&>(*to->values[0]);
    auto& toEnumeration = static_cast<unsigned&>(*to->values[1]);
    auto& toAtEndOfDurationAngle = static_cast<SVGAngleValue&>(*toAtEndOfDuration->values[0]);
    auto& animatedAngle = static_cast<SVGAngleValue&>(*animated->values[0]);
    auto& animatedEnumeration = static_cast<unsigned&>(*animated->values[1]);

    if (fromEnumeration != toEnumeration) {
        // Discrete animation - no linear interpolation possible between values (e.g. auto to angle).
        if (percentage < 0.5f) {
            animatedEnumeration = fromEnumeration;
            if (fromEnumeration == SVGMarkerOrientAngle)
                animatedAngle = fromAngle;
            else
                animatedAngle.setValue(0);
            return;
        }
        animatedEnumeration = toEnumeration;
        if (toEnumeration == SVGMarkerOrientAngle)
            animatedAngle = toAngle;
        else
            animatedAngle.setValue(0);
        return;
    }

    if (fromEnumeration == SVGMarkerOrientAngle) {
        // Regular from angle to angle animation, with support for smooth interpolation, and additive and accumulated animation.
        animatedEnumeration = SVGMarkerOrientAngle;

        float animatedAngleValue = animatedAngle.value();
        m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromAngle.value(), toAngle.value(), toAtEndOfDurationAngle.value(), animatedAngleValue);
        animatedAngle.setValue(animatedAngleValue);
        m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromAngleAndEnumeration.first.value(), toAngleAndEnumeration.first.value(), toAtEndOfDurationSVGAngle.value(), animatedAngle);
        animatedSVGAngle.setValue(animatedAngle);
        return;
    }

    // auto, auto-start-reverse, or unknown.
    animatedAngle.setValue(0);

    if (fromEnumeration == SVGMarkerOrientAuto || fromEnumeration == SVGMarkerOrientAutoStartReverse)
        animatedEnumeration = fromEnumeration;
    else
        animatedEnumeration = SVGMarkerOrientUnknown;
}

float SVGAnimatedAngleAnimator::calculateDistance(const String& fromString, const String& toString)




std::unique_ptr<SVGAnimatedType> SVGAnimatedBooleanAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<bool>::fromString(string));
    animatedType->boolean() = (string == "true"); // wat?
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedBooleanAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedBoolean>(animatedTypes);
}

void SVGAnimatedBooleanAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedBooleanAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedBoolean>(animatedTypes, type);
}

void SVGAnimatedBooleanAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    bool fromBoolean = m_animationElement->animationMode() == ToAnimation ? static_cast<bool&>(*animated->values[0]) : static_cast<bool&>(*from->values[0]);
    bool toBoolean = static_cast<bool&>(*to->values[0]);
    bool& animatedBoolean = static_cast<bool&>(*animated->values[0]);

    m_animationElement->animateDiscreteType<bool>(percentage, fromBoolean, toBoolean, animatedBoolean);
}




std::unique_ptr<SVGAnimatedType> SVGAnimatedColorAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<Color>::fromString(string));
}

void SVGAnimatedColorAnimator::addAnimatedTypes(SVGAnimatedType* from, SVGAnimatedType* to)

    ASSERT(to->type() == AnimatedColor);

    // Ignores any alpha and sets alpha on result to 100% opaque.
    auto& fromColor = static_cast<Color&>(*from->values[0]);
    auto& toColor = static_cast<Color&>(*to->values[0]);
    toColor = { roundAndClampColorChannel(toColor.red() + fromColor.red()),
        roundAndClampColorChannel(toColor.green() + fromColor.green()),
        roundAndClampColorChannel(toColor.blue() + fromColor.blue()) };

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    Color fromColor = m_animationElement->animationMode() == ToAnimation ? static_cast<Color&>(*animated->values[0]) : static_cast<Color&>(*from->values[0]);
    Color toColor = static_cast<Color&>(*to->values[0]);

    // Apply CSS inheritance rules.
    m_animationElement->adjustForInheritance<Color>(parseColorFromString, m_animationElement->fromPropertyValueType(), fromColor, m_contextElement);

    if (m_animationElement->toPropertyValueType() == CurrentColorValue)
        toColor = currentColor(*m_contextElement);

    auto& toAtEndOfDurationColor = static_cast<Color&>(*toAtEndOfDuration->values[0]);
    auto& animatedColor = static_cast<Color&>(*animated->values[0]);

    // FIXME: ExtendedColor - this will need to handle blending between colors in different color spaces,
    // as well as work with non [0-255] Colors.



std::unique_ptr<SVGAnimatedType> SVGAnimatedEnumerationAnimator::constructFromString(const String& string)
{
    ASSERT(m_animationElement);
    return SVGAnimatedType::create(enumerationValueForTargetAttribute(m_animationElement->targetElement(), m_animationElement->attributeName(), string));
    animatedType->enumeration() = enumerationValueForTargetAttribute(m_animationElement->targetElement(), m_animationElement->attributeName(), string);
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedEnumerationAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedEnumeration>(animatedTypes);
}

void SVGAnimatedEnumerationAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedEnumerationAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedEnumeration>(animatedTypes, type);
}

void SVGAnimatedEnumerationAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    unsigned fromEnumeration = m_animationElement->animationMode() == ToAnimation ? static_cast<unsigned&>(*animated->values[0]) : static_cast<unsigned&>(*from->values[0]);
    unsigned toEnumeration = static_cast<unsigned&>(*to->values[0]);
    unsigned& animatedEnumeration = static_cast<unsigned&>(*animated->values[0]);

    m_animationElement->animateDiscreteType<unsigned>(percentage, fromEnumeration, toEnumeration, animatedEnumeration);
}




std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<int>::fromString(string));
    animatedType->integer() = string.toIntStrict();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedInteger>(animatedTypes);
}

void SVGAnimatedIntegerAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedIntegerAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedInteger>(animatedTypes, type);
}

void SVGAnimatedIntegerAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedInteger);
    ASSERT(from->type() == to->type());

    static_cast<int&>(*to->values[0]) += static_cast<int&>(*from->values[0]);
}

void SVGAnimatedIntegerAnimator::calculateAnimatedInteger(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, int fromInteger, int toInteger, int toAtEndOfDurationInteger, int& animatedInteger)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    int fromInteger = m_animationElement->animationMode() == ToAnimation ? static_cast<int&>(*animated->values[0]) : static_cast<int&>(*from->values[0]);
    int toInteger = static_cast<int&>(*to->values[0]);
    int toAtEndOfDurationInteger = static_cast<int&>(*toAtEndOfDuration->values[0]);
    int& animatedInteger = static_cast<int&>(*animated->values[0]);

    calculateAnimatedInteger(m_animationElement, percentage, repeatCount, fromInteger, toInteger, toAtEndOfDurationInteger, animatedInteger);
}




std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerOptionalIntegerAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<std::pair<int, int>>::fromString(string));
    std::pair<int, int>& animatedInteger = animatedType->integerOptionalInteger();
    float firstNumber = 0;
    float secondNumber = 0;
    if (!parseNumberOptionalNumber(string, firstNumber, secondNumber)) {
        animatedInteger.first = 0;
        animatedInteger.second = 0;
    } else {
        animatedInteger.first = static_cast<int>(roundf(firstNumber));
        animatedInteger.second = static_cast<int>(roundf(secondNumber));
    }
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerOptionalIntegerAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValues<SVGAnimatedInteger, SVGAnimatedInteger>(animatedTypes);
}

void SVGAnimatedIntegerOptionalIntegerAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedIntegerOptionalIntegerAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValues<SVGAnimatedInteger, SVGAnimatedInteger>(animatedTypes, type);
}

void SVGAnimatedIntegerOptionalIntegerAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedIntegerOptionalInteger);
    ASSERT(from->type() == to->type());

    static_cast<int&>(*to->values[0]) += static_cast<int&>(*from->values[0]);
    static_cast<int&>(*to->values[1]) += static_cast<int&>(*from->values[1]);

    toIntegerPair.first += fromIntegerPair.first;
    toIntegerPair.second += fromIntegerPair.second;
}

void SVGAnimatedIntegerOptionalIntegerAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    const int& formFirst = m_animationElement->animationMode() == ToAnimation ? static_cast<int&>(*animated->values[0]) : static_cast<int&>(*from->values[0]);
    const int& formSecond = m_animationElement->animationMode() == ToAnimation ? static_cast<int&>(*animated->values[1]) : static_cast<int&>(*from->values[1]);
    const int& toFirst = static_cast<int&>(*to->values[0]);
    const int& toSecond = static_cast<int&>(*to->values[1]);
    const int& toAtEndOfDurationFirst = static_cast<int&>(*toAtEndOfDuration->values[0]);
    const int& toAtEndOfDurationSecond = static_cast<int&>(*toAtEndOfDuration->values[1]);
    int& animatedFirst = static_cast<int&>(*animated->values[0]);
    int& animatedSecond = static_cast<int&>(*animated->values[1]);

    SVGAnimatedIntegerAnimator::calculateAnimatedInteger(m_animationElement, percentage, repeatCount, formFirst, toFirst, toAtEndOfDurationFirst, animatedFirst);
    SVGAnimatedIntegerAnimator::calculateAnimatedInteger(m_animationElement, percentage, repeatCount, formSecond, toSecond, toAtEndOfDurationSecond, animatedSecond);
}

float SVGAnimatedIntegerOptionalIntegerAnimator::calculateDistance(const String&, const String&)




std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGLengthValue(m_lengthMode, string));
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedLength>(animatedTypes);
}

void SVGAnimatedLengthAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedLengthAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedLength>(animatedTypes, type);
}

void SVGAnimatedLengthAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == to->type());

    SVGLengthContext lengthContext(m_contextElement);
    const auto& fromLength = static_cast<SVGLengthValue&>(*from->values[0]);
    auto& toLength = static_cast<SVGLengthValue&>(*to->values[0]);

    toLength.setValue(toLength.value(lengthContext) + fromLength.value(lengthContext), lengthContext);
}

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    auto fromSVGLength = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGLengthValue&>(*animated->values[0]) : static_cast<SVGLengthValue&>(*from->values[0]);
    auto toSVGLength = static_cast<SVGLengthValue&>(*to->values[0]);
    const auto& toAtEndOfDurationSVGLength = static_cast<SVGLengthValue&>(*toAtEndOfDuration->values[0]);
    auto& animatedSVGLength = static_cast<SVGLengthValue&>(*animated->values[0]);

    // Apply CSS inheritance rules.
    m_animationElement->adjustForInheritance<SVGLengthValue>(parseLengthFromString, m_animationElement->fromPropertyValueType(), fromSVGLength, m_contextElement);




std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthListAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<SVGLengthListValues>::fromString(string, m_lengthMode));
    animatedType->lengthList().parse(string, m_lengthMode);
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedLengthList>(animatedTypes);
}

void SVGAnimatedLengthListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedLengthListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedLengthList>(animatedTypes, type);
}

void SVGAnimatedLengthListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedLengthList);
    ASSERT(from->type() == to->type());

    const auto& fromLengthList = static_cast<SVGLengthListValues&>(*from->values[0]);
    auto& toLengthList = static_cast<SVGLengthListValues&>(*to->values[0]);

    unsigned fromLengthListSize = fromLengthList.size();
    if (!fromLengthListSize || fromLengthListSize != toLengthList.size())


    SVGLengthContext lengthContext(m_contextElement);
    for (unsigned i = 0; i < fromLengthListSize; ++i)
        toLengthList.propertyAt(i).setValue(toLengthList.propertyAt(i).value(lengthContext) + fromLengthList.propertyAt(i).value(lengthContext), lengthContext);
}

static SVGLengthListValues parseLengthListFromString(SVGAnimationElement* animationElement, const String& string)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    auto fromLengthList = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGLengthListValues&>(*animated->values[0]) : static_cast<SVGLengthListValues&>(*from->values[0]);
    auto toLengthList = static_cast<SVGLengthListValues&>(*to->values[0]);
    const auto& toAtEndOfDurationLengthList = static_cast<SVGLengthListValues&>(*toAtEndOfDuration->values[0]);
    auto& animatedLengthList = static_cast<SVGLengthListValues&>(*animated->values[0]);

    // Apply CSS inheritance rules.
    m_animationElement->adjustForInheritance<SVGLengthListValues>(parseLengthListFromString, m_animationElement->fromPropertyValueType(), fromLengthList, m_contextElement);


    SVGLengthContext lengthContext(m_contextElement);
    for (unsigned i = 0; i < toLengthListSize; ++i) {
        float animatedNumber = animatedLengthList.propertyAt(i).value(lengthContext);
        SVGLengthType unitType = toLengthList.propertyAt(i).unitType();
        float effectiveFrom = 0;
        if (fromLengthListSize) {
            if (percentage < 0.5)
                unitType = fromLengthList.propertyAt(i).unitType();
            effectiveFrom = fromLengthList.propertyAt(i).value(lengthContext);
        }
        float effectiveToAtEnd = i < toAtEndOfDurationListSize ? toAtEndOfDurationLengthList.propertyAt(i).value(lengthContext) : 0;

        m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom, toLengthList.propertyAt(i).value(lengthContext), effectiveToAtEnd, animatedNumber);
        animatedLengthList.propertyAt(i).setValue(lengthContext, animatedNumber, m_lengthMode, unitType);
    }
}





std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<float>::fromString(string));
    float& animatedNumber = animatedType->number();
    if (!parseNumberFromString(string, animatedNumber))
        animatedNumber = 0;
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedNumber>(animatedTypes);
}

void SVGAnimatedNumberAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedNumberAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedNumber>(animatedTypes, type);
}

void SVGAnimatedNumberAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedNumber);
    ASSERT(from->type() == to->type());

    static_cast<float&>(*to->values[0]) += static_cast<float&>(*from->values[0]);
}

static float parseNumberFromString(SVGAnimationElement*, const String& string)
{
    return SVGPropertyTraits<float>::fromString(string);
    parseNumberFromString(string, number);
    return number;
}

void SVGAnimatedNumberAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    float fromNumber = m_animationElement->animationMode() == ToAnimation ? static_cast<float&>(*animated->values[0]) : static_cast<float&>(*from->values[0]);
    float toNumber = static_cast<float&>(*to->values[0]);
    float toAtEndOfDurationNumber = static_cast<float&>(*toAtEndOfDuration->values[0]);
    float& animatedNumber = static_cast<float&>(*animated->values[0]);

    // Apply CSS inheritance rules.
    m_animationElement->adjustForInheritance<float>(parseNumberFromString, m_animationElement->fromPropertyValueType(), fromNumber, m_contextElement);




std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberListAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<SVGNumberListValues>::fromString(string));
    animatedType->numberList().parse(string);
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedNumberList>(animatedTypes);
}

void SVGAnimatedNumberListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedNumberListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedNumberList>(animatedTypes, type);
}

void SVGAnimatedNumberListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedNumberList);
    ASSERT(from->type() == to->type());

    const auto& fromNumberList = static_cast<SVGNumberListValues&>(*from->values[0]);
    auto& toNumberList = static_cast<SVGNumberListValues&>(*to->values[0]);

    unsigned fromNumberListSize = fromNumberList.size();
    if (!fromNumberListSize || fromNumberListSize != toNumberList.size())
        return;

    for (unsigned i = 0; i < fromNumberListSize; ++i)
        static_cast<float&>(*toNumberList[i]) += static_cast<float&>(*fromNumberList[i]);
}

void SVGAnimatedNumberListAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
{
    ASSERT(m_animationElement);

    const auto& fromNumberList = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGNumberListValues&>(*animated->values[0]) : static_cast<SVGNumberListValues&>(*from->values[0]);
    const auto& toNumberList = static_cast<SVGNumberListValues&>(*to->values[0]);
    const auto& toAtEndOfDurationNumberList = static_cast<SVGNumberListValues&>(*toAtEndOfDuration->values[0]);
    auto& animatedNumberList = static_cast<SVGNumberListValues&>(*animated->values[0]);
    if (!m_animationElement->adjustFromToListValues<SVGNumberListValues>(fromNumberList, toNumberList, animatedNumberList, percentage))
        return;


    unsigned toAtEndOfDurationSize = toAtEndOfDurationNumberList.size();

    for (unsigned i = 0; i < toNumberListSize; ++i) {
        float effectiveFrom = fromNumberListSize ? fromNumberList.propertyAt(i) : 0;
        float effectiveToAtEnd = i < toAtEndOfDurationSize ? toAtEndOfDurationNumberList.propertyAt(i) : 0;
        m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom, toNumberList.propertyAt(i), effectiveToAtEnd, animatedNumberList.propertyAt(i));
    }
}





std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberOptionalNumberAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<std::pair<float, float>>::fromString(string));
    std::pair<float, float>& animatedNumber = animatedType->numberOptionalNumber();
    if (!parseNumberOptionalNumber(string, animatedNumber.first, animatedNumber.second)) {
        animatedNumber.first = 0;
        animatedNumber.second = 0;
    }
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberOptionalNumberAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValues<SVGAnimatedNumber, SVGAnimatedNumber>(animatedTypes);
}

void SVGAnimatedNumberOptionalNumberAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedNumberOptionalNumberAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValues<SVGAnimatedNumber, SVGAnimatedNumber>(animatedTypes, type);
}

void SVGAnimatedNumberOptionalNumberAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedNumberOptionalNumber);
    ASSERT(from->type() == to->type());

    static_cast<float&>(*to->values[0]) += static_cast<float&>(*from->values[0]);
    static_cast<float&>(*to->values[1]) += static_cast<float&>(*from->values[1]);

    toNumberPair.first += fromNumberPair.first;
    toNumberPair.second += fromNumberPair.second;
}

void SVGAnimatedNumberOptionalNumberAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    const auto& formFirst = m_animationElement->animationMode() == ToAnimation ? static_cast<float&>(*animated->values[0]) : static_cast<float&>(*from->values[0]);
    const auto& formSecond = m_animationElement->animationMode() == ToAnimation ? static_cast<float&>(*animated->values[1]) : static_cast<float&>(*from->values[1]);
    const auto& toFirst = static_cast<float&>(*to->values[0]);
    const auto& toSecond = static_cast<float&>(*to->values[1]);
    const auto& toAtEndOfDurationFirst = static_cast<float&>(*toAtEndOfDuration->values[0]);
    const auto& toAtEndOfDurationSecond = static_cast<float&>(*toAtEndOfDuration->values[1]);
    auto& animatedFirst = static_cast<float&>(*animated->values[0]);
    auto& animatedSecond = static_cast<float&>(*animated->values[1]);

    m_animationElement->animateAdditiveNumber(percentage, repeatCount, formFirst, toFirst, toAtEndOfDurationFirst, animatedFirst);
    m_animationElement->animateAdditiveNumber(percentage, repeatCount, formSecond, toSecond, toAtEndOfDurationSecond, animatedSecond);
}

float SVGAnimatedNumberOptionalNumberAnimator::calculateDistance(const String&, const String&)




#include "SVGAnimateElementBase.h"
#include "SVGAnimatedPathSegListPropertyTearOff.h"
#include "SVGPathUtilities.h"

namespace WebCore {



std::unique_ptr<SVGAnimatedType> SVGAnimatedPathAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<SVGPathByteStream>::fromString(string));
    buildSVGPathByteStreamFromString(string, *byteStream, UnalteredParsing);
    return SVGAnimatedType::createPath(WTFMove(byteStream));
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedPathAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(animatedTypes.size() >= 1);

    // Build initial path byte stream.
    auto animatedType = SVGAnimatedType::create<SVGPathByteStream>();
    resetAnimValToBaseVal(animatedTypes, *animatedType);
    return animatedType;
}

void SVGAnimatedPathAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)

    RefPtr<SVGAnimatedPathSegListPropertyTearOff> property = castAnimatedPropertyToActualType<SVGAnimatedPathSegListPropertyTearOff>(animatedTypes[0].properties[0].get());
    const auto& baseValue = property->currentBaseValue();

    buildSVGPathByteStreamFromSVGPathSegListValues(static_cast<SVGPathSegListValues&>(*baseValue), *byteStream, UnalteredParsing);

    Vector<RefPtr<SVGAnimatedPathSegListPropertyTearOff>> result;


    if (!result.isEmpty()) {
        SVGElement::InstanceUpdateBlocker blocker(*property->contextElement());
        for (auto& segment : result)
            segment->animationStarted(byteStream, &static_cast<SVGPathSegListValues&>(*baseValue));
    }
}


{
    ASSERT(animatedTypes.size() >= 1);
    ASSERT(type.type() == m_type);
    resetAnimValToBaseVal(animatedTypes, &static_cast<SVGPathByteStream&>(*type.values[0]));
}

void SVGAnimatedPathAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedPath);
    ASSERT(from->type() == to->type());

    const auto& fromPath = static_cast<SVGPathByteStream&>(*from->values[0]);
    auto& toPath = static_cast<SVGPathByteStream&>(*to->values[0]);
    unsigned fromPathSize = fromPath.size();
    if (!fromPathSize || fromPathSize != toPath.size())
        return;
    addToSVGPathByteStream(toPath, fromPath);
}

void SVGAnimatedPathAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    auto& fromPath = static_cast<SVGPathByteStream&>(*from->values[0]);
    auto& toPath = static_cast<SVGPathByteStream&>(*to->values[0]);
    auto& toAtEndOfDurationPath = static_cast<SVGPathByteStream&>(*toAtEndOfDuration->values[0]);
    auto& animatedPath = static_cast<SVGPathByteStream&>(*animated->values[0]);

    std::unique_ptr<SVGPathByteStream> underlyingPath;
    bool isToAnimation = m_animationElement->animationMode() == ToAnimation;
    if (isToAnimation)
        fromPath = animatedPath;
        fromPath = underlyingPath.get();
    }

    // Cache the current animated value before the buildAnimatedSVGPathByteStream() clears animatedPath.
    SVGPathByteStream lastAnimatedPath;
    if (!fromPath.size() || (m_animationElement->isAdditive() && !isToAnimation))
        lastAnimatedPath = animatedPath;

    // Pass false to 'resizeAnimatedListIfNeeded' here, as the path animation is not a regular Vector<SVGXXX> type, but a SVGPathByteStream, that works differently.
    if (!m_animationElement->adjustFromToListValues<SVGPathByteStream>(fromPath, toPath, animatedPath, percentage, false))
        return;

    buildAnimatedSVGPathByteStream(fromPath, toPath, animatedPath, percentage);

    // Handle additive='sum'.
    if (!lastAnimatedPath.isEmpty())
        addToSVGPathByteStream(animatedPath, lastAnimatedPath);

    // Handle accumulate='sum'.
    if (m_animationElement->isAccumulated() && repeatCount)
        addToSVGPathByteStream(animatedPath, toAtEndOfDurationPath, repeatCount);
}

float SVGAnimatedPathAnimator::calculateDistance(const String&, const String&)




std::unique_ptr<SVGAnimatedType> SVGAnimatedPointListAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<SVGPointListValues>::fromString(string));
    pointsListFromSVGData(animatedType->pointList(), string);
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedPointListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedPointList>(animatedTypes);
}

void SVGAnimatedPointListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedPointListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedPointList>(animatedTypes, type);
}

void SVGAnimatedPointListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedPoints);
    ASSERT(from->type() == to->type());

    const auto& fromPointList = static_cast<SVGPointListValues&>(*from->values[0]);
    auto& toPointList =  static_cast<SVGPointListValues&>(*to->values[0]);

    unsigned fromPointListSize = fromPointList.size();
    if (!fromPointListSize || fromPointListSize != toPointList.size())
        return;

    for (unsigned i = 0; i < fromPointListSize; ++i)
        toPointList.propertyAt(i) += fromPointList.propertyAt(i);
}

void SVGAnimatedPointListAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
{
    ASSERT(m_animationElement);

    const auto& fromPointList = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGPointListValues&>(*animated->values[0]) : static_cast<SVGPointListValues&>(*from->values[0]);
    const auto& toPointList = static_cast<SVGPointListValues&>(*to->values[0]);
    const auto& toAtEndOfDurationPointList = static_cast<SVGPointListValues&>(*toAtEndOfDuration->values[0]);
    auto& animatedPointList = static_cast<SVGPointListValues&>(*animated->values[0]);
    if (!m_animationElement->adjustFromToListValues<SVGPointListValues>(fromPointList, toPointList, animatedPointList, percentage))
        return;


    for (unsigned i = 0; i < toPointListSize; ++i) {
        FloatPoint effectiveFrom;
        if (fromPointListSize)
            effectiveFrom = fromPointList.propertyAt(i);
        FloatPoint effectiveToAtEnd = i < toAtEndOfDurationSize ? toAtEndOfDurationPointList.propertyAt(i) : FloatPoint();

        float animatedX = animatedPointList.propertyAt(i).x();
        float animatedY = animatedPointList.propertyAt(i).y();
        m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom.x(), toPointList.propertyAt(i).x(), effectiveToAtEnd.x(), animatedX);
        m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom.y(), toPointList.propertyAt(i).y(), effectiveToAtEnd.y(), animatedY);
        animatedPointList.propertyAt(i) = FloatPoint(animatedX, animatedY);
    }
}





std::unique_ptr<SVGAnimatedType> SVGAnimatedPreserveAspectRatioAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<SVGPreserveAspectRatioValue>::fromString(string));
    animatedType->preserveAspectRatio().parse(string);
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedPreserveAspectRatioAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedPreserveAspectRatio>(animatedTypes);
}

void SVGAnimatedPreserveAspectRatioAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedPreserveAspectRatioAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedPreserveAspectRatio>(animatedTypes, type);
}

void SVGAnimatedPreserveAspectRatioAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    const auto& fromPreserveAspectRatio = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGPreserveAspectRatioValue&>(*animated->values[0]) : static_cast<SVGPreserveAspectRatioValue&>(*from->values[0]);
    const auto& toPreserveAspectRatio = static_cast<SVGPreserveAspectRatioValue&>(*to->values[0]);
    auto& animatedPreserveAspectRatio = static_cast<SVGPreserveAspectRatioValue&>(*animated->values[0]);

    m_animationElement->animateDiscreteType<SVGPreserveAspectRatioValue>(percentage, fromPreserveAspectRatio, toPreserveAspectRatio, animatedPreserveAspectRatio);
}




std::unique_ptr<SVGAnimatedType> SVGAnimatedRectAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<FloatRect>::fromString(string));
    parseRect(string, animatedType->rect());
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedRectAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedRect>(animatedTypes);
}

void SVGAnimatedRectAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedRectAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedRect>(animatedTypes, type);
}

void SVGAnimatedRectAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedRect);
    ASSERT(from->type() == to->type());

    static_cast<FloatRect&>(*to->values[0]) += static_cast<FloatRect&>(*from->values[0]);
}

void SVGAnimatedRectAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    const auto& fromRect = m_animationElement->animationMode() == ToAnimation ? static_cast<FloatRect&>(*animated->values[0]) : static_cast<FloatRect&>(*from->values[0]);
    const auto& toRect = static_cast<FloatRect&>(*to->values[0]);
    const auto& toAtEndOfDurationRect = static_cast<FloatRect&>(*toAtEndOfDuration->values[0]);
    auto& animatedRect = static_cast<FloatRect&>(*animated->values[0]);

    float animatedX = animatedRect.x();
    float animatedY = animatedRect.y();



/*
 * Copyright (C) Research In Motion Limited 2011. All rights reserved.
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public


std::unique_ptr<SVGAnimatedType> SVGAnimatedStringAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<String>::fromString(string));
    animatedType->string() = string;
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedStringAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedString>(animatedTypes);
}

void SVGAnimatedStringAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedStringAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedString>(animatedTypes, type);
}

void SVGAnimatedStringAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(m_animationElement);
    ASSERT(m_contextElement);

    String fromString = static_cast<String&>(*from->values[0]);
    String toString = static_cast<String&>(*to->values[0]);
    String& animatedString = static_cast<String&>(*animated->values[0]);

    // Apply CSS inheritance rules.
    m_animationElement->adjustForInheritance<String>(parseStringFromString, m_animationElement->fromPropertyValueType(), fromString, m_contextElement);




std::unique_ptr<SVGAnimatedType> SVGAnimatedTransformListAnimator::constructFromString(const String& string)
{
    return SVGAnimatedType::create(SVGPropertyTraits<SVGTransformListValues>::fromString(m_transformTypeString + string + ')'));
    animatedType->transformList().parse(m_transformTypeString + string + ')');
    ASSERT(animatedType->transformList().size() <= 1);
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedTransformListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
{
    return constructFromBaseValue<SVGAnimatedTransformList>(animatedTypes);
}

void SVGAnimatedTransformListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)


void SVGAnimatedTransformListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
{
    resetFromBaseValue<SVGAnimatedTransformList>(animatedTypes, type);
}

void SVGAnimatedTransformListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)

    ASSERT(from->type() == AnimatedTransformList);
    ASSERT(from->type() == to->type());

    const auto& fromTransformList = static_cast<SVGTransformListValues&>(*from->values[0]);
    auto& toTransformList = static_cast<SVGTransformListValues&>(*to->values[0]);
    auto fromTransformListSize = fromTransformList.size();
    if (!fromTransformListSize || fromTransformListSize != toTransformList.size())
        return;

    ASSERT(fromTransformListSize == 1);
    const auto& fromTransform = fromTransformList.propertyAt(0);
    auto& toTransform = toTransformList.propertyAt(0);

    ASSERT(fromTransform.type() == toTransform.type());
    toTransform = SVGTransformDistance::addSVGTransforms(fromTransform, toTransform);

    // Spec: To animations provide specific functionality to get a smooth change from the underlying value to the
    // ‘to’ attribute value, which conflicts mathematically with the requirement for additive transform animations
    // to be post-multiplied. As a consequence, in SVG 1.1 the behavior of to animations for ‘animateTransform’ is undefined.
    const auto& fromTransformList = static_cast<SVGTransformListValues&>(*from->values[0]);
    const auto& toTransformList = static_cast<SVGTransformListValues&>(*to->values[0]);
    const auto& toAtEndOfDurationTransformList = static_cast<SVGTransformListValues&>(*toAtEndOfDuration->values[0]);
    auto& animatedTransformList = static_cast<SVGTransformListValues&>(*animated->values[0]);

    // Pass false to 'resizeAnimatedListIfNeeded' here, as the special post-multiplication behavior of <animateTransform> needs to be respected below.
    if (!m_animationElement->adjustFromToListValues<SVGTransformListValues>(fromTransformList, toTransformList, animatedTransformList, percentage, false))

        animatedTransformList.clear();

    auto fromTransformListSize = fromTransformList.size();
    const auto& toTransform = toTransformList.propertyAt(0);
    const auto effectiveFrom = fromTransformListSize ? fromTransformList.propertyAt(0) : SVGTransformValue(toTransform.type(), SVGTransformValue::ConstructZeroTransform);
    auto currentTransform = SVGTransformDistance(effectiveFrom, toTransform).scaledDistance(percentage).addToSVGTransform(effectiveFrom);
    if (m_animationElement->isAccumulated() && repeatCount) {
        const auto effectiveToAtEnd = toAtEndOfDurationTransformList.size() ? toAtEndOfDurationTransformList.propertyAt(0) : SVGTransformValue(toTransform.type(), SVGTransformValue::ConstructZeroTransform);
        animatedTransformList.append(SVGValue::create<SVGTransformValue>(SVGTransformDistance::addSVGTransforms(currentTransform, effectiveToAtEnd, repeatCount)));
    } else
        animatedTransformList.append(SVGValue::create<SVGTransformValue>(currentTransform));
}

float SVGAnimatedTransformListAnimator::calculateDistance(const String& fromString, const String& toString)

    auto from = constructFromString(fromString);
    auto to = constructFromString(toString);

    auto& fromTransformList = static_cast<SVGTransformListValues&>(*from->values[0]);
    auto& toTransformList = static_cast<SVGTransformListValues&>(*to->values[0]);
    unsigned itemsCount = fromTransformList.size();
    if (!itemsCount || itemsCount != toTransformList.size())
        return -1;

    ASSERT(itemsCount == 1);
    if (fromTransformList.propertyAt(0).type() != toTransformList.propertyAt(0).type())
        return -1;

    // Spec: http://www.w3.org/TR/SVG/animate.html#complexDistances
    // Paced animations assume a notion of distance between the various animation values defined by the ‘to’, ‘from’, ‘by’ and ‘values’ attributes.
    // Distance is defined only for scalar types (such as <length>), colors and the subset of transformation types that are supported by ‘animateTransform’.
    return SVGTransformDistance(fromTransformList.propertyAt(0), toTransformList.propertyAt(0)).distance();
}

}



/*
 * Copyright (C) Research In Motion Limited 2011. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "config.h"
#include "SVGAnimatedType.h"

#include "CSSParser.h"
#include "SVGParserUtilities.h"
#include "SVGPathByteStream.h"

namespace WebCore {

SVGAnimatedType::SVGAnimatedType(AnimatedPropertyType type)
    : m_type(type)
{
}

SVGAnimatedType::~SVGAnimatedType()
{
    switch (m_type) {
    case AnimatedAngle:
        delete m_data.angleAndEnumeration;
        break;
    case AnimatedBoolean:
        delete m_data.boolean;
        break;
    case AnimatedColor:
        delete m_data.color;
        break;
    case AnimatedEnumeration:
        delete m_data.enumeration;
        break;
    case AnimatedInteger:
        delete m_data.integer;
        break;
    case AnimatedIntegerOptionalInteger:
        delete m_data.integerOptionalInteger;
        break;
    case AnimatedLength:
        delete m_data.length;
        break;
    case AnimatedLengthList:
        delete m_data.lengthList;
        break;
    case AnimatedNumber:
        delete m_data.number;
        break;
    case AnimatedNumberList:
        delete m_data.numberList;
        break;
    case AnimatedNumberOptionalNumber:
        delete m_data.numberOptionalNumber;
        break;
    case AnimatedPath:
        delete m_data.path;
        break;
    case AnimatedPoints:
        delete m_data.pointList;
        break;
    case AnimatedPreserveAspectRatio:
        delete m_data.preserveAspectRatio;
        break;
    case AnimatedRect:
        delete m_data.rect;
        break;
    case AnimatedString:
        delete m_data.string;
        break;
    case AnimatedTransformList:
        delete m_data.transformList;
        break;
    case AnimatedUnknown:
        ASSERT_NOT_REACHED();
        break;
    }
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createAngleAndEnumeration(std::unique_ptr<std::pair<SVGAngleValue, unsigned>> angleAndEnumeration)
{
    ASSERT(angleAndEnumeration);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedAngle);
    animatedType->m_data.angleAndEnumeration = angleAndEnumeration.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createBoolean(std::unique_ptr<bool> boolean)
{
    ASSERT(boolean);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedBoolean);
    animatedType->m_data.boolean = boolean.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createColor(std::unique_ptr<Color> color)
{
    ASSERT(color);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedColor);
    animatedType->m_data.color = color.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createEnumeration(std::unique_ptr<unsigned> enumeration)
{
    ASSERT(enumeration);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedEnumeration);
    animatedType->m_data.enumeration = enumeration.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createInteger(std::unique_ptr<int> integer)
{
    ASSERT(integer);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedInteger);
    animatedType->m_data.integer = integer.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createIntegerOptionalInteger(std::unique_ptr<std::pair<int, int>> integerOptionalInteger)
{
    ASSERT(integerOptionalInteger);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedIntegerOptionalInteger);
    animatedType->m_data.integerOptionalInteger = integerOptionalInteger.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createLength(std::unique_ptr<SVGLengthValue> length)
{
    ASSERT(length);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedLength);
    animatedType->m_data.length = length.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createLengthList(std::unique_ptr<SVGLengthListValues> lengthList)
{
    ASSERT(lengthList);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedLengthList);
    animatedType->m_data.lengthList = lengthList.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createNumber(std::unique_ptr<float> number)
{
    ASSERT(number);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedNumber);
    animatedType->m_data.number = number.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createNumberList(std::unique_ptr<SVGNumberListValues> numberList)
{
    ASSERT(numberList);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedNumberList);
    animatedType->m_data.numberList = numberList.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createNumberOptionalNumber(std::unique_ptr<std::pair<float, float>> numberOptionalNumber)
{
    ASSERT(numberOptionalNumber);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedNumberOptionalNumber);
    animatedType->m_data.numberOptionalNumber = numberOptionalNumber.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createPath(std::unique_ptr<SVGPathByteStream> path)
{
    ASSERT(path);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedPath);
    animatedType->m_data.path = path.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createPointList(std::unique_ptr<SVGPointListValues> pointList)
{
    ASSERT(pointList);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedPoints);
    animatedType->m_data.pointList = pointList.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createPreserveAspectRatio(std::unique_ptr<SVGPreserveAspectRatioValue> preserveAspectRatio)
{
    ASSERT(preserveAspectRatio);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedPreserveAspectRatio);
    animatedType->m_data.preserveAspectRatio = preserveAspectRatio.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createRect(std::unique_ptr<FloatRect> rect)
{
    ASSERT(rect);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedRect);
    animatedType->m_data.rect = rect.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createString(std::unique_ptr<String> string)
{
    ASSERT(string);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedString);
    animatedType->m_data.string = string.release();
    return animatedType;
}

std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createTransformList(std::unique_ptr<SVGTransformListValues> transformList)
{
    ASSERT(transformList);
    auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedTransformList);
    animatedType->m_data.transformList = transformList.release();
    return animatedType;
}

String SVGAnimatedType::valueAsString()
{
    switch (m_type) {
    case AnimatedColor:
        ASSERT(m_data.color);
        return m_data.color->serialized();
    case AnimatedLength:
        ASSERT(m_data.length);
        return m_data.length->valueAsString();
    case AnimatedLengthList:
        ASSERT(m_data.lengthList);
        return m_data.lengthList->valueAsString();
    case AnimatedNumber:
        ASSERT(m_data.number);
        return String::number(*m_data.number);
    case AnimatedRect:
        ASSERT(m_data.rect);
        return String::number(m_data.rect->x()) + ' ' + String::number(m_data.rect->y()) + ' '
             + String::number(m_data.rect->width()) + ' ' + String::number(m_data.rect->height());
    case AnimatedString:
        ASSERT(m_data.string);
        return *m_data.string;

    // These types don't appear in the table in SVGElement::cssPropertyToTypeMap() and thus don't need valueAsString() support.
    case AnimatedAngle:
    case AnimatedBoolean:
    case AnimatedEnumeration:
    case AnimatedInteger:
    case AnimatedIntegerOptionalInteger:
    case AnimatedNumberList:
    case AnimatedNumberOptionalNumber:
    case AnimatedPath:
    case AnimatedPoints:
    case AnimatedPreserveAspectRatio:
    case AnimatedTransformList:
    case AnimatedUnknown:
        // Only SVG DOM animations use these property types - that means valueAsString() is never used for those.
        ASSERT_NOT_REACHED();
        break;
    }
    ASSERT_NOT_REACHED();
    return String();
}

bool SVGAnimatedType::setValueAsString(const QualifiedName& attrName, const String& value)
{
    switch (m_type) {
    case AnimatedColor:
        ASSERT(m_data.color);
        *m_data.color = CSSParser::parseColor(value.stripWhiteSpace());
        return true;
    case AnimatedLength:
        ASSERT(m_data.length);
        return !m_data.length->setValueAsString(value, SVGLengthValue::lengthModeForAnimatedLengthAttribute(attrName)).hasException();
    case AnimatedLengthList:
        ASSERT(m_data.lengthList);
        m_data.lengthList->parse(value, SVGLengthValue::lengthModeForAnimatedLengthAttribute(attrName));
        return true;
    case AnimatedNumber:
        ASSERT(m_data.number);
        parseNumberFromString(value, *m_data.number);
        return true;
    case AnimatedRect:
        ASSERT(m_data.rect);
        parseRect(value, *m_data.rect);
        return true;
    case AnimatedString:
        ASSERT(m_data.string);
        *m_data.string = value;
        return true;

    // These types don't appear in the table in SVGElement::cssPropertyToTypeMap() and thus don't need setValueAsString() support. 
    case AnimatedAngle:
    case AnimatedBoolean:
    case AnimatedEnumeration:
    case AnimatedInteger:
    case AnimatedIntegerOptionalInteger:
    case AnimatedNumberList:
    case AnimatedNumberOptionalNumber:
    case AnimatedPath:
    case AnimatedPoints:
    case AnimatedPreserveAspectRatio:
    case AnimatedTransformList:
    case AnimatedUnknown:
        // Only SVG DOM animations use these property types - that means setValueAsString() is never used for those.
        ASSERT_NOT_REACHED();
        break;
    }
    return true;
}

bool SVGAnimatedType::supportsAnimVal(AnimatedPropertyType type)
{
    // AnimatedColor is only used for CSS property animations.
    return type != AnimatedUnknown && type != AnimatedColor;
}

} // namespace WebCore
native



/*
 * Copyright (C) Research In Motion Limited 2011. All rights reserved.
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public


#pragma once

#include "SVGValue.h"
#include "FloatRect.h"
#include "SVGAngleValue.h"
#include "SVGLengthListValues.h"
#include "SVGLengthValue.h"
#include "SVGNumberListValues.h"
#include "SVGPointListValues.h"
#include "SVGPreserveAspectRatioValue.h"
#include "SVGPropertyInfo.h"
#include "SVGTransformListValues.h"

namespace WebCore {

struct SVGAnimatedType {
    template<typename PropertyType>
    SVGAnimatedType(PropertyType&& property)
        : values { SVGValue::create(WTFMove(property)) }
public:
    SVGAnimatedType(AnimatedPropertyType);
    virtual ~SVGAnimatedType();

    static std::unique_ptr<SVGAnimatedType> createAngleAndEnumeration(std::unique_ptr<std::pair<SVGAngleValue, unsigned>>);
    static std::unique_ptr<SVGAnimatedType> createBoolean(std::unique_ptr<bool>);
    static std::unique_ptr<SVGAnimatedType> createColor(std::unique_ptr<Color>);
    static std::unique_ptr<SVGAnimatedType> createEnumeration(std::unique_ptr<unsigned>);
    static std::unique_ptr<SVGAnimatedType> createInteger(std::unique_ptr<int>);
    static std::unique_ptr<SVGAnimatedType> createIntegerOptionalInteger(std::unique_ptr<std::pair<int, int>>);
    static std::unique_ptr<SVGAnimatedType> createLength(std::unique_ptr<SVGLengthValue>);
    static std::unique_ptr<SVGAnimatedType> createLengthList(std::unique_ptr<SVGLengthListValues>);
    static std::unique_ptr<SVGAnimatedType> createNumber(std::unique_ptr<float>);
    static std::unique_ptr<SVGAnimatedType> createNumberList(std::unique_ptr<SVGNumberListValues>);
    static std::unique_ptr<SVGAnimatedType> createNumberOptionalNumber(std::unique_ptr<std::pair<float, float>>);
    static std::unique_ptr<SVGAnimatedType> createPath(std::unique_ptr<SVGPathByteStream>);
    static std::unique_ptr<SVGAnimatedType> createPointList(std::unique_ptr<SVGPointListValues>);
    static std::unique_ptr<SVGAnimatedType> createPreserveAspectRatio(std::unique_ptr<SVGPreserveAspectRatioValue>);
    static std::unique_ptr<SVGAnimatedType> createRect(std::unique_ptr<FloatRect>);
    static std::unique_ptr<SVGAnimatedType> createString(std::unique_ptr<String>);
    static std::unique_ptr<SVGAnimatedType> createTransformList(std::unique_ptr<SVGTransformListValues>);
    static bool supportsAnimVal(AnimatedPropertyType);

    AnimatedPropertyType type() const { return m_type; }

    // Non-mutable accessors.
    const std::pair<SVGAngleValue, unsigned>& angleAndEnumeration() const
    {
        ASSERT(m_type == AnimatedAngle);
        return *m_data.angleAndEnumeration;
    }

    const bool& boolean() const
    {
        ASSERT(m_type == AnimatedBoolean);
        return *m_data.boolean;
    }

    const Color& color() const
    {
        ASSERT(m_type == AnimatedColor);
        return *m_data.color;
    }

    const unsigned& enumeration() const
    {
        ASSERT(m_type == AnimatedEnumeration);
        return *m_data.enumeration;
    }

    const int& integer() const
    {
        ASSERT(m_type == AnimatedInteger);
        return *m_data.integer;
    }

    const std::pair<int, int>& integerOptionalInteger() const
    {
        ASSERT(m_type == AnimatedIntegerOptionalInteger);
        return *m_data.integerOptionalInteger;
    }

    const SVGLengthValue& length() const
    {
        ASSERT(m_type == AnimatedLength);
        return *m_data.length;
    }

    const SVGLengthListValues& lengthList() const
    {
        ASSERT(m_type == AnimatedLengthList);
        return *m_data.lengthList;
    }

    const float& number() const
    {
        ASSERT(m_type == AnimatedNumber);
        return *m_data.number;
    }

    const SVGNumberListValues& numberList() const
    {
        ASSERT(m_type == AnimatedNumberList);
        return *m_data.numberList;
    }

    SVGAnimatedType(RefPtr<SVGValue>&& value)
        : values { WTFMove(value) }
    {
        ASSERT(m_type == AnimatedNumberOptionalNumber);
        return *m_data.numberOptionalNumber;
    }

    template<typename PropertyType1, typename PropertyType2>
    SVGAnimatedType(std::pair<PropertyType1, PropertyType2>&& properties)
        : values { SVGValue::create(properties.first), SVGValue::create(properties.second) }
    {
        ASSERT(m_type == AnimatedPath);
        return m_data.path;
    }

    SVGAnimatedType(RefPtr<SVGValue>&& value1, RefPtr<SVGValue>&& value2)
        : values { WTFMove(value1), WTFMove(value2) }
    {
        ASSERT(m_type == AnimatedPoints);
        return *m_data.pointList;
    }

    template<typename PropertyType>
    static std::unique_ptr<SVGAnimatedType> create()
    {
        return std::make_unique<SVGAnimatedType>(SVGPropertyTraits<PropertyType>::initialValue());
        return *m_data.preserveAspectRatio;
    }

    template<typename PropertyType>
    static std::unique_ptr<SVGAnimatedType> create(PropertyType&& property)
    {
        return std::make_unique<SVGAnimatedType>(WTFMove(property));
        return *m_data.rect;
    }

    static std::unique_ptr<SVGAnimatedType> create(RefPtr<SVGValue>&& value)
    {
        return std::make_unique<SVGAnimatedType>(WTFMove(value));
        return *m_data.string;
    }

    template<typename PropertyType1, typename PropertyType2>
    static std::unique_ptr<SVGAnimatedType> create()
    {
        return std::make_unique<SVGAnimatedType>(SVGPropertyTraits<std::pair<PropertyType1, PropertyType2>>::initialValue());
        return *m_data.transformList;
    }

    template<typename PropertyType1, typename PropertyType2>
    static std::unique_ptr<SVGAnimatedType> create(std::pair<PropertyType1, PropertyType2>&& properties)
    {
        return std::make_unique<SVGAnimatedType>(WTFMove(properties));
        return *m_data.angleAndEnumeration;
    }

    static std::unique_ptr<SVGAnimatedType> create(RefPtr<SVGValue>&& value1, RefPtr<SVGValue>&& value2)
    {
        return std::make_unique<SVGAnimatedType>(WTFMove(value1), WTFMove(value2));
        return *m_data.boolean;
    }

    AnimatedPropertyType type() const
    {
        ASSERT(values[0]);
        AnimatedPropertyType animatedType1 = valueAnimatedType(*values[0]);
        AnimatedPropertyType animatedType2 = values[1] ? valueAnimatedType(*values[1]) : AnimatedUnknown;

    unsigned& enumeration()
    {
        ASSERT(m_type == AnimatedEnumeration);
        return *m_data.enumeration;
    }

    int& integer()
    {
        ASSERT(m_type == AnimatedInteger);
        return *m_data.integer;
    }

    std::pair<int, int>& integerOptionalInteger()
    {
        ASSERT(m_type == AnimatedIntegerOptionalInteger);
        return *m_data.integerOptionalInteger;
    }

    SVGLengthValue& length()
    {
        ASSERT(m_type == AnimatedLength);
        return *m_data.length;
    }

    SVGLengthListValues& lengthList()
    {
        ASSERT(m_type == AnimatedLengthList);
        return *m_data.lengthList;
    }

        if (animatedType1 == AnimatedAngle) {
            ASSERT(animatedType2 == AnimatedEnumeration);
            return AnimatedAngle;
        }
    }

        if (animatedType1 == AnimatedInteger && animatedType2 == AnimatedInteger)
            return AnimatedIntegerOptionalInteger;
        ASSERT(m_type == AnimatedNumberList);
        return *m_data.numberList;
    }

        if (animatedType1 == AnimatedNumber && animatedType2 == AnimatedNumber)
            return AnimatedNumberOptionalNumber;
        ASSERT(m_type == AnimatedNumberOptionalNumber);
        return *m_data.numberOptionalNumber;
    }

        ASSERT(animatedType2 == AnimatedUnknown);
        return animatedType1;
        ASSERT(m_type == AnimatedPath);
        return m_data.path;
    }

    String valueAsString() const
    {
        ASSERT(values[0] && !values[1]);
        return values[0]->toString();
    }

    bool setValueAsString(const QualifiedName& attrName, const String& string)
    {
        ASSERT(values[0] && !values[1]);
        return values[0]->parse(attrName, string);
    }

    static bool supportsAnimVal(AnimatedPropertyType type)
    {
        // AnimatedColor is only used for CSS property animations.
        return type != AnimatedUnknown && type != AnimatedColor;
    }

    static AnimatedPropertyType valueAnimatedType(const SVGValue& value)
    {
        return WTF::visit(WTF::makeVisitor(
            [](const SVGAngleValue&)                { return AnimatedAngle; },
            [](const bool&)                         { return AnimatedBoolean; },
            [](const Color&)                        { return AnimatedColor; },
            [](const unsigned&)                     { return AnimatedEnumeration; },
            [](const int&)                          { return AnimatedInteger; },
            [](const SVGLengthValue&)               { return AnimatedLength; },
            [](const SVGLengthListValues&)          { return AnimatedLengthList; },
            [](const float)                         { return AnimatedNumber; },
            [](const SVGNumberListValues&)          { return AnimatedNumberList; },
            [](const SVGPathByteStream&)            { return AnimatedPath; },
            [](const SVGPreserveAspectRatioValue&)  { return AnimatedPreserveAspectRatio; },
            [](const SVGPointListValues&)           { return AnimatedPoints; },
            [](const FloatRect&)                    { return AnimatedRect; },
            [](const String&)                       { return AnimatedString; },
            [](const SVGTransformListValues&)       { return AnimatedTransformList; },
            [](const auto&)                         { return AnimatedUnknown; }
        ), static_cast<const SVGValueVariant&>(value));
    }

    RefPtr<SVGValue> values[2];
    {
        ASSERT(m_type == AnimatedTransformList);
        return *m_data.transformList;
    }

    String valueAsString();
    bool setValueAsString(const QualifiedName&, const String&);

private:
    AnimatedPropertyType m_type;

    union DataUnion {
        DataUnion()
            : length(nullptr)
        {
        }

        std::pair<SVGAngleValue, unsigned>* angleAndEnumeration;
        bool* boolean;
        Color* color;
        unsigned* enumeration;
        int* integer;
        std::pair<int, int>* integerOptionalInteger;
        SVGLengthValue* length;
        SVGLengthListValues* lengthList;
        float* number;
        SVGNumberListValues* numberList;
        std::pair<float, float>* numberOptionalNumber;
        SVGPathByteStream* path;
        SVGPreserveAspectRatioValue* preserveAspectRatio;
        SVGPointListValues* pointList;
        FloatRect* rect;
        String* string;
        SVGTransformListValues* transformList;
    } m_data;
};

} // namespace WebCore



/*
 * Copyright (C) Research In Motion Limited 2011-2012. All rights reserved.
 * Copyright (C) 2013 Samsung Electronics. All rights reserved.
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public


    // Helpers for animators that operate on single types, eg. just one SVGAnimatedInteger.
    template<typename AnimValType>
    std::unique_ptr<SVGAnimatedType> constructFromBaseValue(const SVGElementAnimatedPropertyList& animatedTypes)
    {
        ASSERT(animatedTypes[0].properties.size() == 1);
        const AnimValType* animatedType = castAnimatedPropertyToActualType<AnimValType>(animatedTypes[0].properties[0].get());

        RefPtr<SVGValue> animatedValue = SVGValue::create(*animatedType->currentBaseValue());
        executeAction<AnimValType>(StartAnimationAction, animatedTypes, 0, animatedValue);
        return SVGAnimatedType::create(WTFMove(animatedValue));
    }

    template<typename AnimValType>
    void resetFromBaseValue(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
    {
        ASSERT(animatedTypes[0].properties.size() == 1);
        ASSERT(type.type() == m_type);
        AnimValType* animatedType = castAnimatedPropertyToActualType<AnimValType>(animatedTypes[0].properties[0].get());
        animatedType->synchronizeWrappersIfNeeded();

        RefPtr<SVGValue> baseValue = animatedType->currentBaseValue();
        RefPtr<SVGValue> animatedValue = type.values[0];
        static_cast<typename AnimValType::ContentType&>(*animatedValue) = static_cast<typename AnimValType::ContentType&>(*baseValue);
        executeAction<AnimValType>(StartAnimationAction, animatedTypes, 0, animatedValue);
    }

    template<typename AnimValType>


    // Helpers for animators that operate on pair types, eg. a pair of SVGAnimatedIntegers.
    template<typename AnimValType1, typename AnimValType2>
    std::unique_ptr<SVGAnimatedType> constructFromBaseValues(const SVGElementAnimatedPropertyList& animatedTypes)
    {
        ASSERT(animatedTypes[0].properties.size() == 2);
        const AnimValType1* firstAnimatedType = castAnimatedPropertyToActualType<AnimValType1>(animatedTypes[0].properties[0].get());
        const AnimValType2* secondAnimatedType = castAnimatedPropertyToActualType<AnimValType2>(animatedTypes[0].properties[1].get());

        RefPtr<SVGValue> firstAnimatedValue = SVGValue::create(*firstAnimatedType->currentBaseValue());
        RefPtr<SVGValue> secondAnimatedValue = SVGValue::create(*secondAnimatedType->currentBaseValue());
        executeAction<AnimValType1>(StartAnimationAction, animatedTypes, 0, firstAnimatedValue);
        executeAction<AnimValType2>(StartAnimationAction, animatedTypes, 1, secondAnimatedValue);
        return SVGAnimatedType::create(WTFMove(firstAnimatedValue), WTFMove(secondAnimatedValue));
    }

    template<typename AnimValType1, typename AnimValType2>
    void resetFromBaseValues(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
    {
        ASSERT(animatedTypes[0].properties.size() == 2);
        ASSERT(type.type() == m_type);
        AnimValType1* firstAnimatedType = castAnimatedPropertyToActualType<AnimValType1>(animatedTypes[0].properties[0].get());
        AnimValType2* secondAnimatedType = castAnimatedPropertyToActualType<AnimValType2>(animatedTypes[0].properties[1].get());
        firstAnimatedType->synchronizeWrappersIfNeeded();
        secondAnimatedType->synchronizeWrappersIfNeeded();

        RefPtr<SVGValue> firstBaseValue = firstAnimatedType->currentBaseValue();
        RefPtr<SVGValue> firstAnimatedValue = type.values[0];
        static_cast<typename AnimValType1::ContentType&>(*firstAnimatedValue) = static_cast<typename AnimValType1::ContentType&>(*firstBaseValue);
        executeAction<AnimValType1>(StartAnimationAction, animatedTypes, 0, firstAnimatedValue);

        RefPtr<SVGValue> secondBaseValue = secondAnimatedType->currentBaseValue();
        RefPtr<SVGValue> secondAnimatedValue = type.values[1];
        static_cast<typename AnimValType2::ContentType&>(*secondAnimatedValue) = static_cast<typename AnimValType2::ContentType&>(*secondBaseValue);
        executeAction<AnimValType2>(StartAnimationAction, animatedTypes, 1, secondAnimatedValue);
    }

    template<typename AnimValType1, typename AnimValType2>

    };

    template<typename AnimValType>
    void executeAction(AnimationAction action, const SVGElementAnimatedPropertyList& animatedTypes, unsigned whichProperty, RefPtr<SVGValue> animatedValue = nullptr)
    {
        // FIXME: Can't use SVGElement::InstanceUpdateBlocker because of circular header dependency. Would be nice to untangle this.
        setInstanceUpdatesBlocked(*animatedTypes[0].element, true);

        for (auto& animatedType : animatedTypes) {
            ASSERT_WITH_SECURITY_IMPLICATION(whichProperty < animatedType.properties.size());
            AnimValType* animatedProperty = castAnimatedPropertyToActualType<AnimValType>(animatedType.properties[whichProperty].get());

            switch (action) {
            case StartAnimationAction:
                ASSERT(animatedValue);
                if (!animatedProperty->isAnimating())
                    animatedProperty->animationStarted(animatedValue);
                break;
            case StopAnimationAction:
                ASSERT(!animatedValue);
                if (animatedProperty->isAnimating())
                    animatedProperty->animationEnded();
                break;
            case AnimValWillChangeAction:
                ASSERT(!animatedValue);
                animatedProperty->animValWillChange();
                break;
            case AnimValDidChangeAction:
                ASSERT(!animatedValue);
                animatedProperty->animValDidChange();
                break;
            }
        }

Lines 33-39 Source/WebCore/svg/SVGAnimationElement.h_sec1
- Source/WebCore/svg/SVGAnimationElement.h -1 / +1 lines
33	namespace WebCore {	33	namespace WebCore {
34		34
35	class ConditionEventListener;	35	class ConditionEventListener;
36	class SVGAnimatedType;	36	struct SVGAnimatedType;
37	class TimeContainer;	37	class TimeContainer;
38		38
39	enum AnimationMode {	39	enum AnimationMode {

Lines 137-143 ComponentTransferFunction SVGComponentTr Source/WebCore/svg/SVGComponentTransferFunctionElement.cpp_sec1
- Source/WebCore/svg/SVGComponentTransferFunctionElement.cpp -1 / +1 lines
137	func.amplitude = amplitude();	137	func.amplitude = amplitude();
138	func.exponent = exponent();	138	func.exponent = exponent();
139	func.offset = offset();	139	func.offset = offset();
140	func.tableValues = tableValues();	140	func.tableValues = tableValues().properties();
141	return func;	141	return func;
142	}	142	}
143		143




inline SVGCursorElement::SVGCursorElement(const QualifiedName& tagName, Document& document)
    : SVGElement(tagName, document)
    , m_x(SVGLengthValue(LengthModeWidth))
    , m_y(SVGLengthValue(LengthModeHeight))
{
    ASSERT(hasTagName(SVGNames::cursorTag));
    registerAnimatedPropertiesForSVGCursorElement();




inline SVGEllipseElement::SVGEllipseElement(const QualifiedName& tagName, Document& document)
    : SVGGraphicsElement(tagName, document)
    , m_cx(SVGLengthValue(LengthModeWidth))
    , m_cy(SVGLengthValue(LengthModeHeight))
    , m_rx(SVGLengthValue(LengthModeWidth))
    , m_ry(SVGLengthValue(LengthModeHeight))
{
    ASSERT(hasTagName(SVGNames::ellipseTag));
    registerAnimatedPropertiesForSVGEllipseElement();



    if (attrName == SVGNames::typeAttr)
        return colorMatrix->setType(type());
    if (attrName == SVGNames::valuesAttr)
        return colorMatrix->setValues(values().properties());

    ASSERT_NOT_REACHED();
    return false;

            break;
        }
    } else {
        filterValues = values().properties();
        unsigned size = filterValues.size();

        if ((filterType == FECOLORMATRIX_TYPE_MATRIX && size != 20)



        return nullptr;
    if (!hasAttribute(SVGNames::divisorAttr)) {
        for (int i = 0; i < kernelMatrixSize; ++i)
            divisorValue += kernelMatrix.propertyAt(i);
        if (!divisorValue)
            divisorValue = 1;
    }

    auto effect = FEConvolveMatrix::create(filter, IntSize(orderXValue, orderYValue), divisorValue, bias(), IntPoint(targetXValue, targetYValue), edgeMode(), FloatPoint(kernelUnitLengthXValue, kernelUnitLengthYValue), preserveAlpha(), kernelMatrix.properties());
    effect->inputEffects().append(input1);
    return WTFMove(effect);
}



    : SVGElement(tagName, document)
    , m_filterUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
    , m_primitiveUnits(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
    , m_x(SVGLengthValue(LengthModeWidth, "-10%"))
    , m_y(SVGLengthValue(LengthModeHeight, "-10%"))
    , m_width(SVGLengthValue(LengthModeWidth, "120%"))
    , m_height(SVGLengthValue(LengthModeHeight, "120%"))
{
    // Spec: If the x/y attribute is not specified, the effect is as if a value of "-10%" were specified.
    // Spec: If the width/height attribute is not specified, the effect is as if a value of "120%" were specified.




SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes(const QualifiedName& tagName, Document& document)
    : SVGElement(tagName, document)
    , m_x(SVGLengthValue(LengthModeWidth, "0%"))
    , m_y(SVGLengthValue(LengthModeHeight, "0%"))
    , m_width(SVGLengthValue(LengthModeWidth, "100%"))
    , m_height(SVGLengthValue(LengthModeHeight, "100%"))
{
    // Spec: If the x/y attribute is not specified, the effect is as if a value of "0%" were specified.
    // Spec: If the width/height attribute is not specified, the effect is as if a value of "100%" were specified.




inline SVGForeignObjectElement::SVGForeignObjectElement(const QualifiedName& tagName, Document& document)
    : SVGGraphicsElement(tagName, document)
    , m_x(SVGLengthValue(LengthModeWidth))
    , m_y(SVGLengthValue(LengthModeHeight))
    , m_width(SVGLengthValue(LengthModeWidth))
    , m_height(SVGLengthValue(LengthModeHeight))
{
    ASSERT(hasTagName(SVGNames::foreignObjectTag));
    registerAnimatedPropertiesForSVGForeignObjectElement();




inline SVGImageElement::SVGImageElement(const QualifiedName& tagName, Document& document)
    : SVGGraphicsElement(tagName, document)
    , m_x(SVGLengthValue(LengthModeWidth))
    , m_y(SVGLengthValue(LengthModeHeight))
    , m_width(SVGLengthValue(LengthModeWidth))
    , m_height(SVGLengthValue(LengthModeHeight))
    , m_imageLoader(*this)
{
    registerAnimatedPropertiesForSVGImageElement();



        SVG_LENGTHTYPE_PC = LengthTypePC
    };

    static Ref<SVGLength> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
    {
        return adoptRef(*new SVGLength(animatedProperty, role, value));
    }

        return adoptRef(*new SVGLength(initialValue));
    }

    static Ref<SVGLength> create(const SVGLengthValue* initialValue)
    {
        return adoptRef(*new SVGLength(initialValue));
    }

    template<typename T> static ExceptionOr<Ref<SVGLength>> create(ExceptionOr<T>&& initialValue)
    {
        if (initialValue.hasException())

    }

private:
    SVGLength(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : SVGPropertyTearOff<SVGLengthValue>(&animatedProperty, role, value)
    {
    }

        : SVGPropertyTearOff<SVGLengthValue>(initialValue)
    {
    }

    explicit SVGLength(const SVGLengthValue* initialValue)
        : SVGPropertyTearOff<SVGLengthValue>(initialValue)
    {
    }
};

} // namespace WebCore



    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<SVGLengthListValues>;
    using ListWrapperCache = AnimatedListPropertyTearOff::ListWrapperCache;

    static Ref<SVGLengthList> create(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
    {
        return adoptRef(*new SVGLengthList(animatedProperty, role, values, wrappers));
    }

private:
    SVGLengthList(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
        : SVGListPropertyTearOff<SVGLengthListValues>(animatedProperty, role, values, wrappers)
    {
    }



#include "SVGLengthListValues.h"

#include "SVGParserUtilities.h"
#include "SVGValue.h"
#include <wtf/text/StringBuilder.h>

namespace WebCore {

            return;
        if (length.setValueAsString(valueString).hasException())
            return;
        append(SVGValue::create<SVGLengthValue>(length));
        skipOptionalSVGSpacesOrDelimiter(ptr, end);
    }
}

        if (i > 0)
            builder.append(' ');

        builder.append(propertyAt(i).valueAsString());
    }

    return builder.toString();



/*
 * Copyright (C) 2004, 2005, 2006, 2008 Nikolas Zimmermann <zimmermann@kde.org>
 * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public

#pragma once

#include "SVGLengthValue.h"
#include "SVGListValues.h"

namespace WebCore {

class SVGLength;
class SVGLengthList;

class SVGLengthListValues final : public SVGListValues<SVGLengthValue> {
public:
    void parse(const String& value, SVGLengthMode);
    String valueAsString() const;
};

template<>
struct SVGPropertyTraits<SVGLengthListValues> {
    static SVGLengthListValues initialValue() { return  { }; }
    static SVGLengthListValues fromString(const String& string, SVGLengthMode lengthMode)
    {
        SVGLengthListValues list;
        list.parse(string, lengthMode);
        return list;
    }
    static std::optional<SVGLengthListValues> parse(const QualifiedName& attrName, const String& string)
    {
        SVGLengthListValues list;
        list.parse(string, SVGLengthValue::lengthModeForAnimatedLengthAttribute(attrName));
        return list;
    }
    static String toString(const SVGLengthListValues& list) { return list.valueAsString(); }
    
    using ListItemType = SVGLengthValue;
    using ListItemTearOff = SVGLength;
    using ListPropertyTearOff = SVGLengthList;

    static SVGLengthListValues initialValue() { return  { }; }
    static String toString(const SVGLengthListValues& type) { return type.valueAsString(); }
};

} // namespace WebCore

Lines 147-153 private: Source/WebCore/svg/SVGLengthValue.h_sec1
- Source/WebCore/svg/SVGLengthValue.h -1 / +7 lines
147		147
148	template<> struct SVGPropertyTraits<SVGLengthValue> {	148	template<> struct SVGPropertyTraits<SVGLengthValue> {
149	static SVGLengthValue initialValue() { return { }; }	149	static SVGLengthValue initialValue() { return { }; }
150	static String toString(const SVGLengthValue& type) { return type.valueAsString(); }	150	static std::optional<SVGLengthValue> parse(const QualifiedName& attrName, const String& string)
		151	{
		152	SVGLengthValue length;
		153	length.setValueAsString(string, SVGLengthValue::lengthModeForAnimatedLengthAttribute(attrName)).hasException();
		154	return length;
		155	}
		156	static String toString(const SVGLengthValue& length) { return length.valueAsString(); }
151	};	157	};
152		158
153	WTF::TextStream& operator<<(WTF::TextStream&, const SVGLengthValue&);	159	WTF::TextStream& operator<<(WTF::TextStream&, const SVGLengthValue&);




inline SVGLinearGradientElement::SVGLinearGradientElement(const QualifiedName& tagName, Document& document)
    : SVGGradientElement(tagName, document)
    , m_x1(SVGLengthValue(LengthModeWidth))
    , m_y1(SVGLengthValue(LengthModeHeight))
    , m_x2(SVGLengthValue(LengthModeWidth, "100%"))
    , m_y2(SVGLengthValue(LengthModeHeight))
{
    // Spec: If the x2 attribute is not specified, the effect is as if a value of "100%" were specified.
    ASSERT(hasTagName(SVGNames::linearGradientTag));



/*
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "SVGListValues.h"

#include "SVGValue.h"

namespace WebCore {

template <typename PropertyType>
void SVGListValues<PropertyType>::resize(size_t newSize)
{
    size_t index = size();
    Vector<RefPtr<SVGValue>>::resize(newSize);
    for (; index < newSize; ++index)
        at(index) = SVGValue::create<PropertyType>();
}

template <typename PropertyType>
Vector<RefPtr<SVGValue>> SVGListValues<PropertyType>::deepCopy() const
{
    Vector<RefPtr<SVGValue>> values;
    for (const RefPtr<SVGValue>& value : *this)
        values.append(SVGValue::create(*value));
    return values;
}

// Template function explicit instantiation.
template void SVGListValues<float>::resize(size_t);
template void SVGListValues<FloatPoint>::resize(size_t);
template void SVGListValues<SVGLengthValue>::resize(size_t);
template void SVGListValues<SVGTransformValue>::resize(size_t);

template Vector<RefPtr<SVGValue>> SVGListValues<float>::deepCopy() const;
template Vector<RefPtr<SVGValue>> SVGListValues<String>::deepCopy() const;
template Vector<RefPtr<SVGValue>> SVGListValues<FloatPoint>::deepCopy() const;
template Vector<RefPtr<SVGValue>> SVGListValues<SVGLengthValue>::deepCopy() const;
template Vector<RefPtr<SVGValue>> SVGListValues<RefPtr<SVGPathSeg>>::deepCopy() const;
template Vector<RefPtr<SVGValue>> SVGListValues<SVGTransformValue>::deepCopy() const;

}



/*
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include <wtf/Vector.h>

namespace WebCore {
    
class SVGValue;
    
template<typename PropertyType>
class SVGListValues : public Vector<RefPtr<SVGValue>> {
public:
    SVGListValues() = default;

    SVGListValues(const SVGListValues& other)
        : Vector<RefPtr<SVGValue>>(other.deepCopy())
    {
    }

    void resize(size_t);
    Vector<RefPtr<SVGValue>> deepCopy() const;

    const PropertyType& propertyAt(size_t index) const { return static_cast<PropertyType&>(*at(index)); }
    PropertyType& propertyAt(size_t index) { return static_cast<PropertyType&>(*at(index)); }

    const PropertyType& firstProperty() const { return propertyAt(0); }
    PropertyType& firstProperty() { return propertyAt(0); }

    const PropertyType& lastProperty() const { return propertyAt(size() - 1); }
    PropertyType& lastProperty() { return propertyAt(size() - 1); }

    Vector<PropertyType> properties() const
    {
        Vector<PropertyType> properties;
        for (const auto& value : *this)
            properties.append(static_cast<PropertyType&>(*value));
        return properties;
    }
};

}




inline SVGMarkerElement::SVGMarkerElement(const QualifiedName& tagName, Document& document)
    : SVGElement(tagName, document)
    , m_refX(SVGLengthValue(LengthModeWidth))
    , m_refY(SVGLengthValue(LengthModeHeight))
    , m_markerWidth(SVGLengthValue(LengthModeWidth, "3"))
    , m_markerHeight(SVGLengthValue(LengthModeHeight, "3"))
    , m_markerUnits(SVGMarkerUnitsStrokeWidth)
    , m_orientType(SVGMarkerOrientAngle)
{

    static NeverDestroyed<AtomicString> autoStartReverseString("auto-start-reverse", AtomicString::ConstructFromLiteral);

    // If orient is not auto or auto-start-reverse, the previous call to synchronizeOrientAngle already set the orientAttr to the right angle.
    if (static_cast<SVGMarkerOrientType&>(*ownerType.m_orientType.value) == SVGMarkerOrientAuto) {
        ownerType.m_orientType.synchronize(&ownerType, orientTypePropertyInfo()->attributeName, autoString);
        return;
    }

    if (static_cast<SVGMarkerOrientType&>(*ownerType.m_orientType.value) == SVGMarkerOrientAutoStartReverse)
        ownerType.m_orientType.synchronize(&ownerType, orientTypePropertyInfo()->attributeName, autoStartReverseString);
}


{
    if (auto wrapper = SVGAnimatedProperty::lookupWrapper<UseOwnerType, SVGAnimatedEnumeration>(this, orientTypePropertyInfo())) {
        if (wrapper->isAnimating()) {
            ASSERT(static_cast<SVGMarkerOrientType&>(*wrapper->currentAnimatedValue()) < SVGMarkerOrientMax);
            return static_cast<SVGMarkerOrientType&>(*wrapper->currentAnimatedValue());
        }
    }
    return static_cast<SVGMarkerOrientType&>(*m_orientType.value);
}

Ref<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>> SVGMarkerElement::orientTypeAnimated()



#include "SVGElement.h"
#include "SVGExternalResourcesRequired.h"
#include "SVGFitToViewBox.h"
#include "SVGMarkerTypes.h"

namespace WebCore {

enum SVGMarkerUnitsType {
    SVGMarkerUnitsUnknown = 0,
    SVGMarkerUnitsUserSpaceOnUse,
    SVGMarkerUnitsStrokeWidth
};

enum SVGMarkerOrientType {
    SVGMarkerOrientUnknown = 0,
    SVGMarkerOrientAuto,
    SVGMarkerOrientAngle,
    SVGMarkerOrientAutoStartReverse,

    // Add new elements before here.
    SVGMarkerOrientMax
};

template<>
struct SVGPropertyTraits<SVGMarkerUnitsType> {
    static unsigned highestEnumValue() { return SVGMarkerUnitsStrokeWidth; }

    static String toString(SVGMarkerUnitsType type)
    {
        switch (type) {
        case SVGMarkerUnitsUnknown:
            return emptyString();
        case SVGMarkerUnitsUserSpaceOnUse:
            return ASCIILiteral("userSpaceOnUse");
        case SVGMarkerUnitsStrokeWidth:
            return ASCIILiteral("strokeWidth");
        }

        ASSERT_NOT_REACHED();
        return emptyString();
    }

    static SVGMarkerUnitsType fromString(const String& value)
    {
        if (value == "userSpaceOnUse")
            return SVGMarkerUnitsUserSpaceOnUse;
        if (value == "strokeWidth")
            return SVGMarkerUnitsStrokeWidth;
        return SVGMarkerUnitsUnknown;
    }
};

template<>
inline unsigned SVGIDLEnumLimits<SVGMarkerOrientType>::highestExposedEnumValue() { return SVGMarkerOrientAngle; }

template<> struct SVGPropertyTraits<SVGMarkerOrientType> {
    static unsigned highestEnumValue() { return SVGMarkerOrientAutoStartReverse; }

    // toString is not needed, synchronizeOrientType() handles this on its own.

    static SVGMarkerOrientType fromString(const String& value, SVGAngleValue& angle)
    {
        if (value == "auto")
            return SVGMarkerOrientAuto;
        if (value == "auto-start-reverse")
            return SVGMarkerOrientAutoStartReverse;
        auto setValueResult = angle.setValueAsString(value);
        if (setValueResult.hasException())
            return SVGMarkerOrientUnknown;
        return SVGMarkerOrientAngle;
    }
};

class SVGMarkerElement final : public SVGElement,
                               public SVGExternalResourcesRequired,
                               public SVGFitToViewBox {

    static void synchronizeOrientType(SVGElement* contextElement);
    static Ref<SVGAnimatedProperty> lookupOrCreateOrientTypeWrapper(SVGElement* contextElement);
    SVGMarkerOrientType& orientType() const;
    SVGMarkerOrientType& orientTypeBaseValue() const { return static_cast<SVGMarkerOrientType&>(*m_orientType.value); }
    void setOrientTypeBaseValue(const SVGMarkerOrientType& type) { orientTypeBaseValue() = type; }
    Ref<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>> orientTypeAnimated();

private:



/*
 * Copyright (C) 2017 Apple Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include "SVGPropertyTraits.h"

namespace WebCore {

enum SVGMarkerUnitsType {
    SVGMarkerUnitsUnknown = 0,
    SVGMarkerUnitsUserSpaceOnUse,
    SVGMarkerUnitsStrokeWidth
};

enum SVGMarkerOrientType {
    SVGMarkerOrientUnknown = 0,
    SVGMarkerOrientAuto,
    SVGMarkerOrientAngle,
    SVGMarkerOrientAutoStartReverse,
    
    // Add new elements before here.
    SVGMarkerOrientMax
};
    
template<>
struct SVGPropertyTraits<SVGMarkerUnitsType> {
    static unsigned highestEnumValue() { return SVGMarkerUnitsStrokeWidth; }
    static String toString(SVGMarkerUnitsType type)
    {
        switch (type) {
        case SVGMarkerUnitsUnknown:
            return emptyString();
        case SVGMarkerUnitsUserSpaceOnUse:
            return ASCIILiteral("userSpaceOnUse");
        case SVGMarkerUnitsStrokeWidth:
            return ASCIILiteral("strokeWidth");
        }
        
        ASSERT_NOT_REACHED();
        return emptyString();
    }
    static SVGMarkerUnitsType fromString(const String& value)
    {
        if (value == "userSpaceOnUse")
            return SVGMarkerUnitsUserSpaceOnUse;
        if (value == "strokeWidth")
            return SVGMarkerUnitsStrokeWidth;
        return SVGMarkerUnitsUnknown;
    }
};

template<>
struct SVGPropertyTraits<SVGMarkerOrientType> {
    static unsigned highestEnumValue() { return SVGMarkerOrientAutoStartReverse; }
    static SVGMarkerOrientType fromString(const String& value, SVGAngleValue& angle)
    {
        if (value == "auto")
            return SVGMarkerOrientAuto;
        if (value == "auto-start-reverse")
            return SVGMarkerOrientAutoStartReverse;
        auto setValueResult = angle.setValueAsString(value);
        if (setValueResult.hasException())
            return SVGMarkerOrientUnknown;
        return SVGMarkerOrientAngle;
    }
};

template<>
struct SVGPropertyTraits<std::pair<SVGAngleValue, unsigned>> {
    static std::pair<SVGAngleValue, unsigned> fromString(const String& string)
    {
        SVGAngleValue angle;
        SVGMarkerOrientType orientType = SVGPropertyTraits<SVGMarkerOrientType>::fromString(string, angle);
        if (orientType != SVGMarkerOrientAngle)
            angle = { };
        return std::pair<SVGAngleValue, unsigned>(angle, orientType);
    }
};

template<>
inline unsigned SVGIDLEnumLimits<SVGMarkerOrientType>::highestExposedEnumValue() { return SVGMarkerOrientAngle; }

} // namespace WebCore



    : SVGElement(tagName, document)
    , m_maskUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
    , m_maskContentUnits(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
    , m_x(SVGLengthValue(LengthModeWidth, "-10%"))
    , m_y(SVGLengthValue(LengthModeHeight, "-10%"))
    , m_width(SVGLengthValue(LengthModeWidth, "120%"))
    , m_height(SVGLengthValue(LengthModeHeight, "120%"))
{
    // Spec: If the x/y attribute is not specified, the effect is as if a value of "-10%" were specified.
    // Spec: If the width/height attribute is not specified, the effect is as if a value of "120%" were specified.



// FIXME: Remove this class once SVGMatrix becomes an alias to DOMMatrix.
class SVGMatrix : public SVGPropertyTearOff<SVGMatrixValue> {
public:
    static Ref<SVGMatrix> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
    {
        return adoptRef(*new SVGMatrix(animatedProperty, role, value));
    }

        if (isReadOnly())
            return Exception { NoModificationAllowedError };

        auto result = propertyReference().translate(x, y);
        commitChange();

        return SVGMatrix::create(result);

        if (isReadOnly())
            return Exception { NoModificationAllowedError };

        auto result = propertyReference().scale(scaleFactor);
        commitChange();

        return SVGMatrix::create(result);

        if (isReadOnly())
            return Exception { NoModificationAllowedError };

        auto result = propertyReference().scaleNonUniform(scaleFactorX, scaleFactorY);
        commitChange();

        return SVGMatrix::create(result);

        if (isReadOnly())
            return Exception { NoModificationAllowedError };

        auto result = propertyReference().rotate(angle);
        commitChange();

        return SVGMatrix::create(result);

        if (isReadOnly())
            return Exception { NoModificationAllowedError };

        auto result = propertyReference().rotateFromVector(x, y);
        if (result.hasException())
            return result.releaseException();
        

        if (isReadOnly())
            return Exception { NoModificationAllowedError };

        auto result = propertyReference().flipX();
        commitChange();

        return SVGMatrix::create(result);

        if (isReadOnly())
            return Exception { NoModificationAllowedError };

        auto result = propertyReference().flipY();
        commitChange();

        return SVGMatrix::create(result);

        if (isReadOnly())
            return Exception { NoModificationAllowedError };

        auto result = propertyReference().skewX(angle);
        commitChange();

        return SVGMatrix::create(result);

        if (isReadOnly())
            return Exception { NoModificationAllowedError };

        auto result = propertyReference().skewY(angle);
        commitChange();

        return SVGMatrix::create(result);
    }

protected:
    SVGMatrix(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : SVGPropertyTearOff<SVGMatrixValue>(&animatedProperty, role, value)
    {
    }




class SVGNumber : public SVGPropertyTearOff<float> {
public:
    static Ref<SVGNumber> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
    {
        return adoptRef(*new SVGNumber(animatedProperty, role, value));
    }

        return adoptRef(*new SVGNumber(initialValue));
    }

    static Ref<SVGNumber> create(const float* initialValue)
    {
        return adoptRef(*new SVGNumber(initialValue));
    }

    template<typename T> static ExceptionOr<Ref<SVGNumber>> create(ExceptionOr<T>&& initialValue)
    {
        if (initialValue.hasException())

    }

private:
    SVGNumber(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : SVGPropertyTearOff<float>(&animatedProperty, role, value)
    {
    }

        : SVGPropertyTearOff<float>(initialValue)
    {
    }

    explicit SVGNumber(const float* initialValue)
        : SVGPropertyTearOff<float>(initialValue)
    {
    }
};

} // namespace WebCore



    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<SVGNumberListValues>;
    using ListWrapperCache = AnimatedListPropertyTearOff::ListWrapperCache;

    static Ref<SVGNumberList> create(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
    {
        return adoptRef(*new SVGNumberList(animatedProperty, role, values, wrappers));
    }

private:
    SVGNumberList(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
        : SVGListPropertyTearOff<SVGNumberListValues>(animatedProperty, role, values, wrappers)
    {
    }



    while (ptr < end) {
        if (!parseNumber(ptr, end, number))
            return;
        append(SVGValue::create<float>(number));
    }
}


        if (i > 0)
            builder.append(' ');

        builder.appendNumber(propertyAt(i));
    }

    return builder.toString();




#pragma once

#include "SVGListValues.h"
#include "SVGPropertyTraits.h"
#include <wtf/Vector.h>

namespace WebCore {

class SVGNumber;
class SVGNumberList;

class SVGNumberListValues final : public SVGListValues<float> {
public:
    void parse(const String&);
    String valueAsString() const;   
};

template<>
struct SVGPropertyTraits<SVGNumberListValues> {
    static SVGNumberListValues initialValue() { return { }; }
    static SVGNumberListValues fromString(const String& string)
    {
        SVGNumberListValues list;
        list.parse(string);
        return list;
    }
    static String toString(const SVGNumberListValues& list) { return list.valueAsString(); }

    using ListItemType = float;
    using ListItemTearOff = SVGNumber;
    using ListPropertyTearOff = SVGNumberList;



    return cur == end;
}

bool parsePoint(const String& s, FloatPoint& point)
{
    if (s.isEmpty())
        return false;
    auto upconvertedCharacters = StringView(s).upconvertedCharacters();
    const UChar* cur = upconvertedCharacters;
    const UChar* end = cur + s.length();

    if (!skipOptionalSVGSpaces(cur, end))
        return false;

    float x = 0;
    if (!parseNumber(cur, end, x))
        return false;

    float y = 0;
    if (!parseNumber(cur, end, y))
        return false;

    point = FloatPoint(x, y);

    // Disallow anything except spaces at the end.
    return !skipOptionalSVGSpaces(cur, end);
}

bool parseRect(const String& string, FloatRect& rect)
{
    auto upconvertedCharacters = StringView(string).upconvertedCharacters();

        }
        skipOptionalSVGSpaces(cur, end);

        pointsList.append(SVGValue::create<FloatPoint>(FloatPoint(xPos, yPos)));
    }
    return cur == end && !delimParsed;
}

Lines 43-48 bool parseNumberOptionalNumber(const Str Source/WebCore/svg/SVGParserUtilities.h_sec1
- Source/WebCore/svg/SVGParserUtilities.h +1 lines
43	bool parseArcFlag(const LChar& ptr, const LChar end, bool& flag);	43	bool parseArcFlag(const LChar& ptr, const LChar end, bool& flag);
44	bool parseArcFlag(const UChar& ptr, const UChar end, bool& flag);	44	bool parseArcFlag(const UChar& ptr, const UChar end, bool& flag);
45	bool parseRect(const String&, FloatRect&);	45	bool parseRect(const String&, FloatRect&);
		46	bool parsePoint(const String&, FloatPoint&);
46		47
47	template <typename CharacterType>	48	template <typename CharacterType>
48	bool parseFloatPoint(const CharacterType& current, const CharacterType end, FloatPoint&);	49	bool parseFloatPoint(const CharacterType& current, const CharacterType end, FloatPoint&);

Lines 19-24 Source/WebCore/svg/SVGPathByteStream.h_sec1
- Source/WebCore/svg/SVGPathByteStream.h -12 / +33 lines
19		19
20	#pragma once	20	#pragma once
21		21
		22	#include "SVGPathUtilities.h"
		23	#include "SVGPropertyTraits.h"
22	#include <wtf/Vector.h>	24	#include <wtf/Vector.h>
23		25
24	namespace WebCore {	26	namespace WebCore {
Lines 46-79 public: Source/WebCore/svg/SVGPathByteStream.h_sec2
46	typedef Data::const_iterator DataIterator;	48	typedef Data::const_iterator DataIterator;
47		49
48	SVGPathByteStream() { }	50	SVGPathByteStream() { }
49	SVGPathByteStream(const Data& data) : m_data(data) { }	51	SVGPathByteStream(SVGPathByteStream&& other)
		52	: m_data(WTFMove(other.m_data))
		53	{
		54	}
50		55
51	bool operator==(const SVGPathByteStream& other) const	56	SVGPathByteStream(const SVGPathByteStream& other)
		57	: m_data(other.m_data)
52	{	58	{
53	return m_data == other.m_data;
54	}	59	}
55		60
56	bool operator!=(const SVGPathByteStream& other) const	61	SVGPathByteStream& operator=(SVGPathByteStream&& other)
		62	{
		63	m_data = WTFMove(other.m_data);
		64	return *this;
		65	}
		66	SVGPathByteStream& operator=(const SVGPathByteStream& other)
57	{	67	{
58	return !(*this == other);	68	m_data = other.m_data;
		69	return *this;
59	}	70	}
60		71
		72	bool operator==(const SVGPathByteStream& other) const { return m_data == other.m_data; }
		73	bool operator!=(const SVGPathByteStream& other) const { return m_data != other.m_data; }
		74
61	std::unique_ptr<SVGPathByteStream> copy() const	75	std::unique_ptr<SVGPathByteStream> copy() const
62	{	76	{
63	return std::make_unique<SVGPathByteStream>(m_data);	77	return std::make_unique<SVGPathByteStream>(*this);
64	}	78	}
65		79
66	DataIterator begin() const { return m_data.begin(); }	80	DataIterator begin() const { return m_data.begin(); }
67	DataIterator end() const { return m_data.end(); }	81	DataIterator end() const { return m_data.end(); }
68		82
69	void append(unsigned char byte) { m_data.append(byte); }	83	void append(unsigned char byte) { m_data.append(byte); }
70	void append(const SVGPathByteStream& other)	84	void append(const SVGPathByteStream& other) { m_data.appendVector(other.m_data); }
71	{
72	for (auto stream : other)
73	append(stream);
74	}
75	void clear() { m_data.clear(); }	85	void clear() { m_data.clear(); }
76	bool isEmpty() const { return !m_data.size(); }	86	bool isEmpty() const { return m_data.isEmpty(); }
77	unsigned size() const { return m_data.size(); }	87	unsigned size() const { return m_data.size(); }
78		88
79	// Only defined to let SVGAnimatedPathAnimator use the standard list code paths - this method is never called.	89	// Only defined to let SVGAnimatedPathAnimator use the standard list code paths - this method is never called.
Lines 82-86 public: Source/WebCore/svg/SVGPathByteStream.h_sec3
82	private:	92	private:
83	Data m_data;	93	Data m_data;
84	};	94	};
		95
		96	template<>
		97	struct SVGPropertyTraits<SVGPathByteStream> {
		98	static SVGPathByteStream initialValue() { return SVGPathByteStream(); }
		99	static SVGPathByteStream fromString(const String& string)
		100	{
		101	SVGPathByteStream byteStream;
		102	buildSVGPathByteStreamFromString(string, byteStream, UnalteredParsing);
		103	return byteStream;
		104	}
		105	};
85		106
86	} // namespace WebCore	107	} // namespace WebCore




inline SVGPathElement::SVGPathElement(const QualifiedName& tagName, Document& document)
    : SVGGraphicsElement(tagName, document)
    , m_pathSegList(SVGPathSegListValues(PathSegUnalteredRole))
    , m_isAnimValObserved(false)
{
    ASSERT(hasTagName(SVGNames::pathTag));

        if (m_pathSegList.shouldSynchronize && !SVGAnimatedProperty::lookupWrapper<SVGPathElement, SVGAnimatedPathSegListPropertyTearOff>(this, dPropertyInfo())->isAnimating()) {
            SVGPathSegListValues newList(PathSegUnalteredRole);
            buildSVGPathSegListValuesFromByteStream(m_pathByteStream, *this, newList, UnalteredParsing);
            static_cast<SVGPathSegListValues&>(*m_pathSegList.value) = WTFMove(newList);
        }

        if (renderer)

    if (auto property = SVGAnimatedProperty::lookupWrapper<SVGPathElement, SVGAnimatedPathSegListPropertyTearOff>(&ownerType, dPropertyInfo()))
        return *property;

    if (static_cast<SVGPathSegListValues&>(*ownerType.m_pathSegList.value).isEmpty())
        buildSVGPathSegListValuesFromByteStream(ownerType.m_pathByteStream, ownerType, static_cast<SVGPathSegListValues&>(*ownerType.m_pathSegList.value), UnalteredParsing);

    return SVGAnimatedProperty::lookupOrCreateWrapper<SVGPathElement, SVGAnimatedPathSegListPropertyTearOff, SVGPathSegListValues>(&ownerType, dPropertyInfo(), ownerType.m_pathSegList.value);
}

    SVGPathElement& ownerType = downcast<SVGPathElement>(*contextElement);
    if (!ownerType.m_pathSegList.shouldSynchronize)
        return;
    ownerType.m_pathSegList.synchronize(&ownerType, dPropertyInfo()->attributeName, static_cast<SVGPathSegListValues&>(*ownerType.m_pathSegList.value).valueAsString());
}

void SVGPathElement::animatedPropertyWillBeDeleted()

        break;
    case PathSegUnalteredRole:
        if (listModification == ListModificationAppend) {
            ASSERT(!static_cast<SVGPathSegListValues&>(*m_pathSegList.value).isEmpty());
            appendSVGPathByteStreamFromSVGPathSeg(static_cast<SVGPathSegListValues&>(*m_pathSegList.value).lastProperty().copyRef(), m_pathByteStream, UnalteredParsing);
        } else
            buildSVGPathByteStreamFromSVGPathSegListValues(static_cast<SVGPathSegListValues&>(*m_pathSegList.value), m_pathByteStream, UnalteredParsing);
        m_cachedPath = std::nullopt;
        break;
    case PathSegUndefinedRole:




void SVGPathSegList::clearContextAndRoles()
{
    for (auto& item : valuesProperty().properties())
    for (auto& item : *m_values)
        static_cast<SVGPathSegWithContext*>(item.get())->setContextAndRole(nullptr, PathSegUndefinedRole);
}

ExceptionOr<void> SVGPathSegList::clear()
{
    if (valuesProperty().isEmpty())
    if (m_values->isEmpty())
        return { };

    clearContextAndRoles();


ExceptionOr<RefPtr<SVGPathSeg>> SVGPathSegList::replaceItem(Ref<SVGPathSeg>&& newItem, unsigned index)
{
    if (index < valuesProperty().size()) {
        ListItemType replacedItem = valuesProperty().propertyAt(index);
        ASSERT(replacedItem);
        static_cast<SVGPathSegWithContext*>(replacedItem.get())->setContextAndRole(nullptr, PathSegUndefinedRole);
    }



    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<SVGPathSegListValues>;
    using ListItemType = SVGPropertyTraits<SVGPathSegListValues>::ListItemType;

    static Ref<SVGPathSegList> create(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, SVGPathSegRole pathSegRole, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
    {
        return adoptRef(*new SVGPathSegList(animatedProperty, role, pathSegRole, values, wrappers));
    }

    static Ref<SVGPathSegList> create(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
    {
        ASSERT_NOT_REACHED();
        return adoptRef(*new SVGPathSegList(animatedProperty, role, PathSegUndefinedRole, values, wrappers));


    int findItem(const ListItemType& item) const
    {
        unsigned size = valuesProperty().size();

        unsigned size = m_values->size();
        for (size_t i = 0; i < size; ++i) {
            if (item == valuesProperty().propertyAt(i))
                return i;
        }



    void removeItemFromList(size_t itemIndex, bool shouldSynchronizeWrappers)
    {
        RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(itemIndex < valuesProperty().size());
        ASSERT_WITH_SECURITY_IMPLICATION(itemIndex < m_values->size());

        valuesProperty().remove(itemIndex);

        if (shouldSynchronizeWrappers)
            commitChange();

    }

private:
    SVGPathSegList(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, SVGPathSegRole pathSegRole, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
        : SVGListProperty<SVGPathSegListValues>(role, values, &wrappers)
        , m_animatedProperty(&animatedProperty)
        , m_pathSegRole(pathSegRole)


    void commitChange() final
    {
        valuesProperty().commitChange(*m_animatedProperty->contextElement(), ListModificationUnknown);
        m_values->commitChange(*m_animatedProperty->contextElement(), ListModificationUnknown);
    }

    void commitChange(ListModification listModification) final
    {
        valuesProperty().commitChange(*m_animatedProperty->contextElement(), listModification);
        m_values->commitChange(*m_animatedProperty->contextElement(), listModification);
    }

    bool processIncomingListItemValue(const ListItemType& newItem, unsigned* indexToModify) final;



void SVGPathSegListBuilder::moveTo(const FloatPoint& targetPoint, bool, PathCoordinateMode mode)
{
    if (mode == AbsoluteCoordinates)
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegMovetoAbs(targetPoint.x(), targetPoint.y(), m_pathSegRole)));
    else
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegMovetoRel(targetPoint.x(), targetPoint.y(), m_pathSegRole)));
}

void SVGPathSegListBuilder::lineTo(const FloatPoint& targetPoint, PathCoordinateMode mode)
{
    if (mode == AbsoluteCoordinates)
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegLinetoAbs(targetPoint.x(), targetPoint.y(), m_pathSegRole)));
    else
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegLinetoRel(targetPoint.x(), targetPoint.y(), m_pathSegRole)));
}

void SVGPathSegListBuilder::lineToHorizontal(float x, PathCoordinateMode mode)
{
    if (mode == AbsoluteCoordinates)
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegLinetoHorizontalAbs(x, m_pathSegRole)));
    else
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegLinetoHorizontalRel(x, m_pathSegRole)));
}

void SVGPathSegListBuilder::lineToVertical(float y, PathCoordinateMode mode)
{
    if (mode == AbsoluteCoordinates)
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegLinetoVerticalAbs(y, m_pathSegRole)));
    else
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegLinetoVerticalRel(y, m_pathSegRole)));
}

void SVGPathSegListBuilder::curveToCubic(const FloatPoint& point1, const FloatPoint& point2, const FloatPoint& targetPoint, PathCoordinateMode mode)
{
    if (mode == AbsoluteCoordinates)
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegCurvetoCubicAbs(targetPoint.x(), targetPoint.y(), point1.x(), point1.y(), point2.x(), point2.y(), m_pathSegRole)));
    else
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegCurvetoCubicRel(targetPoint.x(), targetPoint.y(), point1.x(), point1.y(), point2.x(), point2.y(), m_pathSegRole)));
}

void SVGPathSegListBuilder::curveToCubicSmooth(const FloatPoint& point2, const FloatPoint& targetPoint, PathCoordinateMode mode)
{
    if (mode == AbsoluteCoordinates)
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegCurvetoCubicSmoothAbs(targetPoint.x(), targetPoint.y(), point2.x(), point2.y(), m_pathSegRole)));
    else
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegCurvetoCubicSmoothRel(targetPoint.x(), targetPoint.y(), point2.x(), point2.y(), m_pathSegRole)));
}

void SVGPathSegListBuilder::curveToQuadratic(const FloatPoint& point1, const FloatPoint& targetPoint, PathCoordinateMode mode)
{
    if (mode == AbsoluteCoordinates)
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegCurvetoQuadraticAbs(targetPoint.x(), targetPoint.y(), point1.x(), point1.y(), m_pathSegRole)));
    else
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegCurvetoQuadraticRel(targetPoint.x(), targetPoint.y(), point1.x(), point1.y(), m_pathSegRole)));
}

void SVGPathSegListBuilder::curveToQuadraticSmooth(const FloatPoint& targetPoint, PathCoordinateMode mode)
{
    if (mode == AbsoluteCoordinates)
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegCurvetoQuadraticSmoothAbs(targetPoint.x(), targetPoint.y(), m_pathSegRole)));
    else
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegCurvetoQuadraticSmoothRel(targetPoint.x(), targetPoint.y(), m_pathSegRole)));
}

void SVGPathSegListBuilder::arcTo(float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, const FloatPoint& targetPoint, PathCoordinateMode mode)
{
    if (mode == AbsoluteCoordinates)
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegArcAbs(targetPoint.x(), targetPoint.y(), r1, r2, angle, largeArcFlag, sweepFlag, m_pathSegRole)));
    else
        m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegArcRel(targetPoint.x(), targetPoint.y(), r1, r2, angle, largeArcFlag, sweepFlag, m_pathSegRole)));
}

void SVGPathSegListBuilder::closePath()
{
    m_pathSegList.append(SVGValue::create<RefPtr<SVGPathSeg>>(m_pathElement.createSVGPathSegClosePath(m_pathSegRole)));
}

}




bool SVGPathSegListSource::parseSVGSegmentType(SVGPathSegType& pathSegType)
{
    m_segment = m_pathSegList.propertyAt(m_itemCurrent);
    pathSegType = static_cast<SVGPathSegType>(m_segment->pathSegType());
    ++m_itemCurrent;
    return true;


SVGPathSegType SVGPathSegListSource::nextCommand(SVGPathSegType)
{
    m_segment = m_pathSegList.propertyAt(m_itemCurrent);
    SVGPathSegType pathSegType = static_cast<SVGPathSegType>(m_segment->pathSegType());
    ++m_itemCurrent;
    return pathSegType;




#pragma once

#include "SVGListValues.h"
#include "SVGPathSeg.h"
#include "SVGPropertyTraits.h"
#include <wtf/Vector.h>
#include <wtf/text/WTFString.h>

namespace WebCore {

template<typename T> 
class SVGPropertyTearOff;

class SVGPathSegListValues : public SVGListValues<RefPtr<SVGPathSeg>> {
public:
    explicit SVGPathSegListValues(SVGPathSegRole role)
        : m_role(role)



    ASSERT(parsingMode == UnalteredParsing);

    SVGPathSegListValues appendedItemList(PathSegUnalteredRole);
    appendedItemList.append(SVGValue::create<RefPtr<SVGPathSeg>>(WTFMove(pathSeg)));

    SVGPathByteStream appendedByteStream;
    SVGPathSegListSource source(appendedItemList);


bool addToSVGPathByteStream(SVGPathByteStream& streamToAppendTo, const SVGPathByteStream& byStream, unsigned repeatCount)
{
    // The byStream will be blended with streamToAppendTo. So streamToAppendTo has to have elements.
    if (streamToAppendTo.isEmpty() || byStream.isEmpty())
        return true;

    // builder is the destination of blending fromSource and bySource. The stream of builder
    // (i.e. streamToAppendTo) has to be cleared before calling addAnimatedPath.
    SVGPathByteStreamBuilder builder(streamToAppendTo);
    SVGPathByteStream fromStreamCopy = WTFMove(streamToAppendTo);
    SVGPathByteStream fromStreamCopy = streamToAppendTo;
    streamToAppendTo.clear();

    SVGPathByteStreamSource fromSource(fromStreamCopy);
    SVGPathByteStreamSource bySource(byStream);




class SVGPoint : public SVGPropertyTearOff<FloatPoint> {
public:
    static Ref<SVGPoint> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
    {
        return adoptRef(*new SVGPoint(animatedProperty, role, value));
    }

        return adoptRef(*new SVGPoint(initialValue));
    }

    static Ref<SVGPoint> create(const FloatPoint* initialValue)
    {
        return adoptRef(*new SVGPoint(initialValue));
    }

    template<typename T> static ExceptionOr<Ref<SVGPoint>> create(ExceptionOr<T>&& initialValue)
    {
        if (initialValue.hasException())

    }

protected:
    SVGPoint(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : SVGPropertyTearOff<FloatPoint>(&animatedProperty, role, value)
    {
    }

    SVGPoint(SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : SVGPropertyTearOff<FloatPoint>(nullptr, role, value)
    {
    }

        : SVGPropertyTearOff<FloatPoint>(initialValue)
    {
    }

    explicit SVGPoint(const FloatPoint* initialValue)
        : SVGPropertyTearOff<FloatPoint>(initialValue)
    {
    }
};

} // namespace WebCore



    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<SVGPointListValues>;
    using ListWrapperCache = AnimatedListPropertyTearOff::ListWrapperCache;

    static Ref<SVGPointList> create(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
    {
        return adoptRef(*new SVGPointList(animatedProperty, role, values, wrappers));
    }

private:
    SVGPointList(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
        : SVGListPropertyTearOff<SVGPointListValues>(animatedProperty, role, values, wrappers)
    {
    }

Lines 35-41 String SVGPointListValues::valueAsString Source/WebCore/svg/SVGPointListValues.cpp_sec1
- Source/WebCore/svg/SVGPointListValues.cpp -1 / +1 lines
35	if (i > 0)	35	if (i > 0)
36	builder.append(' '); // FIXME: Shouldn't we use commas to seperate?	36	builder.append(' '); // FIXME: Shouldn't we use commas to seperate?
37		37
38	const auto& point = at(i);	38	const auto& point = propertyAt(i);
39	builder.appendNumber(point.x());	39	builder.appendNumber(point.x());
40	builder.append(' ');	40	builder.append(' ');
41	builder.appendNumber(point.y());	41	builder.appendNumber(point.y());



#pragma once

#include "FloatPoint.h"
#include "SVGListValues.h"
#include "SVGPropertyTraits.h"
#include <wtf/Vector.h>

namespace WebCore {

class SVGPoint;
class SVGPointList;

class SVGPointListValues final : public SVGListValues<FloatPoint> {
public:
    String valueAsString() const;
};

template<>
struct SVGPropertyTraits<SVGPointListValues> {
    static SVGPointListValues initialValue() { return { }; }
    static SVGPointListValues fromString(const String& string)
    {
        SVGPointListValues list;
        pointsListFromSVGData(list, string);
        return list;
    }
    using ListItemType = FloatPoint;
    using ListItemTearOff = SVGPoint;
    using ListPropertyTearOff = SVGPointList;



        if (auto wrapper = SVGAnimatedProperty::lookupWrapper<SVGPolyElement, SVGAnimatedPointList>(this, pointsPropertyInfo()))
            static_pointer_cast<SVGAnimatedPointList>(wrapper)->detachListWrappers(newList.size());

        static_cast<SVGPointListValues&>(*m_points.value) = WTFMove(newList);
        return;
    }


    SVGPolyElement& ownerType = downcast<SVGPolyElement>(*contextElement);
    if (!ownerType.m_points.shouldSynchronize)
        return;
    ownerType.m_points.synchronize(&ownerType, pointsPropertyInfo()->attributeName, static_cast<SVGPointListValues&>(*ownerType.m_points.value).valueAsString());
}

Ref<SVGAnimatedProperty> SVGPolyElement::lookupOrCreatePointsWrapper(SVGElement* contextElement)

Lines 33-39 public: Source/WebCore/svg/SVGPolyElement.h_sec1
- Source/WebCore/svg/SVGPolyElement.h -1 / +1 lines
33	Ref<SVGPointList> points();	33	Ref<SVGPointList> points();
34	Ref<SVGPointList> animatedPoints();	34	Ref<SVGPointList> animatedPoints();
35		35
36	SVGPointListValues& pointList() const { return m_points.value; }	36	SVGPointListValues& pointList() const { return static_cast<SVGPointListValues&>(*m_points.value); }
37		37
38	static const SVGPropertyInfo* pointsPropertyInfo();	38	static const SVGPropertyInfo* pointsPropertyInfo();
39		39




class SVGPreserveAspectRatio : public SVGPropertyTearOff<SVGPreserveAspectRatioValue> {
public:
    static Ref<SVGPreserveAspectRatio> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
    {
        return adoptRef(*new SVGPreserveAspectRatio(animatedProperty, role, value));
    }

        return adoptRef(*new SVGPreserveAspectRatio(initialValue));
    }

    static Ref<SVGPreserveAspectRatio> create(const SVGPreserveAspectRatioValue* initialValue)
    {
        return adoptRef(*new SVGPreserveAspectRatio(initialValue));
    }

    template<typename T> static ExceptionOr<Ref<SVGPreserveAspectRatio>> create(ExceptionOr<T>&& initialValue)
    {
        if (initialValue.hasException())

    }

private:
    SVGPreserveAspectRatio(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : SVGPropertyTearOff<SVGPreserveAspectRatioValue>(&animatedProperty, role, value)
    {
    }

        : SVGPropertyTearOff<SVGPreserveAspectRatioValue>(initialValue)
    {
    }

    explicit SVGPreserveAspectRatio(const SVGPreserveAspectRatioValue* initialValue)
        : SVGPropertyTearOff<SVGPreserveAspectRatioValue>(initialValue)
    {
    }
};

} // namespace WebCore

Lines 35-40 SVGPreserveAspectRatioValue::SVGPreserve Source/WebCore/svg/SVGPreserveAspectRatioValue.cpp_sec1
- Source/WebCore/svg/SVGPreserveAspectRatioValue.cpp +5 lines
35	{	35	{
36	}	36	}
37		37
		38	SVGPreserveAspectRatioValue::SVGPreserveAspectRatioValue(const String& string)
		39	{
		40	parse(string);
		41	}
		42
38	ExceptionOr<void> SVGPreserveAspectRatioValue::setAlign(unsigned short align)	43	ExceptionOr<void> SVGPreserveAspectRatioValue::setAlign(unsigned short align)
39	{	44	{
40	if (align == SVG_PRESERVEASPECTRATIO_UNKNOWN \|\| align > SVG_PRESERVEASPECTRATIO_XMAXYMAX)	45	if (align == SVG_PRESERVEASPECTRATIO_UNKNOWN \|\| align > SVG_PRESERVEASPECTRATIO_XMAXYMAX)



    };

    SVGPreserveAspectRatioValue();
    SVGPreserveAspectRatioValue(const String&);

    ExceptionOr<void> setAlign(unsigned short);
    unsigned short align() const { return m_align; }


template<> struct SVGPropertyTraits<SVGPreserveAspectRatioValue> {
    static SVGPreserveAspectRatioValue initialValue() { return SVGPreserveAspectRatioValue(); }
    static SVGPreserveAspectRatioValue fromString(const String& string) { return SVGPreserveAspectRatioValue(string); }
    static String toString(const SVGPreserveAspectRatioValue& type) { return type.valueAsString(); }
};





inline SVGRadialGradientElement::SVGRadialGradientElement(const QualifiedName& tagName, Document& document)
    : SVGGradientElement(tagName, document)
    , m_cx(SVGLengthValue(LengthModeWidth, "50%"))
    , m_cy(SVGLengthValue(LengthModeHeight, "50%"))
    , m_r(SVGLengthValue(LengthModeOther, "50%"))
    , m_fx(SVGLengthValue(LengthModeWidth))
    , m_fy(SVGLengthValue(LengthModeHeight))
    , m_fr(SVGLengthValue(LengthModeOther, "0%"))
{
    // Spec: If the cx/cy/r/fr attribute is not specified, the effect is as if a value of "50%" were specified.
    ASSERT(hasTagName(SVGNames::radialGradientTag));



#pragma once

#include "SVGPropertyTearOff.h"
#include "SVGPropertyTraits.h"

namespace WebCore {

class SVGRect : public SVGPropertyTearOff<FloatRect> {
public:
    static Ref<SVGRect> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
    {
        return adoptRef(*new SVGRect(animatedProperty, role, value));
    }

        return adoptRef(*new SVGRect(initialValue));
    }

    static Ref<SVGRect> create(const FloatRect* initialValue)
    {
        return adoptRef(*new SVGRect(initialValue));
    }

    template<typename T> static ExceptionOr<Ref<SVGRect>> create(ExceptionOr<T>&& initialValue)
    {
        if (initialValue.hasException())

    }

private:
    SVGRect(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : SVGPropertyTearOff<FloatRect>(&animatedProperty, role, value)
    {
    }

        : SVGPropertyTearOff<FloatRect>(initialValue)
    {
    }

    explicit SVGRect(const FloatRect* initialValue)
        : SVGPropertyTearOff<FloatRect>(initialValue)
    {
    }
};





/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include "FloatRect.h"
#include "SVGPropertyTraits.h"
#include <wtf/text/StringBuilder.h>

namespace WebCore {

template<>
struct SVGPropertyTraits<FloatRect> {
    static FloatRect initialValue() { return { }; }
    static String toString(const FloatRect& type)
    {
        StringBuilder builder;
        builder.appendNumber(type.x());
        builder.append(' ');
        builder.appendNumber(type.y());
        builder.append(' ');
        builder.appendNumber(type.width());
        builder.append(' ');
        builder.appendNumber(type.height());
        return builder.toString();
    }
};

} // namespace WebCore




inline SVGSVGElement::SVGSVGElement(const QualifiedName& tagName, Document& document)
    : SVGGraphicsElement(tagName, document)
    , m_x(SVGLengthValue(LengthModeWidth))
    , m_y(SVGLengthValue(LengthModeHeight))
    , m_width(SVGLengthValue(LengthModeWidth, ASCIILiteral("100%")))
    , m_height(SVGLengthValue(LengthModeHeight, ASCIILiteral("100%")))
    , m_timeContainer(SMILTimeContainer::create(*this))
    , m_currentTranslate(SVGValue::create<FloatPoint>())
{
    ASSERT(hasTagName(SVGNames::svgTag));
    registerAnimatedPropertiesForSVGSVGElement();


void SVGSVGElement::setCurrentTranslate(const FloatPoint& translation)
{
    if (static_cast<FloatPoint&>(*m_currentTranslate) == translation)
        return;
    static_cast<FloatPoint&>(*m_currentTranslate) = translation;
    updateCurrentTranslate();
}




    bool m_useCurrentView { false };
    SVGZoomAndPanType m_zoomAndPan { SVGZoomAndPanMagnify };
    Ref<SMILTimeContainer> m_timeContainer;
    RefPtr<SVGValue> m_currentTranslate;
    RefPtr<SVGViewSpec> m_viewSpec;
    String m_currentViewFragmentIdentifier;
};


inline FloatPoint SVGSVGElement::currentTranslateValue()
{
    return static_cast<FloatPoint&>(*m_currentTranslate);
}

inline SVGZoomAndPanType SVGSVGElement::zoomAndPan() const



    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<SVGStringListValues>;
    using ListWrapperCache = AnimatedListPropertyTearOff::ListWrapperCache;

    static Ref<SVGStringList> create(SVGElement& contextElement, const RefPtr<SVGValue>& values)
    {
        return adoptRef(*new SVGStringList(&contextElement, values));
    }

    static Ref<SVGStringList> create(AnimatedListPropertyTearOff&, SVGPropertyRole, const RefPtr<SVGValue>& values, ListWrapperCache&)
    {
        // FIXME: Find a way to remove this. It's only needed to keep Windows compiling.
        ASSERT_NOT_REACHED();

    }

private:
    SVGStringList(SVGElement* contextElement, const RefPtr<SVGValue>& values)
        : SVGStaticListPropertyTearOff<SVGStringListValues>(contextElement, values)
    {
    }




    // Add empty string, if list is empty.
    if (isEmpty())
        append(SVGValue::create<String>(emptyString()));
}

void SVGStringListValues::parse(const String& data, UChar delimiter)

            ptr++;
        if (ptr == start)
            break;
        append(SVGValue::create<String>(String(start, ptr - start)));
        skipOptionalSVGSpacesOrDelimiter(ptr, end, delimiter);
    }
}

        if (i > 0)
            builder.append(' ');

        builder.append(propertyAt(i));
    }

    return builder.toString();



#pragma once

#include "QualifiedName.h"
#include "SVGListValues.h"
#include "SVGPropertyTraits.h"
#include <wtf/Vector.h>

namespace WebCore {


template<typename T> 
class SVGPropertyTearOff;

class SVGStringListValues final : public SVGListValues<String> {
public:
    SVGStringListValues(const QualifiedName& attributeName)
        : m_attributeName(attributeName)

Lines 107-115 static const HashSet<String, ASCIICaseIn Source/WebCore/svg/SVGTests.cpp_sec1
- Source/WebCore/svg/SVGTests.cpp -10 / +15 lines
107	}	107	}
108		108
109	SVGTests::SVGTests()	109	SVGTests::SVGTests()
110	: m_requiredFeatures(requiredFeaturesAttr)	110	: m_requiredFeatures(SVGStringListValues(requiredFeaturesAttr))
111	, m_requiredExtensions(requiredExtensionsAttr)	111	, m_requiredExtensions(SVGStringListValues(requiredExtensionsAttr))
112	, m_systemLanguage(systemLanguageAttr)	112	, m_systemLanguage(SVGStringListValues(systemLanguageAttr))
113	{	113	{
114	}	114	}
115		115
Lines 154-168 bool SVGTests::hasExtension(const String Source/WebCore/svg/SVGTests.cpp_sec2
154		154
155	bool SVGTests::isValid() const	155	bool SVGTests::isValid() const
156	{	156	{
157	for (auto& feature : m_requiredFeatures.value) {	157	auto features = static_cast<SVGStringListValues&>(*m_requiredFeatures.value).properties();
		158	for (auto& feature : features) {
158	if (feature.isEmpty() \|\| !supportedSVGFeatures().contains(feature))	159	if (feature.isEmpty() \|\| !supportedSVGFeatures().contains(feature))
159	return false;	160	return false;
160	}	161	}
161	for (auto& language : m_systemLanguage.value) {	162
		163	auto languages = static_cast<SVGStringListValues&>(*m_systemLanguage.value).properties();
		164	for (auto& language : languages) {
162	if (language != defaultLanguage().substring(0, 2))	165	if (language != defaultLanguage().substring(0, 2))
163	return false;	166	return false;
164	}	167	}
165	for (auto& extension : m_requiredExtensions.value) {	168
		169	auto extensions = static_cast<SVGStringListValues&>(*m_requiredExtensions.value).properties();
		170	for (auto& extension : extensions) {
166	if (!hasExtension(extension))	171	if (!hasExtension(extension))
167	return false;	172	return false;
168	}	173	}
Lines 172-182 bool SVGTests::isValid() const Source/WebCore/svg/SVGTests.cpp_sec3
172	void SVGTests::parseAttribute(const QualifiedName& attributeName, const AtomicString& value)	177	void SVGTests::parseAttribute(const QualifiedName& attributeName, const AtomicString& value)
173	{	178	{
174	if (attributeName == requiredFeaturesAttr)	179	if (attributeName == requiredFeaturesAttr)
175	m_requiredFeatures.value.reset(value);	180	static_cast<SVGStringListValues&>(*m_requiredFeatures.value).reset(value);
176	if (attributeName == requiredExtensionsAttr)	181	if (attributeName == requiredExtensionsAttr)
177	m_requiredExtensions.value.reset(value);	182	static_cast<SVGStringListValues&>(*m_requiredExtensions.value).reset(value);
178	if (attributeName == systemLanguageAttr)	183	if (attributeName == systemLanguageAttr)
179	m_systemLanguage.value.reset(value);	184	static_cast<SVGStringListValues&>(*m_systemLanguage.value).reset(value);
180	}	185	}
181		186
182	bool SVGTests::isKnownAttribute(const QualifiedName& attributeName)	187	bool SVGTests::isKnownAttribute(const QualifiedName& attributeName)
Lines 208-214 void SVGTests::synchronizeAttribute(SVGE Source/WebCore/svg/SVGTests.cpp_sec4
208	{	213	{
209	if (!property.shouldSynchronize)	214	if (!property.shouldSynchronize)
210	return;	215	return;
211	m_requiredFeatures.synchronize(&contextElement, attributeName, property.value.valueAsString());	216	m_requiredFeatures.synchronize(&contextElement, attributeName, static_cast<SVGStringListValues&>(*property.value).valueAsString());
212	}	217	}
213		218
214	void SVGTests::synchronizeRequiredFeatures(SVGElement& contextElement)	219	void SVGTests::synchronizeRequiredFeatures(SVGElement& contextElement)




SVGTextContentElement::SVGTextContentElement(const QualifiedName& tagName, Document& document)
    : SVGGraphicsElement(tagName, document)
    , m_textLength(SVGLengthValue(LengthModeOther))
    , m_specifiedTextLength(SVGLengthValue(LengthModeOther))
    , m_lengthAdjust(SVGLengthAdjustSpacing)
{
    registerAnimatedPropertiesForSVGTextContentElement();

{
    static NeverDestroyed<SVGLengthValue> defaultTextLength(LengthModeOther);
    if (m_specifiedTextLength == defaultTextLength)
        static_cast<SVGLengthValue&>(*m_textLength.value).newValueSpecifiedUnits(LengthTypeNumber, getComputedTextLength());

    m_textLength.shouldSynchronize = true;
    return static_reference_cast<SVGAnimatedLength>(lookupOrCreateTextLengthWrapper(this));

        if (propertyValue > 0)
            setLengthAdjustBaseValue(propertyValue);
    } else if (name == SVGNames::textLengthAttr)
        static_cast<SVGLengthValue&>(*m_textLength.value) = SVGLengthValue::construct(LengthModeOther, value, parseError, ForbidNegativeLengths);

    reportAttributeParsingError(parseError, name, value);


    }

    if (attrName == SVGNames::textLengthAttr)
        m_specifiedTextLength = static_cast<SVGLengthValue&>(*m_textLength.value);

    if (auto renderer = this->renderer()) {
        InstanceInvalidationGuard guard(*this);

Lines 46-52 END_REGISTER_ANIMATED_PROPERTIES Source/WebCore/svg/SVGTextPathElement.cpp_sec1
- Source/WebCore/svg/SVGTextPathElement.cpp -1 / +1 lines
46		46
47	inline SVGTextPathElement::SVGTextPathElement(const QualifiedName& tagName, Document& document)	47	inline SVGTextPathElement::SVGTextPathElement(const QualifiedName& tagName, Document& document)
48	: SVGTextContentElement(tagName, document)	48	: SVGTextContentElement(tagName, document)
49	, m_startOffset(LengthModeOther)	49	, m_startOffset(SVGLengthValue(LengthModeOther))
50	, m_method(SVGTextPathMethodAlign)	50	, m_method(SVGTextPathMethodAlign)
51	, m_spacing(SVGTextPathSpacingExact)	51	, m_spacing(SVGTextPathSpacingExact)
52	{	52	{




class SVGTransform : public SVGPropertyTearOff<SVGTransformValue> {
public:
    static Ref<SVGTransform> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
    {
        return adoptRef(*new SVGTransform(animatedProperty, role, value));
    }

        return adoptRef(*new SVGTransform(initialValue));
    }

    static Ref<SVGTransform> create(const SVGTransformValue* initialValue)
    {
        return adoptRef(*new SVGTransform(initialValue));
    }

    template<typename T> static ExceptionOr<Ref<SVGTransform>> create(ExceptionOr<T>&& initialValue)
    {
        if (initialValue.hasException())

    }

private:
    SVGTransform(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : SVGPropertyTearOff<SVGTransformValue>(&animatedProperty, role, value)
    {
    }

        : SVGPropertyTearOff<SVGTransformValue>(initialValue)
    {
    }

    explicit SVGTransform(const SVGTransformValue* initialValue)
        : SVGPropertyTearOff<SVGTransformValue>(initialValue)
    {
    }
};

} // namespace WebCore




#include "SVGAnimatedListPropertyTearOff.h"
#include "SVGListPropertyTearOff.h"
#include "SVGTransform.h"
#include "SVGTransformListValues.h"

namespace WebCore {

    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<SVGTransformListValues>;
    using ListWrapperCache = AnimatedListPropertyTearOff::ListWrapperCache;

    static Ref<SVGTransformList> create(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
    {
        return adoptRef(*new SVGTransformList(animatedProperty, role, values, wrappers));
    }

    ExceptionOr<Ref<SVGTransform>> createSVGTransformFromMatrix(SVGMatrix& matrix)
    {
        return valuesProperty().createSVGTransformFromMatrix(matrix);
        return m_values->createSVGTransformFromMatrix(matrix);
    }

    ExceptionOr<RefPtr<SVGTransform>> consolidate()
    {
        ASSERT(m_values);
        ASSERT(m_wrappers);

        auto result = canAlterList();

            return result.releaseException();
        ASSERT(result.releaseReturnValue());

        ASSERT(valuesProperty().size() == m_wrappers->size());

        // Spec: If the list was empty, then a value of null is returned.
        if (valuesProperty().isEmpty())
            return nullptr;

        detachListWrappers(0);
        
        RefPtr<SVGTransform> wrapper = valuesProperty().consolidate();
        m_wrappers->append(wrapper->createWeakPtr());

        ASSERT(valuesProperty().size() == m_wrappers->size());
        return WTFMove(wrapper);
    }

private:
    SVGTransformList(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
        : SVGListPropertyTearOff<SVGTransformListValues>(animatedProperty, role, values, wrappers)
    {
    }




    SVGTransformValue transform(matrix);
    clear();
    append(SVGValue::create<SVGTransformValue>(transform));
    return SVGTransform::create(transform);
}


        return false;

    for (unsigned i = 0; i < size; ++i)
        result *= propertyAt(i).matrix();

    return true;
}

        if (i > 0)
            builder.append(' ');

        builder.append(propertyAt(i).valueAsString());
    }

    return builder.toString();



/*
 * Copyright (C) 2004, 2005, 2008 Nikolas Zimmermann <zimmermann@kde.org>
 * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public


#pragma once

#include "SVGListValues.h"
#include "SVGTransformValue.h"
#include <wtf/Vector.h>

namespace WebCore {

class SVGMatrix;
class SVGTransform;

class SVGTransformList;

class SVGTransformListValues final : public SVGListValues<SVGTransformValue> {
public:
    Ref<SVGTransform> createSVGTransformFromMatrix(SVGMatrix&) const;
    Ref<SVGTransform> consolidate();

    void parse(const String&);
};

template<>
struct SVGPropertyTraits<SVGTransformListValues> {
    static SVGTransformListValues initialValue() { return { }; }
    static SVGTransformListValues fromString(const String& string)
    {
        SVGTransformListValues list;
        list.parse(string);
        ASSERT(list.size() <= 1);
        return list;
    }
    static String toString(const SVGTransformListValues& list) { return list.valueAsString(); }

    using ListItemType = SVGTransformValue;

Lines 91-94 inline bool operator!=(const SVGTransfor Source/WebCore/svg/SVGTransformValue.h_sec1
- Source/WebCore/svg/SVGTransformValue.h +5 lines
91	return !(a == b);	91	return !(a == b);
92	}	92	}
93		93
		94	template<> struct SVGPropertyTraits<SVGTransformValue> {
		95	static SVGTransformValue initialValue() { return { }; }
		96	static String toString(const SVGTransformValue& transform) { return transform.valueAsString(); }
		97	};
		98
94	} // namespace WebCore	99	} // namespace WebCore

Lines 197-203 bool SVGTransformable::parseTransformAtt Source/WebCore/svg/SVGTransformable.cpp_sec1
- Source/WebCore/svg/SVGTransformable.cpp -1 / +1 lines
197	if (!parseTransformValue(type, currTransform, end, transform))	197	if (!parseTransformValue(type, currTransform, end, transform))
198	return false;	198	return false;
199		199
200	list.append(transform);	200	list.append(SVGValue::create<SVGTransformValue>(transform));
201	skipOptionalSVGSpaces(currTransform, end);	201	skipOptionalSVGSpaces(currTransform, end);
202	if (currTransform < end && *currTransform == ',') {	202	if (currTransform < end && *currTransform == ',') {
203	delimParsed = true;	203	delimParsed = true;




inline SVGUseElement::SVGUseElement(const QualifiedName& tagName, Document& document)
    : SVGGraphicsElement(tagName, document)
    , m_x(SVGLengthValue(LengthModeWidth))
    , m_y(SVGLengthValue(LengthModeHeight))
    , m_width(SVGLengthValue(LengthModeWidth))
    , m_height(SVGLengthValue(LengthModeHeight))
    , m_svgLoadEventTimer(*this, &SVGElement::svgLoadEventTimerFired)
{
    ASSERT(hasCustomStyleResolveCallbacks());



/*
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include "Color.h"
#include "FloatPoint.h"
#include "FloatRect.h"
#include "SVGAngleValue.h"
#include "SVGLengthListValues.h"
#include "SVGLengthValue.h"
#include "SVGMatrixValue.h"
#include "SVGNumberListValues.h"
#include "SVGPathByteStream.h"
#include "SVGPathSegListValues.h"
#include "SVGPointListValues.h"
#include "SVGPreserveAspectRatioValue.h"
#include "SVGPropertyTraits.h"
#include "SVGStringListValues.h"
#include "SVGTransformListValues.h"
#include "SVGTransformValue.h"
#include <wtf/Variant.h>

namespace WebCore {

using SVGValueVariant = Variant<
    SVGAngleValue,
    bool,
    Color,
    unsigned,
    int,
    SVGLengthValue,
    SVGLengthListValues,
    SVGMatrixValue,
    float,
    SVGNumberListValues,
    SVGPathByteStream,
    RefPtr<SVGPathSeg>,
    SVGPathSegListValues,
    SVGPreserveAspectRatioValue,
    FloatPoint,
    SVGPointListValues,
    FloatRect,
    String,
    SVGStringListValues,
    SVGTransformValue,
    SVGTransformListValues
>;

template <typename PropertyType>
class SVGTraitHasToString {
    typedef char one;
    typedef long two;

    template <typename T> static one test(decltype(&SVGPropertyTraits<T>::toString));
    template <typename T> static two test(...);

public:
    enum { Value = sizeof(test<PropertyType>(nullptr)) == sizeof(char) };
};
    
struct toStringVisitor {
    template<typename PropertyType, std::enable_if_t<SVGTraitHasToString<PropertyType>::Value>* = nullptr>
    String operator()(const PropertyType& value)
    {
        return SVGPropertyTraits<PropertyType>::toString(value);
    }

    template<typename PropertyType, std::enable_if_t<!SVGTraitHasToString<PropertyType>::Value>* = nullptr>
    String operator()(const PropertyType&)
    {
        ASSERT_NOT_REACHED();
        return { };
    }
};
    
template <typename PropertyType>
class SVGTraitHasParse {
    typedef char one;
    typedef long two;

    template <typename T> static one test(decltype(&SVGPropertyTraits<T>::parse));
    template <typename T> static two test(...);

public:
    enum { Value = sizeof(test<PropertyType>(nullptr)) == sizeof(char) };
};

struct parseVisitor {
    parseVisitor(const QualifiedName& attrName, const String& string, SVGValueVariant& variant)
        : m_attrName(attrName)
        , m_string(string)
        , m_variant(variant)
    {
    }
    
    template<typename PropertyType, std::enable_if_t<SVGTraitHasParse<PropertyType>::Value>* = nullptr>
    bool operator()(const PropertyType&)
    {
        std::optional<PropertyType> result = SVGPropertyTraits<PropertyType>::parse(m_attrName, m_string);
        if (!result)
            return false;
        m_variant.emplace<PropertyType>(WTFMove(result.value()));
        return true;
    }
        
    template<typename PropertyType, std::enable_if_t<!SVGTraitHasParse<PropertyType>::Value>* = nullptr>
    bool operator()(const PropertyType&)
    {
        ASSERT_NOT_REACHED();
        return false;
    }

    const QualifiedName& m_attrName;
    const String& m_string;
    SVGValueVariant& m_variant;
};
    
class SVGValue : public RefCounted<SVGValue>, public SVGValueVariant {
public:
    template<typename PropertyType>
    static Ref<SVGValue> create()
    {
        return create<PropertyType>(SVGPropertyTraits<PropertyType>::initialValue());
    }
    
    template <class PropertyType, std::enable_if_t<std::is_enum<PropertyType>::value>* = nullptr>
    static Ref<SVGValue> create(const PropertyType& property)
    {
        return adoptRef(*new SVGValue(reinterpret_cast<const unsigned&>(property)));
    }

    template <class PropertyType, std::enable_if_t<!std::is_enum<PropertyType>::value>* = nullptr>
    static Ref<SVGValue> create(const PropertyType& property)
    {
        return adoptRef(*new SVGValue(property));
    }
    
    static Ref<SVGValue> create(const SVGValue& value)
    {
        return adoptRef(*new SVGValue(value));
    }

    template<typename PropertyType>
    bool is() const
    {
        return WTF::holds_alternative<PropertyType>(*this) || (std::is_enum<PropertyType>::value && WTF::holds_alternative<unsigned>(*this));
    }

    template <class PropertyType, std::enable_if_t<std::is_enum<PropertyType>::value>* = nullptr>
    operator const PropertyType&() const
    {
        ASSERT(WTF::holds_alternative<unsigned>(*this));
        return reinterpret_cast<const PropertyType&>(WTF::get<unsigned>(*this));
    }

    template <class PropertyType, std::enable_if_t<!std::is_enum<PropertyType>::value>* = nullptr>
    operator const PropertyType&() const
    {
        ASSERT(is<PropertyType>());
        return WTF::get<PropertyType>(*this);
    }

    template <class PropertyType, std::enable_if_t<std::is_enum<PropertyType>::value>* = nullptr>
    operator PropertyType&()
    {
        ASSERT(WTF::holds_alternative<unsigned>(*this));
        return reinterpret_cast<PropertyType&>(WTF::get<unsigned>(*this));
    }

    template <class PropertyType, std::enable_if_t<!std::is_enum<PropertyType>::value>* = nullptr>
    operator PropertyType&()
    {
        ASSERT(is<PropertyType>());
        return WTF::get<PropertyType>(*this);
    }

    String toString() const
    {
        return WTF::visit(toStringVisitor(), static_cast<const SVGValueVariant&>(*this));
    }

    bool parse(const QualifiedName& attrName, const String& string)
    {
        return WTF::visit(parseVisitor(attrName, string, static_cast<SVGValueVariant&>(*this)), static_cast<const SVGValueVariant&>(*this));
    }

private:
    template<typename PropertyType>
    explicit SVGValue(const PropertyType& value)
        : SVGValueVariant(value)
    {
        ASSERT(is<PropertyType>());
    }
    
    SVGValue(const SVGValue& value)
        : SVGValueVariant(static_cast<const SVGValueVariant&>(value))
    {
        ASSERT(index() == value.index());
    }
};
    
} // namespace WebCore



inline SVGViewElement::SVGViewElement(const QualifiedName& tagName, Document& document)
    : SVGElement(tagName, document)
    , m_zoomAndPan(SVGZoomAndPanMagnify)
    , m_viewTarget(SVGValue::create(SVGStringListValues(SVGNames::viewTargetAttr)))
{
    ASSERT(hasTagName(SVGNames::viewTag));
    registerAnimatedPropertiesForSVGViewElement();

void SVGViewElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
    if (name == SVGNames::viewTargetAttr)
        static_cast<SVGStringListValues&>(*m_viewTarget).reset(value);

    SVGExternalResourcesRequired::parseAttribute(name, value);
    SVGFitToViewBox::parseAttribute(this, name, value);

Lines 59-65 private: Source/WebCore/svg/SVGViewElement.h_sec1
- Source/WebCore/svg/SVGViewElement.h -1 / +1 lines
59	END_DECLARE_ANIMATED_PROPERTIES	59	END_DECLARE_ANIMATED_PROPERTIES
60		60
61	SVGZoomAndPanType m_zoomAndPan;	61	SVGZoomAndPanType m_zoomAndPan;
62	SVGStringListValues m_viewTarget;	62	RefPtr<SVGValue> m_viewTarget;
63	};	63	};
64		64
65	} // namespace WebCore	65	} // namespace WebCore




SVGViewSpec::SVGViewSpec(SVGElement& contextElement)
    : m_contextElement(&contextElement)
    , m_transform(SVGValue::create<SVGTransformListValues>())
    , m_viewBox(SVGValue::create<FloatRect>())
    , m_preserveAspectRatio(SVGValue::create<SVGPreserveAspectRatioValue>())
{
}



String SVGViewSpec::transformString() const
{
    return m_transform->toString();
}

String SVGViewSpec::viewBoxString() const
{
    return m_viewBox->toString();
}

String SVGViewSpec::preserveAspectRatioString() const
{
    return m_preserveAspectRatio->toString();
}

SVGElement* SVGViewSpec::viewTarget() const

void SVGViewSpec::reset()
{
    m_zoomAndPan = SVGZoomAndPanMagnify;
    static_cast<SVGTransformListValues&>(*m_transform).clear();
    static_cast<FloatRect&>(*m_viewBox) = { };
    static_cast<SVGPreserveAspectRatioValue&>(*m_preserveAspectRatio) = { };
    m_viewTargetString = emptyString();
}


            if (currViewSpec >= end || *currViewSpec != '(')
                return false;
            currViewSpec++;
            SVGTransformable::parseTransformAttribute(static_cast<SVGTransformListValues&>(*m_transform), currViewSpec, end, SVGTransformable::DoNotClearList);
            if (currViewSpec >= end || *currViewSpec != ')')
                return false;
            currViewSpec++;




    // Custom non-animated 'transform' property.
    RefPtr<SVGTransformList> transform();
    SVGTransformListValues transformBaseValue() const { return static_cast<SVGTransformListValues&>(*m_transform); }

    // Custom animated 'viewBox' property.
    RefPtr<SVGAnimatedRect> viewBoxAnimated();
    FloatRect& viewBox() { return static_cast<FloatRect&>(*m_viewBox); }
    void setViewBoxBaseValue(const FloatRect& viewBox) { static_cast<FloatRect&>(*m_viewBox) = viewBox; }

    // Custom animated 'preserveAspectRatio' property.
    RefPtr<SVGAnimatedPreserveAspectRatio> preserveAspectRatioAnimated();
    SVGPreserveAspectRatioValue& preserveAspectRatio() { return static_cast<SVGPreserveAspectRatioValue&>(*m_preserveAspectRatio); }
    void setPreserveAspectRatioBaseValue(const SVGPreserveAspectRatioValue& preserveAspectRatio) { static_cast<SVGPreserveAspectRatioValue&>(*m_preserveAspectRatio) = preserveAspectRatio; }

private:
    explicit SVGViewSpec(SVGElement&);


    SVGElement* m_contextElement;
    SVGZoomAndPanType m_zoomAndPan { SVGZoomAndPanMagnify };
    RefPtr<SVGValue> m_transform;
    RefPtr<SVGValue> m_viewBox;
    RefPtr<SVGValue> m_preserveAspectRatio;
    String m_viewTargetString;
};




        return SVGAnimatedStaticPropertyTearOff<unsigned>::setBaseVal(property);
    }

    static Ref<SVGAnimatedEnumerationPropertyTearOff<EnumType>> create(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& baseValue)
    {
        ASSERT(contextElement);
        return adoptRef(*new SVGAnimatedEnumerationPropertyTearOff<EnumType>(contextElement, attributeName, animatedPropertyType, baseValue));
    }

    EnumType& currentAnimatedValue()
    {
        unsigned& animatedValue = SVGAnimatedStaticPropertyTearOff<unsigned>::currentAnimatedValue();
        ASSERT(animatedValue <= SVGPropertyTraits<EnumType>::highestEnumValue());
        return reinterpret_cast<EnumType&>(animatedValue);
    }

private:
    SVGAnimatedEnumerationPropertyTearOff(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& baseValue)
        : SVGAnimatedStaticPropertyTearOff<unsigned>(contextElement, attributeName, animatedPropertyType, baseValue)
    {
    }




    using ListPropertyTearOff = typename SVGPropertyTraits<PropertyType>::ListPropertyTearOff;
    using ContentType = PropertyType;

    static Ref<SVGAnimatedListPropertyTearOff<PropertyType>> create(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& values)
    {
        ASSERT(contextElement);
        return adoptRef(*new SVGAnimatedListPropertyTearOff<PropertyType>(contextElement, attributeName, animatedPropertyType, values));

        ListProperty::detachListWrappersAndResize(&m_wrappers, newListSize);
    }

    RefPtr<SVGValue> currentAnimatedValue()
    {
        ASSERT(isAnimating());
        return m_animatedProperty->values();
    }

    const RefPtr<SVGValue> currentAnimatedValue() const
    {
        ASSERT(isAnimating());
        return m_animatedProperty->values();
    }

    const RefPtr<SVGValue> currentBaseValue() const
    {
        return m_values;
    }

    void animationStarted(RefPtr<SVGValue> newAnimVal)
    {
        ASSERT(!isAnimating());
        ASSERT(newAnimVal);
        ASSERT(static_cast<PropertyType&>(*currentBaseValue()).size() == m_wrappers.size());
        ASSERT(m_animatedWrappers.isEmpty());

        // Switch to new passed in value type & new wrappers list. The new wrappers list must be created for the new value.
        if (size_t size = static_cast<PropertyType&>(*newAnimVal).size())
            m_animatedWrappers.fill(0, size);

        m_animatedProperty = animVal();
        m_animatedProperty->setValuesAndWrappers(newAnimVal, &m_animatedWrappers);
        ASSERT(m_animatedProperty->valuesProperty().size() == m_animatedProperty->wrappers().size());
        ASSERT(m_animatedProperty->wrappers().size() == m_animatedWrappers.size());
    }

    void animationEnded()
    {
        ASSERT(isAnimating());
        ASSERT(static_cast<PropertyType&>(*currentBaseValue()).size() == m_wrappers.size());

        ASSERT(m_animatedProperty->valuesProperty().size() == m_animatedProperty->wrappers().size());
        ASSERT(m_animatedProperty->wrappers().size() == m_animatedWrappers.size());

        m_animatedProperty->setValuesAndWrappers(m_values, &m_wrappers);
        ASSERT(m_animatedProperty->valuesProperty().size() == m_animatedProperty->wrappers().size());
        ASSERT(m_animatedProperty->wrappers().size() == m_wrappers.size());

        m_animatedWrappers.clear();

        // Also existing wrappers which point directly at elements in the existing SVGLengthListValues have to be detached (so a copy
        // of them is created, so existing animVal variables in JS are kept-alive). If we'd detach them later the underlying
        // SVGLengthListValues was already mutated, and our list item wrapper tear offs would point nowhere. Assertions would fire.
        m_animatedProperty->detachListWrappers(m_animatedProperty->valuesProperty().size());

        ASSERT(m_animatedProperty->valuesProperty().size() == m_animatedProperty->wrappers().size());
        ASSERT(m_animatedProperty->wrappers().size() == m_animatedWrappers.size());
    }

    void animValWillChange()
    {
        ASSERT(static_cast<PropertyType&>(*currentBaseValue()).size() == m_wrappers.size());
        synchronizeWrappersIfNeeded();
    }

    void animValDidChange()
    {
        ASSERT(static_cast<PropertyType&>(*currentBaseValue()).size() == m_wrappers.size());
        synchronizeWrappersIfNeeded();
    }

protected:
    SVGAnimatedListPropertyTearOff(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& values)
        : SVGAnimatedProperty(contextElement, attributeName, animatedPropertyType)
        , m_values(values)
    {
        if (size_t size = static_cast<PropertyType&>(*values).size())
            m_wrappers.fill(0, size);
    }

    RefPtr<SVGValue> m_values;

    ListWrapperCache m_wrappers;
    ListWrapperCache m_animatedWrappers;



/*
 * Copyright (C) Research In Motion Limited 2010, 2012. All rights reserved.
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public

public:
    using Base = SVGAnimatedListPropertyTearOff<SVGPathSegListValues>;

    static Ref<SVGAnimatedPathSegListPropertyTearOff> create(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& values)
    {
        ASSERT(contextElement);
        return adoptRef(*new SVGAnimatedPathSegListPropertyTearOff(contextElement, attributeName, animatedPropertyType, values));

        ASSERT(!m_animatedPathByteStream);
        m_animatedPathByteStream = byteStream;

        auto copy = SVGValue::create(*baseValue);
        Base::animationStarted(copy.ptr());
        Base::animationStarted(copy, true);
    }

    void animationEnded()

        // If the animVal is observed from JS, we have to update it on each animation step.
        // This is an expensive operation and only done, if someone actually observes the animatedPathSegList() while an animation is running.
        if (pathElement->isAnimValObserved()) {
            auto& animatedList = static_cast<SVGPathSegListValues&>(*currentAnimatedValue());
            animatedList.clear();
            buildSVGPathSegListValuesFromByteStream(*m_animatedPathByteStream, *pathElement, animatedList, UnalteredParsing);
        }

    SVGPathByteStream* animatedPathByteStream() const { return m_animatedPathByteStream; }

private:
    SVGAnimatedPathSegListPropertyTearOff(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& values)
        : Base(contextElement, attributeName, animatedPropertyType, values)
        , m_animatedPathByteStream(nullptr)
    {




namespace WebCore {

class SVGValue;
class SVGElement;
class SVGProperty;


    virtual ~SVGAnimatedProperty();

    template<typename OwnerType, typename TearOffType, typename PropertyType>
    static Ref<TearOffType> lookupOrCreateWrapper(OwnerType* element, const SVGPropertyInfo* info, const RefPtr<SVGValue>& value)
    {
        ASSERT(info);
        SVGAnimatedPropertyDescription key(element, info->propertyIdentifier);

        if (!result.isNewEntry)
            return static_cast<TearOffType&>(*result.iterator->value);

        Ref<SVGAnimatedProperty> wrapper = TearOffType::create(element, info->attributeName, info->animatedPropertyType, value);
        if (info->animatedPropertyState == PropertyIsReadOnly)
            wrapper->setIsReadOnly();




 * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
 * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
 * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
 * Copyright (C) 2018 Apple Inc.  All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public

#include "SVGAnimatedProperty.h"
#include "SVGAttributeToPropertyMap.h"
#include "SVGPropertyTraits.h"
#include "SVGValue.h"
#include <wtf/NeverDestroyed.h>
#include <wtf/StdLibExtras.h>


template<typename PropertyType>
struct SVGSynchronizableAnimatedProperty {
    SVGSynchronizableAnimatedProperty()
        : value(SVGValue::create<PropertyType>())
        , shouldSynchronize(false)
        , isValid(false)
    {
    }

    SVGSynchronizableAnimatedProperty(const PropertyType& value)
        : value(SVGValue::create<PropertyType>(value))
        : value(value1)
        , shouldSynchronize(false)
        , isValid(false)
    {
    }

    template<typename ConstructorParameter1, typename ConstructorParameter2>
    SVGSynchronizableAnimatedProperty(const ConstructorParameter1& value1, const ConstructorParameter2& value2)
        : value(value1, value2)
        , shouldSynchronize(false)
        , isValid(false)
    {
    }


        ownerElement->setSynchronizedLazyAttribute(attrName, value);
    }

    RefPtr<SVGValue> value;
    bool shouldSynchronize { false };
    bool isValid { false };
};

// Property registration helpers

    { \
        if (auto wrapper = SVGAnimatedProperty::lookupWrapper<UseOwnerType, TearOffType>(this, LowerProperty##PropertyInfo())) { \
            if (wrapper->isAnimating()) \
                return static_cast<PropertyType&>(*wrapper->currentAnimatedValue()); \
        } \
        return static_cast<PropertyType&>(*m_##LowerProperty.value); \
    } \
\
    PropertyType& LowerProperty##BaseValue() const OverrideSpecifier \
    { \
        return static_cast<PropertyType&>(*m_##LowerProperty.value); \
    } \
\
    void set##UpperProperty##BaseValue(const PropertyType& value, const bool validValue = true) OverrideSpecifier \
    { \
        static_cast<PropertyType&>(*m_##LowerProperty.value) = value; \
        m_##LowerProperty.isValid = validValue; \
    } \
\

    { \
        if (!m_##LowerProperty.shouldSynchronize) \
            return; \
        AtomicString value(SVGPropertyTraits<PropertyType>::toString(static_cast<PropertyType&>(*m_##LowerProperty.value))); \
        m_##LowerProperty.synchronize(this, LowerProperty##PropertyInfo()->attributeName, value); \
    } \
\



    using PropertyType = typename PropertyTearOff::PropertyType;
    using ContentType = PropertyType;

    static Ref<SVGAnimatedPropertyTearOff<PropertyTearOff>> create(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& property)
    {
        ASSERT(contextElement);
        return adoptRef(*new SVGAnimatedPropertyTearOff<PropertyTearOff>(contextElement, attributeName, animatedPropertyType, property));


    bool isAnimating() const final { return m_animatedProperty; }

    RefPtr<SVGValue> currentAnimatedValue()
    {
        ASSERT(isAnimating());
        return m_animatedProperty->value();
    }

    const RefPtr<SVGValue> currentAnimatedValue() const
    {
        ASSERT(isAnimating());
        return m_animatedProperty->value();
    }

    const RefPtr<SVGValue> currentBaseValue() const
    {
        return m_property;
    }

    void animationStarted(const RefPtr<SVGValue>& newAnimVal)
    {
        ASSERT(!isAnimating());
        ASSERT(newAnimVal);
        m_animatedProperty = animVal();
        m_animatedProperty->setValue(newAnimVal);
    }

    void animationEnded()

    }

private:
    SVGAnimatedPropertyTearOff(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& property)
        : SVGAnimatedProperty(contextElement, attributeName, animatedPropertyType)
        , m_property(property)
    {
    }

    RefPtr<SVGValue> m_property;
    WeakPtr<SVGPropertyTearOff<PropertyType>> m_baseVal;
    WeakPtr<SVGPropertyTearOff<PropertyType>> m_animVal;





#include "ExceptionOr.h"
#include "SVGAnimatedProperty.h"
#include "SVGValue.h"

namespace WebCore {



    virtual const PropertyType& baseVal()
    {
        return static_cast<PropertyType&>(*m_property);
    }

    virtual const PropertyType& animVal()
    {
        if (m_animatedProperty)
            return static_cast<PropertyType&>(*m_animatedProperty);
        return baseVal();
    }

    virtual ExceptionOr<void> setBaseVal(const PropertyType& property)
    {
        static_cast<PropertyType&>(*m_property) = property;
        commitChange();
        return { };
    }

    bool isAnimating() const override { return m_animatedProperty; }

    static Ref<SVGAnimatedStaticPropertyTearOff<PropertyType>> create(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& property)
    {
        ASSERT(contextElement);
        return adoptRef(*new SVGAnimatedStaticPropertyTearOff<PropertyType>(contextElement, attributeName, animatedPropertyType, property));
    }

    RefPtr<SVGValue> currentAnimatedValue()
    {
        ASSERT(isAnimating());
        return m_animatedProperty;
    }

    const RefPtr<SVGValue> currentAnimatedValue() const
    {
        ASSERT(isAnimating());
        return m_animatedProperty;
    }

    const RefPtr<SVGValue> currentBaseValue() const
    {
        return m_property;
    }

    void animationStarted(RefPtr<SVGValue> newAnimVal)
    {
        ASSERT(!isAnimating());
        ASSERT(newAnimVal);

    }

protected:
    SVGAnimatedStaticPropertyTearOff(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& property)
        : SVGAnimatedProperty(contextElement, attributeName, animatedPropertyType)
        , m_property(property)
        , m_animatedProperty(nullptr)
    {
        ASSERT_IMPLIES(m_property, m_property->is<PropertyType>());
    }

private:
    RefPtr<SVGValue> m_property;
    RefPtr<SVGValue> m_animatedProperty;
};

}




class SVGAnimatedTransformListPropertyTearOff final : public SVGAnimatedListPropertyTearOff<SVGTransformListValues> {
public:
    static Ref<SVGAnimatedTransformListPropertyTearOff> create(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& values)
    {
        ASSERT(contextElement);
        return adoptRef(*new SVGAnimatedTransformListPropertyTearOff(contextElement, attributeName, animatedPropertyType, values));

    }

private:
    SVGAnimatedTransformListPropertyTearOff(SVGElement* contextElement, const QualifiedName& attributeName, AnimatedPropertyType animatedPropertyType, const RefPtr<SVGValue>& values)
        : SVGAnimatedListPropertyTearOff<SVGTransformListValues>(contextElement, attributeName, animatedPropertyType, values)
    {
    }




namespace WebCore {

enum ListModification {
    ListModificationUnknown = 0,
    ListModificationInsert = 1,
    ListModificationReplace = 2,
    ListModificationRemove = 3,
    ListModificationAppend = 4
};

template<typename PropertyType>
class SVGAnimatedListPropertyTearOff;


        detachListWrappersAndResize(m_wrappers, newListSize);
    }

    void setValuesAndWrappers(const RefPtr<SVGValue>& values, ListWrapperCache* wrappers)
    {
        // This is only used for animVal support, to switch the underlying values & wrappers
        // to the current animated values, once animation for a list starts.
        ASSERT(m_values);
        ASSERT(m_wrappers);
        ASSERT(m_role == AnimValRole);
        if (m_ownsValues)
            delete m_values;
        m_values = values;
        m_ownsValues = shouldOwnValues;
        m_wrappers = wrappers;
        ASSERT(valuesProperty().size() == m_wrappers->size());
    }

    // SVGList::clear()

            return result.releaseException();
        ASSERT(result.releaseReturnValue());

        valuesProperty().clear();
        commitChange();
        return { };
    }

        ASSERT(result.releaseReturnValue());

        detachListWrappers(0);
        valuesProperty().clear();
        commitChange();
        return { };
    }

    // SVGList::numberOfItems()
    unsigned numberOfItems() const
    {
        return valuesProperty().size();
    }

    // SVGList::initialize()

        processIncomingListItemValue(newItem, 0);

        // Spec: Clears all existing current items from the list and re-initializes the list to hold the single item specified by the parameter.
        valuesProperty().clear();
        valuesProperty().append(SVGValue::create<ListItemType>(newItem));

        commitChange();
        return ListItemType { newItem };

            return result.releaseException();
        ASSERT(result.releaseReturnValue());

        ASSERT(valuesProperty().size() == m_wrappers->size());

        Ref<ListItemTearOff> newItem(item);



        // Spec: Clears all existing current items from the list and re-initializes the list to hold the single item specified by the parameter.
        detachListWrappers(0);
        valuesProperty().clear();

        valuesProperty().append(newItem->value());
        m_wrappers->append(newItem->createWeakPtr());

        commitChange();

    // SVGList::getItem()
    ExceptionOr<bool> canGetItem(unsigned index)
    {
        if (index >= valuesProperty().size())
            return Exception { IndexSizeError };

        return true;

        ASSERT(result.releaseReturnValue());

        // Spec: Returns the specified item from the list. The returned item is the item itself and not a copy.
        return ListItemType { static_cast<ListItemType&>(*valuesProperty().at(index)) };
    }

    ExceptionOr<Ref<ListItemTearOff>> getItemValuesAndWrappers(AnimatedListPropertyTearOff& animatedList, unsigned index)


        // Spec: Returns the specified item from the list. The returned item is the item itself and not a copy.
        // Any changes made to the item are immediately reflected in the list.
        ASSERT(valuesProperty().size() == m_wrappers->size());
        RefPtr<ListItemTearOff> wrapper = static_cast<ListItemTearOff*>(m_wrappers->at(index).get());
        if (!wrapper) {
            // Create new wrapper, which is allowed to directly modify the item in the list, w/o copying and cache the wrapper in our map.
            // It is also associated with our animated property, so it can notify the SVG Element which holds the SVGAnimated*List
            // that it has been modified (and thus can call svgAttributeChanged(associatedAttributeName)).
            wrapper = ListItemTearOff::create(animatedList, UndefinedRole, valuesProperty().at(index));
            m_wrappers->at(index) = wrapper->createWeakPtr();
        }


        ASSERT(result.releaseReturnValue());

        // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.
        if (index > valuesProperty().size())
            index = valuesProperty().size();

        // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
        if (!processIncomingListItemValue(newItem, &index)) {


        // Spec: Inserts a new item into the list at the specified position. The index of the item before which the new item is to be
        // inserted. The first item is number 0. If the index is equal to 0, then the new item is inserted at the front of the list.
        valuesProperty().insert(index, SVGValue::create<ListItemType>(newItem));

        commitChange();
        return ListItemType { newItem };

        ASSERT(result.releaseReturnValue());

        // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.
        if (index > valuesProperty().size())
            index = valuesProperty().size();

        ASSERT(valuesProperty().size() == m_wrappers->size());

        Ref<ListItemTearOff> newItem(item);



        // Spec: Inserts a new item into the list at the specified position. The index of the item before which the new item is to be
        // inserted. The first item is number 0. If the index is equal to 0, then the new item is inserted at the front of the list.
        valuesProperty().insert(index, newItem->value());

        // Store new wrapper at position 'index', change its underlying value, so mutations of newItem, directly affect the item in the list.
        m_wrappers->insert(index, newItem->createWeakPtr());

            return result.releaseException();
        ASSERT(result.releaseReturnValue());

        if (index >= valuesProperty().size())
            return Exception { IndexSizeError };

        return true;

            return ListItemType { newItem };
        }

        if (valuesProperty().isEmpty()) {
            // 'newItem' already lived in our list, we removed it, and now we're empty, which means there's nothing to replace.
            return Exception { IndexSizeError };
        }

        // Update the value at the desired position 'index'. 
        static_cast<ListItemType&>(*valuesProperty().at(index)) = newItem;

        commitChange();
        return ListItemType { newItem };

            return result.releaseException();
        ASSERT(result.releaseReturnValue());

        ASSERT(valuesProperty().size() == m_wrappers->size());

        Ref<ListItemTearOff> newItem(item);


        if (!processIncomingListItemWrapper(newItem, &index))
            return WTFMove(newItem);

        if (valuesProperty().isEmpty()) {
            ASSERT(m_wrappers->isEmpty());
            // 'newItem' already lived in our list, we removed it, and now we're empty, which means there's nothing to replace.
            return Exception { IndexSizeError };

            oldItem->detachWrapper();

        // Update the value and the wrapper at the desired position 'index'. 
        valuesProperty().at(index) = newItem->value();
        m_wrappers->at(index) = newItem->createWeakPtr();

        commitChange();

            return result.releaseException();
        ASSERT(result.releaseReturnValue());

        if (index >= valuesProperty().size())
            return Exception { IndexSizeError };

        return true;

            return result.releaseException();
        ASSERT(result.releaseReturnValue());

        ListItemType oldItem = static_cast<ListItemType&>(*valuesProperty().at(index));
        valuesProperty().remove(index);

        commitChange();
        return WTFMove(oldItem);

            return result.releaseException();
        ASSERT(result.releaseReturnValue());

        ASSERT(valuesProperty().size() == m_wrappers->size());

        // Detach the existing wrapper.
        RefPtr<ListItemTearOff> oldItem = static_cast<ListItemTearOff*>(m_wrappers->at(index).get());
        if (!oldItem)
            oldItem = ListItemTearOff::create(animatedList, UndefinedRole, valuesProperty().at(index));

        oldItem->detachWrapper();
        m_wrappers->remove(index);
        valuesProperty().remove(index);

        commitChange();
        return oldItem.releaseNonNull();

        processIncomingListItemValue(newItem, 0);

        // Append the value at the end of the list.
        valuesProperty().append(SVGValue::create<ListItemType>(newItem));

        commitChange(ListModificationAppend);
        return ListItemType { newItem };

            return result.releaseException();
        ASSERT(result.releaseReturnValue());

        ASSERT(valuesProperty().size() == m_wrappers->size());

        Ref<ListItemTearOff> newItem(item);


        processIncomingListItemWrapper(newItem, 0);

        // Append the value and wrapper at the end of the list.
        valuesProperty().append(newItem->value());
        m_wrappers->append(newItem->createWeakPtr());

        commitChange(ListModificationAppend);
        return WTFMove(newItem);
    }

    Ref<SVGValue> values() const
    {
        ASSERT(m_values);
        return *m_values;
    }

    PropertyType& valuesProperty() const
    {
        ASSERT(m_values);
        return static_cast<PropertyType&>(*m_values);
    }

    ListWrapperCache& wrappers() const
    {
        ASSERT(m_wrappers);

    }

protected:
    SVGListProperty(SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache* wrappers)
        : m_role(role)
        , m_values(values)
        , m_values(&values)
        , m_wrappers(wrappers)
    {
    }

    virtual ~SVGListProperty()
    {
        if (m_ownsValues)
            delete m_values;
    }

    void commitChange() override = 0;
    virtual void commitChange(ListModification)
    {

    virtual bool processIncomingListItemWrapper(Ref<ListItemTearOff>& newItem, unsigned* indexToModify) = 0;

    SVGPropertyRole m_role;
    RefPtr<SVGValue> m_values;
    PropertyType* m_values;
    ListWrapperCache* m_wrappers;
    WeakPtrFactory<SVGListProperty> m_weakPtrFactory;
};



    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<PropertyType>;
    using ListWrapperCache = typename SVGAnimatedListPropertyTearOff<PropertyType>::ListWrapperCache;

    using Base::valuesProperty;
    using Base::m_role;
    using Base::m_values;
    using Base::m_wrappers;

    static Ref<Self> create(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
    {
        return adoptRef(*new Self(animatedProperty, role, values, wrappers));
    }

    int findItem(ListItemTearOff* item) const
    {
        ASSERT(m_values);
        ASSERT(m_wrappers);

        unsigned size = m_wrappers->size();
        ASSERT(size == valuesProperty().size());
        for (size_t i = 0; i < size; ++i) {
            if (item == m_wrappers->at(i))
                return i;


    void removeItemFromList(size_t itemIndex, bool shouldSynchronizeWrappers)
    {
        ASSERT(m_values);
        ASSERT(m_wrappers);
        ASSERT(valuesProperty().size() == m_wrappers->size());
        ASSERT_WITH_SECURITY_IMPLICATION(itemIndex < m_wrappers->size());

        auto item = m_wrappers->at(itemIndex);
        item->detachWrapper();
        m_wrappers->remove(itemIndex);
        valuesProperty().remove(itemIndex);

        if (shouldSynchronizeWrappers)
            commitChange();

    }

protected:
    SVGListPropertyTearOff(AnimatedListPropertyTearOff& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& values, ListWrapperCache& wrappers)
        : SVGListProperty<PropertyType>(role, values, &wrappers)
        , m_animatedProperty(animatedProperty)
    {


    void commitChange() override
    {
        ASSERT(m_values);
        ASSERT(m_wrappers);

        // Update existing wrappers, as the index in the values list has changed.
        unsigned size = m_wrappers->size();
        ASSERT(size == valuesProperty().size());
        for (unsigned i = 0; i < size; ++i) {
            auto item = m_wrappers->at(i);
            if (!item)
                continue;
            item->setAnimatedProperty(m_animatedProperty.ptr());
            item->setValue(valuesProperty().at(i));
        }

        m_animatedProperty->commitChange();

Lines 36-42 public: Source/WebCore/svg/properties/SVGMatrixTearOff.h_sec1
- Source/WebCore/svg/properties/SVGMatrixTearOff.h -1 / +1 lines
36		36
37	SVGMatrixValue& propertyReference() final { return m_parent->propertyReference().svgMatrix(); }	37	SVGMatrixValue& propertyReference() final { return m_parent->propertyReference().svgMatrix(); }
38		38
39	void setValue(SVGMatrixValue& value) final { m_parent->propertyReference().setMatrix(value); }	39	void setValue(const RefPtr<SVGValue>& value) final { m_parent->propertyReference().setMatrix(static_cast<SVGMatrixValue&>(*value)); }
40		40
41	void commitChange() final	41	void commitChange() final
42	{	42	{



#include "ExceptionOr.h"
#include "SVGAnimatedProperty.h"
#include "SVGProperty.h"
#include "SVGValue.h"
#include <wtf/WeakPtr.h>

namespace WebCore {

        return create(initialValue.releaseReturnValue());
    }

    RefPtr<SVGValue> value() const { return m_value; }
    virtual PropertyType& propertyReference() { return static_cast<PropertyType&>(*m_value); }
    SVGAnimatedProperty* animatedProperty() const { return m_animatedProperty.get(); }

    virtual void setValue(const RefPtr<SVGValue>& value)
    {
        if (m_valueIsCopy)
            detachChildren();
            delete m_value;
        }
        m_valueIsCopy = false;
        m_value = value;
    }

    void setAnimatedProperty(SVGAnimatedProperty* animatedProperty)

        // item.value still has to report '50' and it has to be possible to modify 'item'
        // w/o changing the "new item" (with x=100) in the text element.
        // Whenever the XML DOM modifies the "x" attribute, all existing wrappers are detached, using this function.
        m_value = SVGValue::create(static_cast<PropertyType&>(*m_value));
        m_valueIsCopy = true;
        m_animatedProperty = nullptr;
    }

    }

protected:
    SVGPropertyTearOff(SVGAnimatedProperty* animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
        : m_animatedProperty(animatedProperty)
        , m_role(role)
        , m_value(value)
        , m_valueIsCopy(false)
    {
    }

    SVGPropertyTearOff(const PropertyType* initialValue)
        : m_animatedProperty(nullptr)
        , m_role(UndefinedRole)
        , m_value(initialValue ? new PropertyType(*initialValue) : nullptr)
        , m_valueIsCopy(true)
    {
        if (initialValue)
            m_value = SVGValue::create(*initialValue);
    }

    virtual ~SVGPropertyTearOff()
    {
        if (m_valueIsCopy)
            detachChildren();
            delete m_value;
        }
    }

    void detachChildren()


    RefPtr<SVGAnimatedProperty> m_animatedProperty;
    SVGPropertyRole m_role;
    RefPtr<SVGValue> m_value;
    Vector<WeakPtr<SVGPropertyTearOffBase>> m_childTearOffs;
    WeakPtrFactory<SVGPropertyTearOff> m_weakPtrFactory;
    bool m_valueIsCopy { false };
};

}




#pragma once

#include "CSSParser.h"
#include "Color.h"
#include "FloatPoint.h"
#include "FloatRect.h"
#include "QualifiedName.h"
#include "SVGParserUtilities.h"
#include <wtf/text/StringBuilder.h>
#include <wtf/text/WTFString.h>

namespace WebCore {

enum ListModification {
    ListModificationUnknown = 0,
    ListModificationInsert = 1,
    ListModificationReplace = 2,
    ListModificationRemove = 3,
    ListModificationAppend = 4
};
    
template<typename PropertyType>
struct SVGPropertyTraits { };

template<>
struct SVGPropertyTraits<bool> {
    static bool initialValue() { return false; }
    static bool fromString(const String& string) { return string == "true"; }
    static String toString(bool type) { return type ? "true" : "false"; }
};

template<>
struct SVGPropertyTraits<Color> {
    static Color initialValue() { return Color(); }
    static Color fromString(const String& string) { return CSSParser::parseColor(string.stripWhiteSpace()); }
    static std::optional<Color> parse(const QualifiedName&, const String& string)
    {
        Color color = CSSParser::parseColor(string.stripWhiteSpace());
        return color.isValid() ? color : std::optional<Color>();
    }
    static String toString(const Color& type) { return type.serialized(); }
};

template<>
struct SVGPropertyTraits<unsigned> {
    static unsigned initialValue() { return 0; }
    static String toString(unsigned type) { return String::number(type); }

template<>
struct SVGPropertyTraits<int> {
    static int initialValue() { return 0; }
    static int fromString(const String&string) { return string.toIntStrict(); }
    static String toString(int type) { return String::number(type); }
};
    
template<>
struct SVGPropertyTraits<std::pair<int, int>> {
    static std::pair<int, int> initialValue() { return { }; }
    static std::pair<int, int> fromString(const String& string)
    {
        float firstNumber = 0, secondNumber = 0;
        if (!parseNumberOptionalNumber(string, firstNumber, secondNumber))
            return { };
        
        return std::make_pair(static_cast<int>(roundf(firstNumber)), static_cast<int>(roundf(secondNumber)));
    }
};

template<>
struct SVGPropertyTraits<float> {
    static float initialValue() { return 0; }
    static float fromString(const String& string)
    {
        float type = 0;
        return parseNumberFromString(string, type) ? type : 0;
    }
    static std::optional<float> parse(const QualifiedName&, const String& string)
    {
        float number;
        return parseNumberFromString(string, number) ? number : std::optional<float>();
    }
    static String toString(float type) { return String::number(type); }
};

template<>
struct SVGPropertyTraits<std::pair<float, float>> {
    static std::pair<float, float> initialValue() { return { }; }
    static std::pair<float, float> fromString(const String& string)
    {
        float firstNumber = 0, secondNumber = 0;
        if (!parseNumberOptionalNumber(string, firstNumber, secondNumber))
            return { };

        return std::make_pair(firstNumber, secondNumber);
    }
};

template<>
struct SVGPropertyTraits<FloatPoint> {
    static FloatPoint initialValue() { return FloatPoint(); }
    static FloatPoint fromString(const String& string)
    {
        FloatPoint point;
        return parsePoint(string, point) ? point : FloatPoint();
    }
    static std::optional<FloatPoint> parse(const QualifiedName&, const String& string)
    {
        FloatPoint point;
        return parsePoint(string, point) ? point : std::optional<FloatPoint>();
    }
    static String toString(const FloatPoint& type)
    {
        StringBuilder builder;
        builder.appendNumber(type.x());
        builder.append(' ');
        builder.appendNumber(type.y());
        return builder.toString();
    }
};

template<>
struct SVGPropertyTraits<FloatRect> {
    static FloatRect initialValue() { return FloatRect(); }
    static FloatRect fromString(const String& string)
    {
        FloatRect rect;
        return parseRect(string, rect) ? rect : FloatRect();
        
    }
    static std::optional<FloatRect> parse(const QualifiedName&, const String& string)
    {
        FloatRect rect;
        return parseRect(string, rect) ? rect : std::optional<FloatRect>();
    }
    static String toString(const FloatRect& type)
    {
        StringBuilder builder;
        builder.appendNumber(type.x());
        builder.append(' ');
        builder.appendNumber(type.y());
        builder.append(' ');
        builder.appendNumber(type.width());
        builder.append(' ');
        builder.appendNumber(type.height());
        return builder.toString();
    }
};

template<>
struct SVGPropertyTraits<String> {
    static String initialValue() { return String(); }
    static String fromString(const String& string) { return string; }
    static std::optional<String> parse(const QualifiedName&, const String& string) { return string; }
    static String toString(const String& string) { return string; }
};

template<typename EnumType>



    using ListItemTearOff = typename SVGPropertyTraits<PropertyType>::ListItemTearOff;

    using Base::m_role;
    using Base::valuesProperty;

    static Ref<Self> create(SVGElement& contextElement, PropertyType& values)
    {

    }

protected:
    SVGStaticListPropertyTearOff(SVGElement* contextElement, const RefPtr<SVGValue>& values)
        : Base(UndefinedRole, values, nullptr)
        , m_contextElement(*contextElement)
    {


    void commitChange() override
    {
        valuesProperty().commitChange(m_contextElement);
        m_values->commitChange(m_contextElement);
    }

    bool processIncomingListItemValue(const ListItemType&, unsigned*) override




    // Used for non-animated POD types that are not associated with a SVGAnimatedProperty object, nor with a XML DOM attribute
    // (for example: SVGSVGElement::currentTranslate).
    static Ref<Self> create(ContextElement& contextElement, const RefPtr<SVGValue>& value, UpdateMethod update)
    {
        return adoptRef(*new Self(contextElement, value, update));
    }

    void commitChange() final { (m_contextElement.get()->*m_update)(); }

private:
    SVGStaticPropertyTearOff(ContextElement& contextElement, const RefPtr<SVGValue>& value, UpdateMethod update)
        : PropertyTearOff(UndefinedRole, value)
        , m_update(update)
        , m_contextElement(&contextElement)

Return to Bug 168586

Lines 2071-2077 svg/SVGAnimatedPreserveAspectRatio.cpp Source/WebCore/Sources.txt_sec1
- Source/WebCore/Sources.txt -1 / +1 lines
2071	svg/SVGAnimatedRect.cpp	2071	svg/SVGAnimatedRect.cpp
2072	svg/SVGAnimatedString.cpp	2072	svg/SVGAnimatedString.cpp
2073	svg/SVGAnimatedTransformList.cpp	2073	svg/SVGAnimatedTransformList.cpp
2074	svg/SVGAnimatedType.cpp
2075	svg/SVGAnimatedTypeAnimator.cpp	2074	svg/SVGAnimatedTypeAnimator.cpp
2076	svg/SVGAnimationElement.cpp	2075	svg/SVGAnimationElement.cpp
2077	svg/SVGCircleElement.cpp	2076	svg/SVGCircleElement.cpp
Lines 2135-2140 svg/SVGLengthListValues.cpp Source/WebCore/Sources.txt_sec2
2135	svg/SVGLengthValue.cpp	2134	svg/SVGLengthValue.cpp
2136	svg/SVGLineElement.cpp	2135	svg/SVGLineElement.cpp
2137	svg/SVGLinearGradientElement.cpp	2136	svg/SVGLinearGradientElement.cpp
		2137	svg/SVGListValues.cpp
2138	svg/SVGLocatable.cpp	2138	svg/SVGLocatable.cpp
2139	svg/SVGMPathElement.cpp	2139	svg/SVGMPathElement.cpp
2140	svg/SVGMarkerElement.cpp	2140	svg/SVGMarkerElement.cpp

Lines 100-115 static Path pathFromPathElement(SVGEleme Source/WebCore/rendering/svg/SVGPathData.cpp_sec1
- Source/WebCore/rendering/svg/SVGPathData.cpp -6 / +6 lines
100		100
101	static Path pathFromPolygonElement(SVGElement& element)	101	static Path pathFromPolygonElement(SVGElement& element)
102	{	102	{
103	auto& points = downcast<SVGPolygonElement>(element).animatedPoints()->values();	103	auto& points = downcast<SVGPolygonElement>(element).animatedPoints()->valuesProperty();
104	if (points.isEmpty())	104	if (points.isEmpty())
105	return { };	105	return { };
106		106
107	Path path;	107	Path path;
108	path.moveTo(points.first());	108	path.moveTo(points.firstProperty());
109		109
110	unsigned size = points.size();	110	unsigned size = points.size();
111	for (unsigned i = 1; i < size; ++i)	111	for (unsigned i = 1; i < size; ++i)
112	path.addLineTo(points.at(i));	112	path.addLineTo(points.propertyAt(i));
113		113
114	path.closeSubpath();	114	path.closeSubpath();
115	return path;	115	return path;
Lines 117-132 static Path pathFromPolygonElement(SVGEl Source/WebCore/rendering/svg/SVGPathData.cpp_sec2
117		117
118	static Path pathFromPolylineElement(SVGElement& element)	118	static Path pathFromPolylineElement(SVGElement& element)
119	{	119	{
120	auto& points = downcast<SVGPolylineElement>(element).animatedPoints()->values();	120	auto& points = downcast<SVGPolylineElement>(element).animatedPoints()->valuesProperty();
121	if (points.isEmpty())	121	if (points.isEmpty())
122	return { };	122	return { };
123		123
124	Path path;	124	Path path;
125	path.moveTo(points.first());	125	path.moveTo(points.firstProperty());
126		126
127	unsigned size = points.size();	127	unsigned size = points.size();
128	for (unsigned i = 1; i < size; ++i)	128	for (unsigned i = 1; i < size; ++i)
129	path.addLineTo(points.at(i));	129	path.addLineTo(points.propertyAt(i));
130	return path;	130	return path;
131	}	131	}
132		132

Lines 163-177 void SVGTextLayoutAttributesBuilder::bui Source/WebCore/rendering/svg/SVGTextLayoutAttributesBuilder.cpp_sec1
- Source/WebCore/rendering/svg/SVGTextLayoutAttributesBuilder.cpp -5 / +5 lines
163	static inline void updateCharacterData(unsigned i, float& lastRotation, SVGCharacterData& data, const SVGLengthContext& lengthContext, const SVGLengthListValues* xList, const SVGLengthListValues* yList, const SVGLengthListValues* dxList, const SVGLengthListValues* dyList, const SVGNumberListValues* rotateList)	163	static inline void updateCharacterData(unsigned i, float& lastRotation, SVGCharacterData& data, const SVGLengthContext& lengthContext, const SVGLengthListValues* xList, const SVGLengthListValues* yList, const SVGLengthListValues* dxList, const SVGLengthListValues* dyList, const SVGNumberListValues* rotateList)
164	{	164	{
165	if (xList)	165	if (xList)
166	data.x = xList->at(i).value(lengthContext);	166	data.x = xList->propertyAt(i).value(lengthContext);
167	if (yList)	167	if (yList)
168	data.y = yList->at(i).value(lengthContext);	168	data.y = yList->propertyAt(i).value(lengthContext);
169	if (dxList)	169	if (dxList)
170	data.dx = dxList->at(i).value(lengthContext);	170	data.dx = dxList->propertyAt(i).value(lengthContext);
171	if (dyList)	171	if (dyList)
172	data.dy = dyList->at(i).value(lengthContext);	172	data.dy = dyList->propertyAt(i).value(lengthContext);
173	if (rotateList) {	173	if (rotateList) {
174	data.rotate = rotateList->at(i);	174	data.rotate = rotateList->propertyAt(i);
175	lastRotation = data.rotate;	175	lastRotation = data.rotate;
176	}	176	}
177	}	177	}

Lines 32-38 namespace WebCore { Source/WebCore/svg/SVGAngle.h_sec1
- Source/WebCore/svg/SVGAngle.h -12 / +2 lines
32		32
33	class SVGAngle : public SVGPropertyTearOff<SVGAngleValue> {	33	class SVGAngle : public SVGPropertyTearOff<SVGAngleValue> {
34	public:	34	public:
35	static Ref<SVGAngle> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, SVGAngleValue& value)	35	static Ref<SVGAngle> create(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
36	{	36	{
37	return adoptRef(*new SVGAngle(animatedProperty, role, value));	37	return adoptRef(*new SVGAngle(animatedProperty, role, value));
38	}	38	}
Lines 42-52 public: Source/WebCore/svg/SVGAngle.h_sec2
42	return adoptRef(*new SVGAngle(initialValue));	42	return adoptRef(*new SVGAngle(initialValue));
43	}	43	}
44		44
45	static Ref<SVGAngle> create(const SVGAngleValue* initialValue)
46	{
47	return adoptRef(*new SVGAngle(initialValue));
48	}
49
50	template<typename T> static ExceptionOr<Ref<SVGAngle>> create(ExceptionOr<T>&& initialValue)	45	template<typename T> static ExceptionOr<Ref<SVGAngle>> create(ExceptionOr<T>&& initialValue)
51	{	46	{
52	if (initialValue.hasException())	47	if (initialValue.hasException())
Lines 136-142 public: Source/WebCore/svg/SVGAngle.h_sec3
136	}	131	}
137		132
138	private:	133	private:
139	SVGAngle(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, SVGAngleValue& value)	134	SVGAngle(SVGAnimatedProperty& animatedProperty, SVGPropertyRole role, const RefPtr<SVGValue>& value)
140	: SVGPropertyTearOff<SVGAngleValue>(&animatedProperty, role, value)	135	: SVGPropertyTearOff<SVGAngleValue>(&animatedProperty, role, value)
141	{	136	{
142	}	137	}
Lines 145-155 private: Source/WebCore/svg/SVGAngle.h_sec4
145	: SVGPropertyTearOff<SVGAngleValue>(initialValue)	140	: SVGPropertyTearOff<SVGAngleValue>(initialValue)
146	{	141	{
147	}	142	}
148
149	explicit SVGAngle(const SVGAngleValue* initialValue)
150	: SVGPropertyTearOff<SVGAngleValue>(initialValue)
151	{
152	}
153	};	143	};
154		144
155	} // namespace WebCore	145	} // namespace WebCore

Lines 136-166 void SVGAnimateMotionElement::updateAnim Source/WebCore/svg/SVGAnimateMotionElement.cpp_sec1
- Source/WebCore/svg/SVGAnimateMotionElement.cpp -25 lines
136	updateAnimationMode();	136	updateAnimationMode();
137	}	137	}
138		138
139	static bool parsePoint(const String& s, FloatPoint& point)
140	{
141	if (s.isEmpty())
142	return false;
143	auto upconvertedCharacters = StringView(s).upconvertedCharacters();
144	const UChar* cur = upconvertedCharacters;
145	const UChar* end = cur + s.length();
146
147	if (!skipOptionalSVGSpaces(cur, end))
148	return false;
149
150	float x = 0;
151	if (!parseNumber(cur, end, x))
152	return false;
153
154	float y = 0;
155	if (!parseNumber(cur, end, y))
156	return false;
157
158	point = FloatPoint(x, y);
159
160	// disallow anything except spaces at the end
161	return !skipOptionalSVGSpaces(cur, end);
162	}
163
164	void SVGAnimateMotionElement::resetAnimatedType()	139	void SVGAnimateMotionElement::resetAnimatedType()
165	{	140	{
166	if (!hasValidAttributeType())	141	if (!hasValidAttributeType())

Lines 32-53 SVGAnimatedAngleAnimator::SVGAnimatedAng Source/WebCore/svg/SVGAnimatedAngle.cpp_sec1
- Source/WebCore/svg/SVGAnimatedAngle.cpp -42 / +33 lines
32		32
33	std::unique_ptr<SVGAnimatedType> SVGAnimatedAngleAnimator::constructFromString(const String& string)	33	std::unique_ptr<SVGAnimatedType> SVGAnimatedAngleAnimator::constructFromString(const String& string)
34	{	34	{
35	auto animatedType = SVGAnimatedType::createAngleAndEnumeration(std::make_unique<std::pair<SVGAngleValue, unsigned>>());	35	return SVGAnimatedType::create(SVGPropertyTraits<std::pair<SVGAngleValue, unsigned>>::fromString(string));
36	auto& animatedPair = animatedType->angleAndEnumeration();
37
38	SVGAngleValue angle;
39	SVGMarkerOrientType orientType = SVGPropertyTraits<SVGMarkerOrientType>::fromString(string, angle);
40	if (orientType > 0)
41	animatedPair.second = orientType;
42	if (orientType == SVGMarkerOrientAngle)
43	animatedPair.first = angle;
44
45	return animatedType;
46	}	36	}
47		37
48	std::unique_ptr<SVGAnimatedType> SVGAnimatedAngleAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	38	std::unique_ptr<SVGAnimatedType> SVGAnimatedAngleAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
49	{	39	{
50	return SVGAnimatedType::createAngleAndEnumeration(constructFromBaseValues<SVGAnimatedAngle, SVGAnimatedEnumeration>(animatedTypes));	40	return constructFromBaseValues<SVGAnimatedAngle, SVGAnimatedEnumeration>(animatedTypes);
51	}	41	}
52		42
53	void SVGAnimatedAngleAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	43	void SVGAnimatedAngleAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 57-63 void SVGAnimatedAngleAnimator::stopAnimV Source/WebCore/svg/SVGAnimatedAngle.cpp_sec2
57		47
58	void SVGAnimatedAngleAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	48	void SVGAnimatedAngleAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
59	{	49	{
60	resetFromBaseValues<SVGAnimatedAngle, SVGAnimatedEnumeration>(animatedTypes, type, &SVGAnimatedType::angleAndEnumeration);	50	resetFromBaseValues<SVGAnimatedAngle, SVGAnimatedEnumeration>(animatedTypes, type);
61	}	51	}
62		52
63	void SVGAnimatedAngleAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	53	void SVGAnimatedAngleAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 75-87 void SVGAnimatedAngleAnimator::addAnimat Source/WebCore/svg/SVGAnimatedAngle.cpp_sec3
75	ASSERT(from->type() == AnimatedAngle);	65	ASSERT(from->type() == AnimatedAngle);
76	ASSERT(from->type() == to->type());	66	ASSERT(from->type() == to->type());
77		67
78	const auto& fromAngleAndEnumeration = from->angleAndEnumeration();	68	const auto& fromAngle = static_cast<SVGAngleValue&>(*from->values[0]);
79	auto& toAngleAndEnumeration = to->angleAndEnumeration();	69	const auto& fromEnumeration = static_cast<unsigned&>(*from->values[1]);
		70	auto& toAngle = static_cast<SVGAngleValue&>(*to->values[0]);
		71	auto& toEnumeration = static_cast<unsigned&>(*to->values[1]);
80	// Only respect by animations, if from and by are both specified in angles (and not eg. 'auto').	72	// Only respect by animations, if from and by are both specified in angles (and not eg. 'auto').
81	if (fromAngleAndEnumeration.second != toAngleAndEnumeration.second \|\| fromAngleAndEnumeration.second != SVGMarkerOrientAngle)	73	if (fromEnumeration != toEnumeration \|\| fromEnumeration != SVGMarkerOrientAngle)
82	return;	74	return;
83	const auto& fromAngle = fromAngleAndEnumeration.first;
84	auto& toAngle = toAngleAndEnumeration.first;
85	toAngle.setValue(toAngle.value() + fromAngle.value());	75	toAngle.setValue(toAngle.value() + fromAngle.value());
86	}	76	}
87		77
Lines 90-137 void SVGAnimatedAngleAnimator::calculate Source/WebCore/svg/SVGAnimatedAngle.cpp_sec4
90	ASSERT(m_animationElement);	80	ASSERT(m_animationElement);
91	ASSERT(m_contextElement);	81	ASSERT(m_contextElement);
92		82
93	const auto& fromAngleAndEnumeration = m_animationElement->animationMode() == ToAnimation ? animated->angleAndEnumeration() : from->angleAndEnumeration();	83	const auto& fromAngle = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGAngleValue&>(animated->values[0]) : static_cast<SVGAngleValue&>(from->values[0]);
94	auto& toAngleAndEnumeration = to->angleAndEnumeration();	84	const auto& fromEnumeration = m_animationElement->animationMode() == ToAnimation ? static_cast<unsigned&>(animated->values[1]) : static_cast<unsigned&>(from->values[1]);
95	auto& toAtEndOfDurationAngleAndEnumeration = toAtEndOfDuration->angleAndEnumeration();	85	auto& toAngle = static_cast<SVGAngleValue&>(*to->values[0]);
96	auto& animatedAngleAndEnumeration = animated->angleAndEnumeration();	86	auto& toEnumeration = static_cast<unsigned&>(*to->values[1]);
		87	auto& toAtEndOfDurationAngle = static_cast<SVGAngleValue&>(*toAtEndOfDuration->values[0]);
		88	auto& animatedAngle = static_cast<SVGAngleValue&>(*animated->values[0]);
		89	auto& animatedEnumeration = static_cast<unsigned&>(*animated->values[1]);
97		90
98	if (fromAngleAndEnumeration.second != toAngleAndEnumeration.second) {	91	if (fromEnumeration != toEnumeration) {
99	// Discrete animation - no linear interpolation possible between values (e.g. auto to angle).	92	// Discrete animation - no linear interpolation possible between values (e.g. auto to angle).
100	if (percentage < 0.5f) {	93	if (percentage < 0.5f) {
101	animatedAngleAndEnumeration.second = fromAngleAndEnumeration.second;	94	animatedEnumeration = fromEnumeration;
102	if (fromAngleAndEnumeration.second == SVGMarkerOrientAngle)	95	if (fromEnumeration == SVGMarkerOrientAngle)
103	animatedAngleAndEnumeration.first = fromAngleAndEnumeration.first;	96	animatedAngle = fromAngle;
104	else	97	else
105	animatedAngleAndEnumeration.first.setValue(0);	98	animatedAngle.setValue(0);
106	return;	99	return;
107	}	100	}
108	animatedAngleAndEnumeration.second = toAngleAndEnumeration.second;	101	animatedEnumeration = toEnumeration;
109	if (toAngleAndEnumeration.second == SVGMarkerOrientAngle)	102	if (toEnumeration == SVGMarkerOrientAngle)
110	animatedAngleAndEnumeration.first = toAngleAndEnumeration.first;	103	animatedAngle = toAngle;
111	else	104	else
112	animatedAngleAndEnumeration.first.setValue(0);	105	animatedAngle.setValue(0);
113	return;	106	return;
114	}	107	}
115		108
116	if (fromAngleAndEnumeration.second == SVGMarkerOrientAngle) {	109	if (fromEnumeration == SVGMarkerOrientAngle) {
117	// Regular from angle to angle animation, with support for smooth interpolation, and additive and accumulated animation.	110	// Regular from angle to angle animation, with support for smooth interpolation, and additive and accumulated animation.
118	animatedAngleAndEnumeration.second = SVGMarkerOrientAngle;	111	animatedEnumeration = SVGMarkerOrientAngle;
119		112
120	auto& animatedSVGAngle = animatedAngleAndEnumeration.first;	113	float animatedAngleValue = animatedAngle.value();
121	const auto& toAtEndOfDurationSVGAngle = toAtEndOfDurationAngleAndEnumeration.first;	114	m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromAngle.value(), toAngle.value(), toAtEndOfDurationAngle.value(), animatedAngleValue);
122	float animatedAngle = animatedSVGAngle.value();	115	animatedAngle.setValue(animatedAngleValue);
123	m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromAngleAndEnumeration.first.value(), toAngleAndEnumeration.first.value(), toAtEndOfDurationSVGAngle.value(), animatedAngle);
124	animatedSVGAngle.setValue(animatedAngle);
125	return;	116	return;
126	}	117	}
127		118
128	// auto, auto-start-reverse, or unknown.	119	// auto, auto-start-reverse, or unknown.
129	animatedAngleAndEnumeration.first.setValue(0);	120	animatedAngle.setValue(0);
130		121
131	if (fromAngleAndEnumeration.second == SVGMarkerOrientAuto \|\| fromAngleAndEnumeration.second == SVGMarkerOrientAutoStartReverse)	122	if (fromEnumeration == SVGMarkerOrientAuto \|\| fromEnumeration == SVGMarkerOrientAutoStartReverse)
132	animatedAngleAndEnumeration.second = fromAngleAndEnumeration.second;	123	animatedEnumeration = fromEnumeration;
133	else	124	else
134	animatedAngleAndEnumeration.second = SVGMarkerOrientUnknown;	125	animatedEnumeration = SVGMarkerOrientUnknown;
135	}	126	}
136		127
137	float SVGAnimatedAngleAnimator::calculateDistance(const String& fromString, const String& toString)	128	float SVGAnimatedAngleAnimator::calculateDistance(const String& fromString, const String& toString)

Lines 31-44 SVGAnimatedBooleanAnimator::SVGAnimatedB Source/WebCore/svg/SVGAnimatedBoolean.cpp_sec1
- Source/WebCore/svg/SVGAnimatedBoolean.cpp -8 / +6 lines
31		31
32	std::unique_ptr<SVGAnimatedType> SVGAnimatedBooleanAnimator::constructFromString(const String& string)	32	std::unique_ptr<SVGAnimatedType> SVGAnimatedBooleanAnimator::constructFromString(const String& string)
33	{	33	{
34	auto animatedType = SVGAnimatedType::createBoolean(std::make_unique<bool>());	34	return SVGAnimatedType::create(SVGPropertyTraits<bool>::fromString(string));
35	animatedType->boolean() = (string == "true"); // wat?
36	return animatedType;
37	}	35	}
38		36
39	std::unique_ptr<SVGAnimatedType> SVGAnimatedBooleanAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	37	std::unique_ptr<SVGAnimatedType> SVGAnimatedBooleanAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
40	{	38	{
41	return SVGAnimatedType::createBoolean(constructFromBaseValue<SVGAnimatedBoolean>(animatedTypes));	39	return constructFromBaseValue<SVGAnimatedBoolean>(animatedTypes);
42	}	40	}
43		41
44	void SVGAnimatedBooleanAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	42	void SVGAnimatedBooleanAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 48-54 void SVGAnimatedBooleanAnimator::stopAni Source/WebCore/svg/SVGAnimatedBoolean.cpp_sec2
48		46
49	void SVGAnimatedBooleanAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	47	void SVGAnimatedBooleanAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
50	{	48	{
51	resetFromBaseValue<SVGAnimatedBoolean>(animatedTypes, type, &SVGAnimatedType::boolean);	49	resetFromBaseValue<SVGAnimatedBoolean>(animatedTypes, type);
52	}	50	}
53		51
54	void SVGAnimatedBooleanAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	52	void SVGAnimatedBooleanAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 71-79 void SVGAnimatedBooleanAnimator::calcula Source/WebCore/svg/SVGAnimatedBoolean.cpp_sec3
71	ASSERT(m_animationElement);	69	ASSERT(m_animationElement);
72	ASSERT(m_contextElement);	70	ASSERT(m_contextElement);
73		71
74	bool fromBoolean = m_animationElement->animationMode() == ToAnimation ? animated->boolean() : from->boolean();	72	bool fromBoolean = m_animationElement->animationMode() == ToAnimation ? static_cast<bool&>(animated->values[0]) : static_cast<bool&>(from->values[0]);
75	bool toBoolean = to->boolean();	73	bool toBoolean = static_cast<bool&>(*to->values[0]);
76	bool& animatedBoolean = animated->boolean();	74	bool& animatedBoolean = static_cast<bool&>(*animated->values[0]);
77		75
78	m_animationElement->animateDiscreteType<bool>(percentage, fromBoolean, toBoolean, animatedBoolean);	76	m_animationElement->animateDiscreteType<bool>(percentage, fromBoolean, toBoolean, animatedBoolean);
79	}	77	}

Lines 33-39 SVGAnimatedColorAnimator::SVGAnimatedCol Source/WebCore/svg/SVGAnimatedColor.cpp_sec1
- Source/WebCore/svg/SVGAnimatedColor.cpp -7 / +7 lines
33		33
34	std::unique_ptr<SVGAnimatedType> SVGAnimatedColorAnimator::constructFromString(const String& string)	34	std::unique_ptr<SVGAnimatedType> SVGAnimatedColorAnimator::constructFromString(const String& string)
35	{	35	{
36	return SVGAnimatedType::createColor(std::make_unique<Color>(CSSParser::parseColor(string.stripWhiteSpace())));	36	return SVGAnimatedType::create(SVGPropertyTraits<Color>::fromString(string));
37	}	37	}
38		38
39	void SVGAnimatedColorAnimator::addAnimatedTypes(SVGAnimatedType* from, SVGAnimatedType* to)	39	void SVGAnimatedColorAnimator::addAnimatedTypes(SVGAnimatedType* from, SVGAnimatedType* to)
Lines 44-51 void SVGAnimatedColorAnimator::addAnimat Source/WebCore/svg/SVGAnimatedColor.cpp_sec2
44	ASSERT(to->type() == AnimatedColor);	44	ASSERT(to->type() == AnimatedColor);
45		45
46	// Ignores any alpha and sets alpha on result to 100% opaque.	46	// Ignores any alpha and sets alpha on result to 100% opaque.
47	auto& fromColor = from->color();	47	auto& fromColor = static_cast<Color&>(*from->values[0]);
48	auto& toColor = to->color();	48	auto& toColor = static_cast<Color&>(*to->values[0]);
49	toColor = { roundAndClampColorChannel(toColor.red() + fromColor.red()),	49	toColor = { roundAndClampColorChannel(toColor.red() + fromColor.red()),
50	roundAndClampColorChannel(toColor.green() + fromColor.green()),	50	roundAndClampColorChannel(toColor.green() + fromColor.green()),
51	roundAndClampColorChannel(toColor.blue() + fromColor.blue()) };	51	roundAndClampColorChannel(toColor.blue() + fromColor.blue()) };
Lines 69-76 void SVGAnimatedColorAnimator::calculate Source/WebCore/svg/SVGAnimatedColor.cpp_sec3
69	ASSERT(m_animationElement);	69	ASSERT(m_animationElement);
70	ASSERT(m_contextElement);	70	ASSERT(m_contextElement);
71		71
72	Color fromColor = m_animationElement->animationMode() == ToAnimation ? animated->color() : from->color();	72	Color fromColor = m_animationElement->animationMode() == ToAnimation ? static_cast<Color&>(animated->values[0]) : static_cast<Color&>(from->values[0]);
73	Color toColor = to->color();	73	Color toColor = static_cast<Color&>(*to->values[0]);
74		74
75	// Apply CSS inheritance rules.	75	// Apply CSS inheritance rules.
76	m_animationElement->adjustForInheritance<Color>(parseColorFromString, m_animationElement->fromPropertyValueType(), fromColor, m_contextElement);	76	m_animationElement->adjustForInheritance<Color>(parseColorFromString, m_animationElement->fromPropertyValueType(), fromColor, m_contextElement);
Lines 82-89 void SVGAnimatedColorAnimator::calculate Source/WebCore/svg/SVGAnimatedColor.cpp_sec4
82	if (m_animationElement->toPropertyValueType() == CurrentColorValue)	82	if (m_animationElement->toPropertyValueType() == CurrentColorValue)
83	toColor = currentColor(*m_contextElement);	83	toColor = currentColor(*m_contextElement);
84		84
85	auto& toAtEndOfDurationColor = toAtEndOfDuration->color();	85	auto& toAtEndOfDurationColor = static_cast<Color&>(*toAtEndOfDuration->values[0]);
86	auto& animatedColor = animated->color();	86	auto& animatedColor = static_cast<Color&>(*animated->values[0]);
87		87
88	// FIXME: ExtendedColor - this will need to handle blending between colors in different color spaces,	88	// FIXME: ExtendedColor - this will need to handle blending between colors in different color spaces,
89	// as well as work with non [0-255] Colors.	89	// as well as work with non [0-255] Colors.

Lines 109-122 SVGAnimatedEnumerationAnimator::SVGAnima Source/WebCore/svg/SVGAnimatedEnumeration.cpp_sec1
- Source/WebCore/svg/SVGAnimatedEnumeration.cpp -8 / +6 lines
109	std::unique_ptr<SVGAnimatedType> SVGAnimatedEnumerationAnimator::constructFromString(const String& string)	109	std::unique_ptr<SVGAnimatedType> SVGAnimatedEnumerationAnimator::constructFromString(const String& string)
110	{	110	{
111	ASSERT(m_animationElement);	111	ASSERT(m_animationElement);
112	auto animatedType = SVGAnimatedType::createEnumeration(std::make_unique<unsigned>());	112	return SVGAnimatedType::create(enumerationValueForTargetAttribute(m_animationElement->targetElement(), m_animationElement->attributeName(), string));
113	animatedType->enumeration() = enumerationValueForTargetAttribute(m_animationElement->targetElement(), m_animationElement->attributeName(), string);
114	return animatedType;
115	}	113	}
116		114
117	std::unique_ptr<SVGAnimatedType> SVGAnimatedEnumerationAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	115	std::unique_ptr<SVGAnimatedType> SVGAnimatedEnumerationAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
118	{	116	{
119	return SVGAnimatedType::createEnumeration(constructFromBaseValue<SVGAnimatedEnumeration>(animatedTypes));	117	return constructFromBaseValue<SVGAnimatedEnumeration>(animatedTypes);
120	}	118	}
121		119
122	void SVGAnimatedEnumerationAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	120	void SVGAnimatedEnumerationAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 126-132 void SVGAnimatedEnumerationAnimator::sto Source/WebCore/svg/SVGAnimatedEnumeration.cpp_sec2
126		124
127	void SVGAnimatedEnumerationAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	125	void SVGAnimatedEnumerationAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
128	{	126	{
129	resetFromBaseValue<SVGAnimatedEnumeration>(animatedTypes, type, &SVGAnimatedType::enumeration);	127	resetFromBaseValue<SVGAnimatedEnumeration>(animatedTypes, type);
130	}	128	}
131		129
132	void SVGAnimatedEnumerationAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	130	void SVGAnimatedEnumerationAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 149-157 void SVGAnimatedEnumerationAnimator::cal Source/WebCore/svg/SVGAnimatedEnumeration.cpp_sec3
149	ASSERT(m_animationElement);	147	ASSERT(m_animationElement);
150	ASSERT(m_contextElement);	148	ASSERT(m_contextElement);
151		149
152	unsigned fromEnumeration = m_animationElement->animationMode() == ToAnimation ? animated->enumeration() : from->enumeration();	150	unsigned fromEnumeration = m_animationElement->animationMode() == ToAnimation ? static_cast<unsigned&>(animated->values[0]) : static_cast<unsigned&>(from->values[0]);
153	unsigned toEnumeration = to->enumeration();	151	unsigned toEnumeration = static_cast<unsigned&>(*to->values[0]);
154	unsigned& animatedEnumeration = animated->enumeration();	152	unsigned& animatedEnumeration = static_cast<unsigned&>(*animated->values[0]);
155		153
156	m_animationElement->animateDiscreteType<unsigned>(percentage, fromEnumeration, toEnumeration, animatedEnumeration);	154	m_animationElement->animateDiscreteType<unsigned>(percentage, fromEnumeration, toEnumeration, animatedEnumeration);
157	}	155	}

Lines 33-46 SVGAnimatedIntegerAnimator::SVGAnimatedI Source/WebCore/svg/SVGAnimatedInteger.cpp_sec1
- Source/WebCore/svg/SVGAnimatedInteger.cpp -10 / +8 lines
33		33
34	std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerAnimator::constructFromString(const String& string)	34	std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerAnimator::constructFromString(const String& string)
35	{	35	{
36	auto animatedType = SVGAnimatedType::createInteger(std::make_unique<int>());	36	return SVGAnimatedType::create(SVGPropertyTraits<int>::fromString(string));
37	animatedType->integer() = string.toIntStrict();
38	return animatedType;
39	}	37	}
40		38
41	std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	39	std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
42	{	40	{
43	return SVGAnimatedType::createInteger(constructFromBaseValue<SVGAnimatedInteger>(animatedTypes));	41	return constructFromBaseValue<SVGAnimatedInteger>(animatedTypes);
44	}	42	}
45		43
46	void SVGAnimatedIntegerAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	44	void SVGAnimatedIntegerAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 50-56 void SVGAnimatedIntegerAnimator::stopAni Source/WebCore/svg/SVGAnimatedInteger.cpp_sec2
50		48
51	void SVGAnimatedIntegerAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	49	void SVGAnimatedIntegerAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
52	{	50	{
53	resetFromBaseValue<SVGAnimatedInteger>(animatedTypes, type, &SVGAnimatedType::integer);	51	resetFromBaseValue<SVGAnimatedInteger>(animatedTypes, type);
54	}	52	}
55		53
56	void SVGAnimatedIntegerAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	54	void SVGAnimatedIntegerAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 68-74 void SVGAnimatedIntegerAnimator::addAnim Source/WebCore/svg/SVGAnimatedInteger.cpp_sec3
68	ASSERT(from->type() == AnimatedInteger);	66	ASSERT(from->type() == AnimatedInteger);
69	ASSERT(from->type() == to->type());	67	ASSERT(from->type() == to->type());
70		68
71	to->integer() += from->integer();	69	static_cast<int&>(to->values[0]) += static_cast<int&>(from->values[0]);
72	}	70	}
73		71
74	void SVGAnimatedIntegerAnimator::calculateAnimatedInteger(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, int fromInteger, int toInteger, int toAtEndOfDurationInteger, int& animatedInteger)	72	void SVGAnimatedIntegerAnimator::calculateAnimatedInteger(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, int fromInteger, int toInteger, int toAtEndOfDurationInteger, int& animatedInteger)
Lines 83-92 void SVGAnimatedIntegerAnimator::calcula Source/WebCore/svg/SVGAnimatedInteger.cpp_sec4
83	ASSERT(m_animationElement);	81	ASSERT(m_animationElement);
84	ASSERT(m_contextElement);	82	ASSERT(m_contextElement);
85		83
86	int fromInteger = m_animationElement->animationMode() == ToAnimation ? animated->integer() : from->integer();	84	int fromInteger = m_animationElement->animationMode() == ToAnimation ? static_cast<int&>(animated->values[0]) : static_cast<int&>(from->values[0]);
87	int toInteger = to->integer();	85	int toInteger = static_cast<int&>(*to->values[0]);
88	int toAtEndOfDurationInteger = toAtEndOfDuration->integer();	86	int toAtEndOfDurationInteger = static_cast<int&>(*toAtEndOfDuration->values[0]);
89	int& animatedInteger = animated->integer();	87	int& animatedInteger = static_cast<int&>(*animated->values[0]);
90		88
91	calculateAnimatedInteger(m_animationElement, percentage, repeatCount, fromInteger, toInteger, toAtEndOfDurationInteger, animatedInteger);	89	calculateAnimatedInteger(m_animationElement, percentage, repeatCount, fromInteger, toInteger, toAtEndOfDurationInteger, animatedInteger);
92	}	90	}

Lines 33-55 SVGAnimatedIntegerOptionalIntegerAnimato Source/WebCore/svg/SVGAnimatedIntegerOptionalInteger.cpp_sec1
- Source/WebCore/svg/SVGAnimatedIntegerOptionalInteger.cpp -25 / +15 lines
33		33
34	std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerOptionalIntegerAnimator::constructFromString(const String& string)	34	std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerOptionalIntegerAnimator::constructFromString(const String& string)
35	{	35	{
36	auto animatedType = SVGAnimatedType::createIntegerOptionalInteger(std::make_unique<std::pair<int, int>>());	36	return SVGAnimatedType::create(SVGPropertyTraits<std::pair<int, int>>::fromString(string));
37	std::pair<int, int>& animatedInteger = animatedType->integerOptionalInteger();
38	float firstNumber = 0;
39	float secondNumber = 0;
40	if (!parseNumberOptionalNumber(string, firstNumber, secondNumber)) {
41	animatedInteger.first = 0;
42	animatedInteger.second = 0;
43	} else {
44	animatedInteger.first = static_cast<int>(roundf(firstNumber));
45	animatedInteger.second = static_cast<int>(roundf(secondNumber));
46	}
47	return animatedType;
48	}	37	}
49		38
50	std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerOptionalIntegerAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	39	std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerOptionalIntegerAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
51	{	40	{
52	return SVGAnimatedType::createIntegerOptionalInteger(constructFromBaseValues<SVGAnimatedInteger, SVGAnimatedInteger>(animatedTypes));	41	return constructFromBaseValues<SVGAnimatedInteger, SVGAnimatedInteger>(animatedTypes);
53	}	42	}
54		43
55	void SVGAnimatedIntegerOptionalIntegerAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	44	void SVGAnimatedIntegerOptionalIntegerAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 59-65 void SVGAnimatedIntegerOptionalIntegerAn Source/WebCore/svg/SVGAnimatedIntegerOptionalInteger.cpp_sec2
59		48
60	void SVGAnimatedIntegerOptionalIntegerAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	49	void SVGAnimatedIntegerOptionalIntegerAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
61	{	50	{
62	resetFromBaseValues<SVGAnimatedInteger, SVGAnimatedInteger>(animatedTypes, type, &SVGAnimatedType::integerOptionalInteger);	51	resetFromBaseValues<SVGAnimatedInteger, SVGAnimatedInteger>(animatedTypes, type);
63	}	52	}
64		53
65	void SVGAnimatedIntegerOptionalIntegerAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	54	void SVGAnimatedIntegerOptionalIntegerAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 77-87 void SVGAnimatedIntegerOptionalIntegerAn Source/WebCore/svg/SVGAnimatedIntegerOptionalInteger.cpp_sec3
77	ASSERT(from->type() == AnimatedIntegerOptionalInteger);	66	ASSERT(from->type() == AnimatedIntegerOptionalInteger);
78	ASSERT(from->type() == to->type());	67	ASSERT(from->type() == to->type());
79		68
80	const std::pair<int, int>& fromIntegerPair = from->integerOptionalInteger();	69	static_cast<int&>(to->values[0]) += static_cast<int&>(from->values[0]);
81	std::pair<int, int>& toIntegerPair = to->integerOptionalInteger();	70	static_cast<int&>(to->values[1]) += static_cast<int&>(from->values[1]);
82
83	toIntegerPair.first += fromIntegerPair.first;
84	toIntegerPair.second += fromIntegerPair.second;
85	}	71	}
86		72
87	void SVGAnimatedIntegerOptionalIntegerAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)	73	void SVGAnimatedIntegerOptionalIntegerAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
Lines 89-101 void SVGAnimatedIntegerOptionalIntegerAn Source/WebCore/svg/SVGAnimatedIntegerOptionalInteger.cpp_sec4
89	ASSERT(m_animationElement);	75	ASSERT(m_animationElement);
90	ASSERT(m_contextElement);	76	ASSERT(m_contextElement);
91		77
92	const std::pair<int, int>& fromIntegerPair = m_animationElement->animationMode() == ToAnimation ? animated->integerOptionalInteger() : from->integerOptionalInteger();	78	const int& formFirst = m_animationElement->animationMode() == ToAnimation ? static_cast<int&>(animated->values[0]) : static_cast<int&>(from->values[0]);
93	const std::pair<int, int>& toIntegerPair = to->integerOptionalInteger();	79	const int& formSecond = m_animationElement->animationMode() == ToAnimation ? static_cast<int&>(animated->values[1]) : static_cast<int&>(from->values[1]);
94	const std::pair<int, int>& toAtEndOfDurationIntegerPair = toAtEndOfDuration->integerOptionalInteger();	80	const int& toFirst = static_cast<int&>(*to->values[0]);
95	std::pair<int, int>& animatedIntegerPair = animated->integerOptionalInteger();	81	const int& toSecond = static_cast<int&>(*to->values[1]);
		82	const int& toAtEndOfDurationFirst = static_cast<int&>(*toAtEndOfDuration->values[0]);
		83	const int& toAtEndOfDurationSecond = static_cast<int&>(*toAtEndOfDuration->values[1]);
		84	int& animatedFirst = static_cast<int&>(*animated->values[0]);
		85	int& animatedSecond = static_cast<int&>(*animated->values[1]);
96		86
97	SVGAnimatedIntegerAnimator::calculateAnimatedInteger(m_animationElement, percentage, repeatCount, fromIntegerPair.first, toIntegerPair.first, toAtEndOfDurationIntegerPair.first, animatedIntegerPair.first);	87	SVGAnimatedIntegerAnimator::calculateAnimatedInteger(m_animationElement, percentage, repeatCount, formFirst, toFirst, toAtEndOfDurationFirst, animatedFirst);
98	SVGAnimatedIntegerAnimator::calculateAnimatedInteger(m_animationElement, percentage, repeatCount, fromIntegerPair.second, toIntegerPair.second, toAtEndOfDurationIntegerPair.second, animatedIntegerPair.second);	88	SVGAnimatedIntegerAnimator::calculateAnimatedInteger(m_animationElement, percentage, repeatCount, formSecond, toSecond, toAtEndOfDurationSecond, animatedSecond);
99	}	89	}
100		90
101	float SVGAnimatedIntegerOptionalIntegerAnimator::calculateDistance(const String&, const String&)	91	float SVGAnimatedIntegerOptionalIntegerAnimator::calculateDistance(const String&, const String&)

Lines 1632-1638 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- Source/WebCore/WebCore.xcodeproj/project.pbxproj -14 / +32 lines
1632	5550CB421E955E3C00111AA0 /* ImageTypes.h in Headers / = {isa = PBXBuildFile; fileRef = 5550CB411E955E3C00111AA0 / ImageTypes.h */; settings = {ATTRIBUTES = (Private, ); }; };	1632	5550CB421E955E3C00111AA0 /* ImageTypes.h in Headers / = {isa = PBXBuildFile; fileRef = 5550CB411E955E3C00111AA0 / ImageTypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
1633	555130011E7CCCCB00A69E38 /* DecodingOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 555130001E7CCCCA00A69E38 / DecodingOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };	1633	555130011E7CCCCB00A69E38 /* DecodingOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 555130001E7CCCCA00A69E38 / DecodingOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
1634	555B87ED1CAAF0AB00349425 /* ImageDecoderCG.h in Headers / = {isa = PBXBuildFile; fileRef = 555B87EB1CAAF0AB00349425 / ImageDecoderCG.h */; };	1634	555B87ED1CAAF0AB00349425 /* ImageDecoderCG.h in Headers / = {isa = PBXBuildFile; fileRef = 555B87EB1CAAF0AB00349425 / ImageDecoderCG.h */; };
		1635	55627B7820292BF4002D397D /* SVGListValues.h in Headers / = {isa = PBXBuildFile; fileRef = 55627B762028EDC4002D397D / SVGListValues.h */; settings = {ATTRIBUTES = (Private, ); }; };
1635	5576A5651D88A70800CCC04C /* ImageFrame.h in Headers / = {isa = PBXBuildFile; fileRef = 5576A5631D88A70800CCC04C / ImageFrame.h */; settings = {ATTRIBUTES = (Private, ); }; };	1636	5576A5651D88A70800CCC04C /* ImageFrame.h in Headers / = {isa = PBXBuildFile; fileRef = 5576A5631D88A70800CCC04C / ImageFrame.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1637	558B69982025456D004D75F4 /* SVGValue.h in Headers / = {isa = PBXBuildFile; fileRef = 55E44AE01E4BFBC50092457B / SVGValue.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1638	558B6999202545AC004D75F4 /* SVGAngleValue.h in Headers / = {isa = PBXBuildFile; fileRef = 7C8F22431DD3B3B900E92DA3 / SVGAngleValue.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1639	558B699B202545EA004D75F4 /* SVGNumberListValues.h in Headers / = {isa = PBXBuildFile; fileRef = 7C39C3691DDB86D300FEFB29 / SVGNumberListValues.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1640	558B699C20254605004D75F4 /* SVGPathSegListValues.h in Headers / = {isa = PBXBuildFile; fileRef = 7C39C36F1DDBA3E000FEFB29 / SVGPathSegListValues.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1641	558B699D20254612004D75F4 /* SVGPointListValues.h in Headers / = {isa = PBXBuildFile; fileRef = 7C39C36B1DDB871C00FEFB29 / SVGPointListValues.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1642	558B699E2025462B004D75F4 /* SVGPreserveAspectRatioValue.h in Headers / = {isa = PBXBuildFile; fileRef = 7C8F22461DD3D1C500E92DA3 / SVGPreserveAspectRatioValue.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1643	558B699F20254675004D75F4 /* SVGTransformListValues.h in Headers / = {isa = PBXBuildFile; fileRef = 7C39C36D1DDB8BB000FEFB29 / SVGTransformListValues.h */; settings = {ATTRIBUTES = (Private, ); }; };
1636	55A336F71D8209F40022C4C7 /* NativeImage.h in Headers / = {isa = PBXBuildFile; fileRef = 55A336F61D8209F40022C4C7 / NativeImage.h */; };	1644	55A336F71D8209F40022C4C7 /* NativeImage.h in Headers / = {isa = PBXBuildFile; fileRef = 55A336F61D8209F40022C4C7 / NativeImage.h */; };
1637	55A336F91D821E3C0022C4C7 /* ImageBackingStore.h in Headers / = {isa = PBXBuildFile; fileRef = 55A336F81D821E3C0022C4C7 / ImageBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };	1645	55A336F91D821E3C0022C4C7 /* ImageBackingStore.h in Headers / = {isa = PBXBuildFile; fileRef = 55A336F81D821E3C0022C4C7 / ImageBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
1638	55AF14E61EAAC59B0026EEAA /* UTIRegistry.h in Headers / = {isa = PBXBuildFile; fileRef = 55AF14E41EAAC59B0026EEAA / UTIRegistry.h */; settings = {ATTRIBUTES = (Private, ); }; };	1646	55AF14E61EAAC59B0026EEAA /* UTIRegistry.h in Headers / = {isa = PBXBuildFile; fileRef = 55AF14E41EAAC59B0026EEAA / UTIRegistry.h */; settings = {ATTRIBUTES = (Private, ); }; };
Lines 1930-1936 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
1930	71556CBD1F9F0A4900E78D08 /* JSAnimationEffectTiming.h in Headers / = {isa = PBXBuildFile; fileRef = 71556CB91F9F09FD00E78D08 / JSAnimationEffectTiming.h */; };	1938	71556CBD1F9F0A4900E78D08 /* JSAnimationEffectTiming.h in Headers / = {isa = PBXBuildFile; fileRef = 71556CB91F9F09FD00E78D08 / JSAnimationEffectTiming.h */; };
1931	71556CBE1F9F0A4900E78D08 /* JSKeyframeEffect.h in Headers / = {isa = PBXBuildFile; fileRef = 71556CB71F9F09FC00E78D08 / JSKeyframeEffect.h */; };	1939	71556CBE1F9F0A4900E78D08 /* JSKeyframeEffect.h in Headers / = {isa = PBXBuildFile; fileRef = 71556CB71F9F09FC00E78D08 / JSKeyframeEffect.h */; };
1932	71A1B6081DEE5AD70073BCFB /* modern-media-controls-localized-strings.js in Resources / = {isa = PBXBuildFile; fileRef = 71A1B6061DEE5A820073BCFB / modern-media-controls-localized-strings.js */; };	1940	71A1B6081DEE5AD70073BCFB /* modern-media-controls-localized-strings.js in Resources / = {isa = PBXBuildFile; fileRef = 71A1B6061DEE5A820073BCFB / modern-media-controls-localized-strings.js */; };
1933	71A57DF2154BE25C0009D120 /* SVGPathUtilities.h in Headers / = {isa = PBXBuildFile; fileRef = 71A57DF0154BE25C0009D120 / SVGPathUtilities.h */; };	1941	71A57DF2154BE25C0009D120 /* SVGPathUtilities.h in Headers / = {isa = PBXBuildFile; fileRef = 71A57DF0154BE25C0009D120 / SVGPathUtilities.h */; settings = {ATTRIBUTES = (Private, ); }; };
1934	71C916081D1483A300ACA47D /* UserInterfaceLayoutDirection.h in Headers / = {isa = PBXBuildFile; fileRef = 71C916071D1483A300ACA47D / UserInterfaceLayoutDirection.h */; settings = {ATTRIBUTES = (Private, ); }; };	1942	71C916081D1483A300ACA47D /* UserInterfaceLayoutDirection.h in Headers / = {isa = PBXBuildFile; fileRef = 71C916071D1483A300ACA47D / UserInterfaceLayoutDirection.h */; settings = {ATTRIBUTES = (Private, ); }; };
1935	71DCB7021568197600862271 /* JSSVGZoomAndPan.h in Headers / = {isa = PBXBuildFile; fileRef = 71DCB7001568197600862271 / JSSVGZoomAndPan.h */; };	1943	71DCB7021568197600862271 /* JSSVGZoomAndPan.h in Headers / = {isa = PBXBuildFile; fileRef = 71DCB7001568197600862271 / JSSVGZoomAndPan.h */; };
1936	71E2183A17359FB8006E6E4D /* PlugInsResources.h in Headers / = {isa = PBXBuildFile; fileRef = 71E2183817359FB8006E6E4D / PlugInsResources.h */; };	1944	71E2183A17359FB8006E6E4D /* PlugInsResources.h in Headers / = {isa = PBXBuildFile; fileRef = 71E2183817359FB8006E6E4D / PlugInsResources.h */; };
Lines 2032-2038 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
2032	7C30D9861F815AEC00268356 /* JSAbortSignal.h in Headers / = {isa = PBXBuildFile; fileRef = 7C30D9811F815AC100268356 / JSAbortSignal.h */; };	2040	7C30D9861F815AEC00268356 /* JSAbortSignal.h in Headers / = {isa = PBXBuildFile; fileRef = 7C30D9811F815AC100268356 / JSAbortSignal.h */; };
2033	7C330A021DF8FAC600D3395C /* GraphicsContext3DAttributes.h in Headers / = {isa = PBXBuildFile; fileRef = 7C330A011DF8FAC600D3395C / GraphicsContext3DAttributes.h */; settings = {ATTRIBUTES = (Private, ); }; };	2041	7C330A021DF8FAC600D3395C /* GraphicsContext3DAttributes.h in Headers / = {isa = PBXBuildFile; fileRef = 7C330A011DF8FAC600D3395C / GraphicsContext3DAttributes.h */; settings = {ATTRIBUTES = (Private, ); }; };
2034	7C330A081DF9F95100D3395C /* JSPositionOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 7C330A061DF9F95100D3395C / JSPositionOptions.h */; };	2042	7C330A081DF9F95100D3395C /* JSPositionOptions.h in Headers / = {isa = PBXBuildFile; fileRef = 7C330A061DF9F95100D3395C / JSPositionOptions.h */; };
2035	7C39C3651DDA865200FEFB29 /* SVGLengthListValues.h in Headers / = {isa = PBXBuildFile; fileRef = 7C39C3631DDA864900FEFB29 / SVGLengthListValues.h */; };	2043	7C39C3651DDA865200FEFB29 /* SVGLengthListValues.h in Headers / = {isa = PBXBuildFile; fileRef = 7C39C3631DDA864900FEFB29 / SVGLengthListValues.h */; settings = {ATTRIBUTES = (Private, ); }; };
2036	7C39C3771DDBE17000FEFB29 /* SVGStringListValues.h in Headers / = {isa = PBXBuildFile; fileRef = 7C39C3671DDB82CF00FEFB29 / SVGStringListValues.h */; settings = {ATTRIBUTES = (Private, ); }; };	2044	7C39C3771DDBE17000FEFB29 /* SVGStringListValues.h in Headers / = {isa = PBXBuildFile; fileRef = 7C39C3671DDB82CF00FEFB29 / SVGStringListValues.h */; settings = {ATTRIBUTES = (Private, ); }; };
2037	7C3A91E61C963B8800D1A7E3 /* ClipboardAccessPolicy.h in Headers / = {isa = PBXBuildFile; fileRef = 7C3A91E51C963B8800D1A7E3 / ClipboardAccessPolicy.h */; settings = {ATTRIBUTES = (Private, ); }; };	2045	7C3A91E61C963B8800D1A7E3 /* ClipboardAccessPolicy.h in Headers / = {isa = PBXBuildFile; fileRef = 7C3A91E51C963B8800D1A7E3 / ClipboardAccessPolicy.h */; settings = {ATTRIBUTES = (Private, ); }; };
2038	7C3B79711908757B00B47A2D /* UserMessageHandler.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7C3B796F1908757B00B47A2D / UserMessageHandler.cpp */; };	2046	7C3B79711908757B00B47A2D /* UserMessageHandler.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7C3B796F1908757B00B47A2D / UserMessageHandler.cpp */; };
Lines 2164-2173 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
2164	7CE191791F2ABE7100272F78 /* JSFetchRequestMode.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE1916C1F2AB70A00272F78 / JSFetchRequestMode.h */; };	2172	7CE191791F2ABE7100272F78 /* JSFetchRequestMode.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE1916C1F2AB70A00272F78 / JSFetchRequestMode.h */; };
2165	7CE1917B1F2ABE7100272F78 /* JSFetchRequestRedirect.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE1916A1F2AB70600272F78 / JSFetchRequestRedirect.h */; };	2173	7CE1917B1F2ABE7100272F78 /* JSFetchRequestRedirect.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE1916A1F2AB70600272F78 / JSFetchRequestRedirect.h */; };
2166	7CE58D4A1DD64A5B00128552 /* SVGPoint.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE58D491DD64A5B00128552 / SVGPoint.h */; };	2174	7CE58D4A1DD64A5B00128552 /* SVGPoint.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE58D491DD64A5B00128552 / SVGPoint.h */; };
2167	7CE58D4E1DD694FE00128552 /* SVGRectTraits.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE58D4D1DD694FE00128552 / SVGRectTraits.h */; };
2168	7CE58D501DD69A1E00128552 /* SVGNumber.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE58D4F1DD69A1E00128552 / SVGNumber.h */; };	2175	7CE58D501DD69A1E00128552 /* SVGNumber.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE58D4F1DD69A1E00128552 / SVGNumber.h */; };
2169	7CE58D581DD7D96D00128552 /* SVGTransformValue.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE58D561DD7D96D00128552 / SVGTransformValue.h */; };	2176	7CE58D581DD7D96D00128552 /* SVGTransformValue.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE58D561DD7D96D00128552 / SVGTransformValue.h */; settings = {ATTRIBUTES = (Private, ); }; };
2170	7CE58D5C1DD7EC9C00128552 /* SVGMatrixValue.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE58D5B1DD7EC9C00128552 / SVGMatrixValue.h */; };	2177	7CE58D5C1DD7EC9C00128552 /* SVGMatrixValue.h in Headers / = {isa = PBXBuildFile; fileRef = 7CE58D5B1DD7EC9C00128552 / SVGMatrixValue.h */; settings = {ATTRIBUTES = (Private, ); }; };

Lines 33-44 SVGAnimatedLengthAnimator::SVGAnimatedLe Source/WebCore/svg/SVGAnimatedLength.cpp_sec1
- Source/WebCore/svg/SVGAnimatedLength.cpp -9 / +9 lines
33		33
34	std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthAnimator::constructFromString(const String& string)	34	std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthAnimator::constructFromString(const String& string)
35	{	35	{
36	return SVGAnimatedType::createLength(std::make_unique<SVGLengthValue>(m_lengthMode, string));	36	return SVGAnimatedType::create(SVGLengthValue(m_lengthMode, string));
37	}	37	}
38		38
39	std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	39	std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
40	{	40	{
41	return SVGAnimatedType::createLength(constructFromBaseValue<SVGAnimatedLength>(animatedTypes));	41	return constructFromBaseValue<SVGAnimatedLength>(animatedTypes);
42	}	42	}
43		43
44	void SVGAnimatedLengthAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	44	void SVGAnimatedLengthAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 48-54 void SVGAnimatedLengthAnimator::stopAnim Source/WebCore/svg/SVGAnimatedLength.cpp_sec2
48		48
49	void SVGAnimatedLengthAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	49	void SVGAnimatedLengthAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
50	{	50	{
51	resetFromBaseValue<SVGAnimatedLength>(animatedTypes, type, &SVGAnimatedType::length);	51	resetFromBaseValue<SVGAnimatedLength>(animatedTypes, type);
52	}	52	}
53		53
54	void SVGAnimatedLengthAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	54	void SVGAnimatedLengthAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 67-74 void SVGAnimatedLengthAnimator::addAnima Source/WebCore/svg/SVGAnimatedLength.cpp_sec3
67	ASSERT(from->type() == to->type());	67	ASSERT(from->type() == to->type());
68		68
69	SVGLengthContext lengthContext(m_contextElement);	69	SVGLengthContext lengthContext(m_contextElement);
70	const auto& fromLength = from->length();	70	const auto& fromLength = static_cast<SVGLengthValue&>(*from->values[0]);
71	auto& toLength = to->length();	71	auto& toLength = static_cast<SVGLengthValue&>(*to->values[0]);
72		72
73	toLength.setValue(toLength.value(lengthContext) + fromLength.value(lengthContext), lengthContext);	73	toLength.setValue(toLength.value(lengthContext) + fromLength.value(lengthContext), lengthContext);
74	}	74	}
Lines 85-94 void SVGAnimatedLengthAnimator::calculat Source/WebCore/svg/SVGAnimatedLength.cpp_sec4
85	ASSERT(m_animationElement);	85	ASSERT(m_animationElement);
86	ASSERT(m_contextElement);	86	ASSERT(m_contextElement);
87		87
88	auto fromSVGLength = m_animationElement->animationMode() == ToAnimation ? animated->length() : from->length();	88	auto fromSVGLength = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGLengthValue&>(animated->values[0]) : static_cast<SVGLengthValue&>(from->values[0]);
89	auto toSVGLength = to->length();	89	auto toSVGLength = static_cast<SVGLengthValue&>(*to->values[0]);
90	const auto& toAtEndOfDurationSVGLength = toAtEndOfDuration->length();	90	const auto& toAtEndOfDurationSVGLength = static_cast<SVGLengthValue&>(*toAtEndOfDuration->values[0]);
91	auto& animatedSVGLength = animated->length();	91	auto& animatedSVGLength = static_cast<SVGLengthValue&>(*animated->values[0]);
92		92
93	// Apply CSS inheritance rules.	93	// Apply CSS inheritance rules.
94	m_animationElement->adjustForInheritance<SVGLengthValue>(parseLengthFromString, m_animationElement->fromPropertyValueType(), fromSVGLength, m_contextElement);	94	m_animationElement->adjustForInheritance<SVGLengthValue>(parseLengthFromString, m_animationElement->fromPropertyValueType(), fromSVGLength, m_contextElement);

Lines 33-46 SVGAnimatedLengthListAnimator::SVGAnimat Source/WebCore/svg/SVGAnimatedLengthList.cpp_sec1
- Source/WebCore/svg/SVGAnimatedLengthList.cpp -19 / +17 lines
33		33
34	std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthListAnimator::constructFromString(const String& string)	34	std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthListAnimator::constructFromString(const String& string)
35	{	35	{
36	auto animatedType = SVGAnimatedType::createLengthList(std::make_unique<SVGLengthListValues>());	36	return SVGAnimatedType::create(SVGPropertyTraits<SVGLengthListValues>::fromString(string, m_lengthMode));
37	animatedType->lengthList().parse(string, m_lengthMode);
38	return animatedType;
39	}	37	}
40		38
41	std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	39	std::unique_ptr<SVGAnimatedType> SVGAnimatedLengthListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
42	{	40	{
43	return SVGAnimatedType::createLengthList(constructFromBaseValue<SVGAnimatedLengthList>(animatedTypes));	41	return constructFromBaseValue<SVGAnimatedLengthList>(animatedTypes);
44	}	42	}
45		43
46	void SVGAnimatedLengthListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	44	void SVGAnimatedLengthListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 50-56 void SVGAnimatedLengthListAnimator::stop Source/WebCore/svg/SVGAnimatedLengthList.cpp_sec2
50		48
51	void SVGAnimatedLengthListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	49	void SVGAnimatedLengthListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
52	{	50	{
53	resetFromBaseValue<SVGAnimatedLengthList>(animatedTypes, type, &SVGAnimatedType::lengthList);	51	resetFromBaseValue<SVGAnimatedLengthList>(animatedTypes, type);
54	}	52	}
55		53
56	void SVGAnimatedLengthListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	54	void SVGAnimatedLengthListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 68-75 void SVGAnimatedLengthListAnimator::addA Source/WebCore/svg/SVGAnimatedLengthList.cpp_sec3
68	ASSERT(from->type() == AnimatedLengthList);	66	ASSERT(from->type() == AnimatedLengthList);
69	ASSERT(from->type() == to->type());	67	ASSERT(from->type() == to->type());
70		68
71	const auto& fromLengthList = from->lengthList();	69	const auto& fromLengthList = static_cast<SVGLengthListValues&>(*from->values[0]);
72	auto& toLengthList = to->lengthList();	70	auto& toLengthList = static_cast<SVGLengthListValues&>(*to->values[0]);
73		71
74	unsigned fromLengthListSize = fromLengthList.size();	72	unsigned fromLengthListSize = fromLengthList.size();
75	if (!fromLengthListSize \|\| fromLengthListSize != toLengthList.size())	73	if (!fromLengthListSize \|\| fromLengthListSize != toLengthList.size())
Lines 77-83 void SVGAnimatedLengthListAnimator::addA Source/WebCore/svg/SVGAnimatedLengthList.cpp_sec4
77		75
78	SVGLengthContext lengthContext(m_contextElement);	76	SVGLengthContext lengthContext(m_contextElement);
79	for (unsigned i = 0; i < fromLengthListSize; ++i)	77	for (unsigned i = 0; i < fromLengthListSize; ++i)
80	toLengthList[i].setValue(toLengthList[i].value(lengthContext) + fromLengthList[i].value(lengthContext), lengthContext);	78	toLengthList.propertyAt(i).setValue(toLengthList.propertyAt(i).value(lengthContext) + fromLengthList.propertyAt(i).value(lengthContext), lengthContext);
81	}	79	}
82		80
83	static SVGLengthListValues parseLengthListFromString(SVGAnimationElement* animationElement, const String& string)	81	static SVGLengthListValues parseLengthListFromString(SVGAnimationElement* animationElement, const String& string)
Lines 92-101 void SVGAnimatedLengthListAnimator::calc Source/WebCore/svg/SVGAnimatedLengthList.cpp_sec5
92	ASSERT(m_animationElement);	90	ASSERT(m_animationElement);
93	ASSERT(m_contextElement);	91	ASSERT(m_contextElement);
94		92
95	auto fromLengthList = m_animationElement->animationMode() == ToAnimation ? animated->lengthList() : from->lengthList();	93	auto fromLengthList = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGLengthListValues&>(animated->values[0]) : static_cast<SVGLengthListValues&>(from->values[0]);
96	auto toLengthList = to->lengthList();	94	auto toLengthList = static_cast<SVGLengthListValues&>(*to->values[0]);
97	const auto& toAtEndOfDurationLengthList = toAtEndOfDuration->lengthList();	95	const auto& toAtEndOfDurationLengthList = static_cast<SVGLengthListValues&>(*toAtEndOfDuration->values[0]);
98	auto& animatedLengthList = animated->lengthList();	96	auto& animatedLengthList = static_cast<SVGLengthListValues&>(*animated->values[0]);
99		97
100	// Apply CSS inheritance rules.	98	// Apply CSS inheritance rules.
101	m_animationElement->adjustForInheritance<SVGLengthListValues>(parseLengthListFromString, m_animationElement->fromPropertyValueType(), fromLengthList, m_contextElement);	99	m_animationElement->adjustForInheritance<SVGLengthListValues>(parseLengthListFromString, m_animationElement->fromPropertyValueType(), fromLengthList, m_contextElement);
Lines 110-127 void SVGAnimatedLengthListAnimator::calc Source/WebCore/svg/SVGAnimatedLengthList.cpp_sec6
110		108
111	SVGLengthContext lengthContext(m_contextElement);	109	SVGLengthContext lengthContext(m_contextElement);
112	for (unsigned i = 0; i < toLengthListSize; ++i) {	110	for (unsigned i = 0; i < toLengthListSize; ++i) {
113	float animatedNumber = animatedLengthList[i].value(lengthContext);	111	float animatedNumber = animatedLengthList.propertyAt(i).value(lengthContext);
114	SVGLengthType unitType = toLengthList[i].unitType();	112	SVGLengthType unitType = toLengthList.propertyAt(i).unitType();
115	float effectiveFrom = 0;	113	float effectiveFrom = 0;
116	if (fromLengthListSize) {	114	if (fromLengthListSize) {
117	if (percentage < 0.5)	115	if (percentage < 0.5)
118	unitType = fromLengthList[i].unitType();	116	unitType = fromLengthList.propertyAt(i).unitType();
119	effectiveFrom = fromLengthList[i].value(lengthContext);	117	effectiveFrom = fromLengthList.propertyAt(i).value(lengthContext);
120	}	118	}
121	float effectiveToAtEnd = i < toAtEndOfDurationListSize ? toAtEndOfDurationLengthList[i].value(lengthContext) : 0;	119	float effectiveToAtEnd = i < toAtEndOfDurationListSize ? toAtEndOfDurationLengthList.propertyAt(i).value(lengthContext) : 0;
122		120
123	m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom, toLengthList[i].value(lengthContext), effectiveToAtEnd, animatedNumber);	121	m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom, toLengthList.propertyAt(i).value(lengthContext), effectiveToAtEnd, animatedNumber);
124	animatedLengthList[i].setValue(lengthContext, animatedNumber, m_lengthMode, unitType);	122	animatedLengthList.propertyAt(i).setValue(lengthContext, animatedNumber, m_lengthMode, unitType);
125	}	123	}
126	}	124	}
127		125

Lines 32-47 SVGAnimatedNumberAnimator::SVGAnimatedNu Source/WebCore/svg/SVGAnimatedNumber.cpp_sec1
- Source/WebCore/svg/SVGAnimatedNumber.cpp -15 / +9 lines
32		32
33	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberAnimator::constructFromString(const String& string)	33	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberAnimator::constructFromString(const String& string)
34	{	34	{
35	auto animatedType = SVGAnimatedType::createNumber(std::make_unique<float>());	35	return SVGAnimatedType::create(SVGPropertyTraits<float>::fromString(string));
36	float& animatedNumber = animatedType->number();
37	if (!parseNumberFromString(string, animatedNumber))
38	animatedNumber = 0;
39	return animatedType;
40	}	36	}
41		37
42	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	38	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
43	{	39	{
44	return SVGAnimatedType::createNumber(constructFromBaseValue<SVGAnimatedNumber>(animatedTypes));	40	return constructFromBaseValue<SVGAnimatedNumber>(animatedTypes);
45	}	41	}
46		42
47	void SVGAnimatedNumberAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	43	void SVGAnimatedNumberAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 51-57 void SVGAnimatedNumberAnimator::stopAnim Source/WebCore/svg/SVGAnimatedNumber.cpp_sec2
51		47
52	void SVGAnimatedNumberAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	48	void SVGAnimatedNumberAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
53	{	49	{
54	resetFromBaseValue<SVGAnimatedNumber>(animatedTypes, type, &SVGAnimatedType::number);	50	resetFromBaseValue<SVGAnimatedNumber>(animatedTypes, type);
55	}	51	}
56		52
57	void SVGAnimatedNumberAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	53	void SVGAnimatedNumberAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 69-82 void SVGAnimatedNumberAnimator::addAnima Source/WebCore/svg/SVGAnimatedNumber.cpp_sec3
69	ASSERT(from->type() == AnimatedNumber);	65	ASSERT(from->type() == AnimatedNumber);
70	ASSERT(from->type() == to->type());	66	ASSERT(from->type() == to->type());
71		67
72	to->number() += from->number();	68	static_cast<float&>(to->values[0]) += static_cast<float&>(from->values[0]);
73	}	69	}
74		70
75	static float parseNumberFromString(SVGAnimationElement*, const String& string)	71	static float parseNumberFromString(SVGAnimationElement*, const String& string)
76	{	72	{
77	float number = 0;	73	return SVGPropertyTraits<float>::fromString(string);
78	parseNumberFromString(string, number);
79	return number;
80	}	74	}
81		75
82	void SVGAnimatedNumberAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)	76	void SVGAnimatedNumberAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
Lines 84-93 void SVGAnimatedNumberAnimator::calculat Source/WebCore/svg/SVGAnimatedNumber.cpp_sec4
84	ASSERT(m_animationElement);	78	ASSERT(m_animationElement);
85	ASSERT(m_contextElement);	79	ASSERT(m_contextElement);
86		80
87	float fromNumber = m_animationElement->animationMode() == ToAnimation ? animated->number() : from->number();	81	float fromNumber = m_animationElement->animationMode() == ToAnimation ? static_cast<float&>(animated->values[0]) : static_cast<float&>(from->values[0]);
88	float toNumber = to->number();	82	float toNumber = static_cast<float&>(*to->values[0]);
89	float toAtEndOfDurationNumber = toAtEndOfDuration->number();	83	float toAtEndOfDurationNumber = static_cast<float&>(*toAtEndOfDuration->values[0]);
90	float& animatedNumber = animated->number();	84	float& animatedNumber = static_cast<float&>(*animated->values[0]);
91		85
92	// Apply CSS inheritance rules.	86	// Apply CSS inheritance rules.
93	m_animationElement->adjustForInheritance<float>(parseNumberFromString, m_animationElement->fromPropertyValueType(), fromNumber, m_contextElement);	87	m_animationElement->adjustForInheritance<float>(parseNumberFromString, m_animationElement->fromPropertyValueType(), fromNumber, m_contextElement);

Lines 32-45 SVGAnimatedNumberListAnimator::SVGAnimat Source/WebCore/svg/SVGAnimatedNumberList.cpp_sec1
- Source/WebCore/svg/SVGAnimatedNumberList.cpp -15 / +13 lines
32		32
33	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberListAnimator::constructFromString(const String& string)	33	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberListAnimator::constructFromString(const String& string)
34	{	34	{
35	auto animatedType = SVGAnimatedType::createNumberList(std::make_unique<SVGNumberListValues>());	35	return SVGAnimatedType::create(SVGPropertyTraits<SVGNumberListValues>::fromString(string));
36	animatedType->numberList().parse(string);
37	return animatedType;
38	}	36	}
39		37
40	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	38	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
41	{	39	{
42	return SVGAnimatedType::createNumberList(constructFromBaseValue<SVGAnimatedNumberList>(animatedTypes));	40	return constructFromBaseValue<SVGAnimatedNumberList>(animatedTypes);
43	}	41	}
44		42
45	void SVGAnimatedNumberListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	43	void SVGAnimatedNumberListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 49-55 void SVGAnimatedNumberListAnimator::stop Source/WebCore/svg/SVGAnimatedNumberList.cpp_sec2
49		47
50	void SVGAnimatedNumberListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	48	void SVGAnimatedNumberListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
51	{	49	{
52	resetFromBaseValue<SVGAnimatedNumberList>(animatedTypes, type, &SVGAnimatedType::numberList);	50	resetFromBaseValue<SVGAnimatedNumberList>(animatedTypes, type);
53	}	51	}
54		52
55	void SVGAnimatedNumberListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	53	void SVGAnimatedNumberListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 67-91 void SVGAnimatedNumberListAnimator::addA Source/WebCore/svg/SVGAnimatedNumberList.cpp_sec3
67	ASSERT(from->type() == AnimatedNumberList);	65	ASSERT(from->type() == AnimatedNumberList);
68	ASSERT(from->type() == to->type());	66	ASSERT(from->type() == to->type());
69		67
70	const auto& fromNumberList = from->numberList();	68	const auto& fromNumberList = static_cast<SVGNumberListValues&>(*from->values[0]);
71	auto& toNumberList = to->numberList();	69	auto& toNumberList = static_cast<SVGNumberListValues&>(*to->values[0]);
72		70
73	unsigned fromNumberListSize = fromNumberList.size();	71	unsigned fromNumberListSize = fromNumberList.size();
74	if (!fromNumberListSize \|\| fromNumberListSize != toNumberList.size())	72	if (!fromNumberListSize \|\| fromNumberListSize != toNumberList.size())
75	return;	73	return;
76		74
77	for (unsigned i = 0; i < fromNumberListSize; ++i)	75	for (unsigned i = 0; i < fromNumberListSize; ++i)
78	toNumberList[i] += fromNumberList[i];	76	static_cast<float&>(toNumberList[i]) += static_cast<float&>(fromNumberList[i]);
79	}	77	}
80		78
81	void SVGAnimatedNumberListAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)	79	void SVGAnimatedNumberListAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
82	{	80	{
83	ASSERT(m_animationElement);	81	ASSERT(m_animationElement);
84		82
85	const auto& fromNumberList = m_animationElement->animationMode() == ToAnimation ? animated->numberList() : from->numberList();	83	const auto& fromNumberList = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGNumberListValues&>(animated->values[0]) : static_cast<SVGNumberListValues&>(from->values[0]);
86	const auto& toNumberList = to->numberList();	84	const auto& toNumberList = static_cast<SVGNumberListValues&>(*to->values[0]);
87	const auto& toAtEndOfDurationNumberList = toAtEndOfDuration->numberList();	85	const auto& toAtEndOfDurationNumberList = static_cast<SVGNumberListValues&>(*toAtEndOfDuration->values[0]);
88	auto& animatedNumberList = animated->numberList();	86	auto& animatedNumberList = static_cast<SVGNumberListValues&>(*animated->values[0]);
89	if (!m_animationElement->adjustFromToListValues<SVGNumberListValues>(fromNumberList, toNumberList, animatedNumberList, percentage))	87	if (!m_animationElement->adjustFromToListValues<SVGNumberListValues>(fromNumberList, toNumberList, animatedNumberList, percentage))
90	return;	88	return;
91		89
Lines 94-102 void SVGAnimatedNumberListAnimator::calc Source/WebCore/svg/SVGAnimatedNumberList.cpp_sec4
94	unsigned toAtEndOfDurationSize = toAtEndOfDurationNumberList.size();	92	unsigned toAtEndOfDurationSize = toAtEndOfDurationNumberList.size();
95		93
96	for (unsigned i = 0; i < toNumberListSize; ++i) {	94	for (unsigned i = 0; i < toNumberListSize; ++i) {
97	float effectiveFrom = fromNumberListSize ? fromNumberList[i] : 0;	95	float effectiveFrom = fromNumberListSize ? fromNumberList.propertyAt(i) : 0;
98	float effectiveToAtEnd = i < toAtEndOfDurationSize ? toAtEndOfDurationNumberList[i] : 0;	96	float effectiveToAtEnd = i < toAtEndOfDurationSize ? toAtEndOfDurationNumberList.propertyAt(i) : 0;
99	m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom, toNumberList[i], effectiveToAtEnd, animatedNumberList[i]);	97	m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom, toNumberList.propertyAt(i), effectiveToAtEnd, animatedNumberList.propertyAt(i));
100	}	98	}
101	}	99	}
102		100

Lines 33-50 SVGAnimatedNumberOptionalNumberAnimator: Source/WebCore/svg/SVGAnimatedNumberOptionalNumber.cpp_sec1
- Source/WebCore/svg/SVGAnimatedNumberOptionalNumber.cpp -20 / +15 lines
33		33
34	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberOptionalNumberAnimator::constructFromString(const String& string)	34	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberOptionalNumberAnimator::constructFromString(const String& string)
35	{	35	{
36	auto animatedType = SVGAnimatedType::createNumberOptionalNumber(std::make_unique<std::pair<float, float>>());	36	return SVGAnimatedType::create(SVGPropertyTraits<std::pair<float, float>>::fromString(string));
37	std::pair<float, float>& animatedNumber = animatedType->numberOptionalNumber();
38	if (!parseNumberOptionalNumber(string, animatedNumber.first, animatedNumber.second)) {
39	animatedNumber.first = 0;
40	animatedNumber.second = 0;
41	}
42	return animatedType;
43	}	37	}
44		38
45	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberOptionalNumberAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	39	std::unique_ptr<SVGAnimatedType> SVGAnimatedNumberOptionalNumberAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
46	{	40	{
47	return SVGAnimatedType::createNumberOptionalNumber(constructFromBaseValues<SVGAnimatedNumber, SVGAnimatedNumber>(animatedTypes));	41	return constructFromBaseValues<SVGAnimatedNumber, SVGAnimatedNumber>(animatedTypes);
48	}	42	}
49		43
50	void SVGAnimatedNumberOptionalNumberAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	44	void SVGAnimatedNumberOptionalNumberAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 54-60 void SVGAnimatedNumberOptionalNumberAnim Source/WebCore/svg/SVGAnimatedNumberOptionalNumber.cpp_sec2
54		48
55	void SVGAnimatedNumberOptionalNumberAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	49	void SVGAnimatedNumberOptionalNumberAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
56	{	50	{
57	resetFromBaseValues<SVGAnimatedNumber, SVGAnimatedNumber>(animatedTypes, type, &SVGAnimatedType::numberOptionalNumber);	51	resetFromBaseValues<SVGAnimatedNumber, SVGAnimatedNumber>(animatedTypes, type);
58	}	52	}
59		53
60	void SVGAnimatedNumberOptionalNumberAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	54	void SVGAnimatedNumberOptionalNumberAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 72-82 void SVGAnimatedNumberOptionalNumberAnim Source/WebCore/svg/SVGAnimatedNumberOptionalNumber.cpp_sec3
72	ASSERT(from->type() == AnimatedNumberOptionalNumber);	66	ASSERT(from->type() == AnimatedNumberOptionalNumber);
73	ASSERT(from->type() == to->type());	67	ASSERT(from->type() == to->type());
74		68
75	const std::pair<float, float>& fromNumberPair = from->numberOptionalNumber();	69	static_cast<float&>(to->values[0]) += static_cast<float&>(from->values[0]);
76	std::pair<float, float>& toNumberPair = to->numberOptionalNumber();	70	static_cast<float&>(to->values[1]) += static_cast<float&>(from->values[1]);
77
78	toNumberPair.first += fromNumberPair.first;
79	toNumberPair.second += fromNumberPair.second;
80	}	71	}
81		72
82	void SVGAnimatedNumberOptionalNumberAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)	73	void SVGAnimatedNumberOptionalNumberAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
Lines 84-96 void SVGAnimatedNumberOptionalNumberAnim Source/WebCore/svg/SVGAnimatedNumberOptionalNumber.cpp_sec4
84	ASSERT(m_animationElement);	75	ASSERT(m_animationElement);
85	ASSERT(m_contextElement);	76	ASSERT(m_contextElement);
86		77
87	const std::pair<float, float>& fromNumberPair = m_animationElement->animationMode() == ToAnimation ? animated->numberOptionalNumber() : from->numberOptionalNumber();	78	const auto& formFirst = m_animationElement->animationMode() == ToAnimation ? static_cast<float&>(animated->values[0]) : static_cast<float&>(from->values[0]);
88	const std::pair<float, float>& toNumberPair = to->numberOptionalNumber();	79	const auto& formSecond = m_animationElement->animationMode() == ToAnimation ? static_cast<float&>(animated->values[1]) : static_cast<float&>(from->values[1]);
89	const std::pair<float, float>& toAtEndOfDurationNumberPair = toAtEndOfDuration->numberOptionalNumber();	80	const auto& toFirst = static_cast<float&>(*to->values[0]);
90	std::pair<float, float>& animatedNumberPair = animated->numberOptionalNumber();	81	const auto& toSecond = static_cast<float&>(*to->values[1]);
		82	const auto& toAtEndOfDurationFirst = static_cast<float&>(*toAtEndOfDuration->values[0]);
		83	const auto& toAtEndOfDurationSecond = static_cast<float&>(*toAtEndOfDuration->values[1]);
		84	auto& animatedFirst = static_cast<float&>(*animated->values[0]);
		85	auto& animatedSecond = static_cast<float&>(*animated->values[1]);
91		86
92	m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromNumberPair.first, toNumberPair.first, toAtEndOfDurationNumberPair.first, animatedNumberPair.first);	87	m_animationElement->animateAdditiveNumber(percentage, repeatCount, formFirst, toFirst, toAtEndOfDurationFirst, animatedFirst);
93	m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromNumberPair.second, toNumberPair.second, toAtEndOfDurationNumberPair.second, animatedNumberPair.second);	88	m_animationElement->animateAdditiveNumber(percentage, repeatCount, formSecond, toSecond, toAtEndOfDurationSecond, animatedSecond);
94	}	89	}
95		90
96	float SVGAnimatedNumberOptionalNumberAnimator::calculateDistance(const String&, const String&)	91	float SVGAnimatedNumberOptionalNumberAnimator::calculateDistance(const String&, const String&)

Lines 22-28 Source/WebCore/svg/SVGAnimatedPath.cpp_sec1
- Source/WebCore/svg/SVGAnimatedPath.cpp -32 / +26 lines
22		22
23	#include "SVGAnimateElementBase.h"	23	#include "SVGAnimateElementBase.h"
24	#include "SVGAnimatedPathSegListPropertyTearOff.h"	24	#include "SVGAnimatedPathSegListPropertyTearOff.h"
25	#include "SVGPathUtilities.h"
26		25
27	namespace WebCore {	26	namespace WebCore {
28		27
Lines 33-41 SVGAnimatedPathAnimator::SVGAnimatedPath Source/WebCore/svg/SVGAnimatedPath.cpp_sec2
33		32
34	std::unique_ptr<SVGAnimatedType> SVGAnimatedPathAnimator::constructFromString(const String& string)	33	std::unique_ptr<SVGAnimatedType> SVGAnimatedPathAnimator::constructFromString(const String& string)
35	{	34	{
36	auto byteStream = std::make_unique<SVGPathByteStream>();	35	return SVGAnimatedType::create(SVGPropertyTraits<SVGPathByteStream>::fromString(string));
37	buildSVGPathByteStreamFromString(string, *byteStream, UnalteredParsing);
38	return SVGAnimatedType::createPath(WTFMove(byteStream));
39	}	36	}
40		37
41	std::unique_ptr<SVGAnimatedType> SVGAnimatedPathAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	38	std::unique_ptr<SVGAnimatedType> SVGAnimatedPathAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 43-51 std::unique_ptr<SVGAnimatedType> SVGAnim Source/WebCore/svg/SVGAnimatedPath.cpp_sec3
43	ASSERT(animatedTypes.size() >= 1);	40	ASSERT(animatedTypes.size() >= 1);
44		41
45	// Build initial path byte stream.	42	// Build initial path byte stream.
46	auto byteStream = std::make_unique<SVGPathByteStream>();	43	auto animatedType = SVGAnimatedType::create<SVGPathByteStream>();
47	resetAnimValToBaseVal(animatedTypes, byteStream.get());	44	resetAnimValToBaseVal(animatedTypes, *animatedType);
48	return SVGAnimatedType::createPath(WTFMove(byteStream));	45	return animatedType;
49	}	46	}
50		47
51	void SVGAnimatedPathAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	48	void SVGAnimatedPathAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 58-64 void SVGAnimatedPathAnimator::resetAnimV Source/WebCore/svg/SVGAnimatedPath.cpp_sec4
58	RefPtr<SVGAnimatedPathSegListPropertyTearOff> property = castAnimatedPropertyToActualType<SVGAnimatedPathSegListPropertyTearOff>(animatedTypes[0].properties[0].get());	55	RefPtr<SVGAnimatedPathSegListPropertyTearOff> property = castAnimatedPropertyToActualType<SVGAnimatedPathSegListPropertyTearOff>(animatedTypes[0].properties[0].get());
59	const auto& baseValue = property->currentBaseValue();	56	const auto& baseValue = property->currentBaseValue();
60		57
61	buildSVGPathByteStreamFromSVGPathSegListValues(baseValue, *byteStream, UnalteredParsing);	58	buildSVGPathByteStreamFromSVGPathSegListValues(static_cast<SVGPathSegListValues&>(baseValue), byteStream, UnalteredParsing);
62		59
63	Vector<RefPtr<SVGAnimatedPathSegListPropertyTearOff>> result;	60	Vector<RefPtr<SVGAnimatedPathSegListPropertyTearOff>> result;
64		61
Lines 72-78 void SVGAnimatedPathAnimator::resetAnimV Source/WebCore/svg/SVGAnimatedPath.cpp_sec5
72	if (!result.isEmpty()) {	69	if (!result.isEmpty()) {
73	SVGElement::InstanceUpdateBlocker blocker(*property->contextElement());	70	SVGElement::InstanceUpdateBlocker blocker(*property->contextElement());
74	for (auto& segment : result)	71	for (auto& segment : result)
75	segment->animationStarted(byteStream, &baseValue);	72	segment->animationStarted(byteStream, &static_cast<SVGPathSegListValues&>(*baseValue));
76	}	73	}
77	}	74	}
78		75
Lines 80-86 void SVGAnimatedPathAnimator::resetAnimV Source/WebCore/svg/SVGAnimatedPath.cpp_sec6
80	{	77	{
81	ASSERT(animatedTypes.size() >= 1);	78	ASSERT(animatedTypes.size() >= 1);
82	ASSERT(type.type() == m_type);	79	ASSERT(type.type() == m_type);
83	resetAnimValToBaseVal(animatedTypes, type.path());	80	resetAnimValToBaseVal(animatedTypes, &static_cast<SVGPathByteStream&>(*type.values[0]));
84	}	81	}
85		82
86	void SVGAnimatedPathAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	83	void SVGAnimatedPathAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 98-109 void SVGAnimatedPathAnimator::addAnimate Source/WebCore/svg/SVGAnimatedPath.cpp_sec7
98	ASSERT(from->type() == AnimatedPath);	95	ASSERT(from->type() == AnimatedPath);
99	ASSERT(from->type() == to->type());	96	ASSERT(from->type() == to->type());
100		97
101	SVGPathByteStream* fromPath = from->path();	98	const auto& fromPath = static_cast<SVGPathByteStream&>(*from->values[0]);
102	SVGPathByteStream* toPath = to->path();	99	auto& toPath = static_cast<SVGPathByteStream&>(*to->values[0]);
103	unsigned fromPathSize = fromPath->size();	100	unsigned fromPathSize = fromPath.size();
104	if (!fromPathSize \|\| fromPathSize != toPath->size())	101	if (!fromPathSize \|\| fromPathSize != toPath.size())
105	return;	102	return;
106	addToSVGPathByteStream(toPath, fromPath);	103	addToSVGPathByteStream(toPath, fromPath);
107	}	104	}
108		105
109	void SVGAnimatedPathAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)	106	void SVGAnimatedPathAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
Lines 111-146 void SVGAnimatedPathAnimator::calculateA Source/WebCore/svg/SVGAnimatedPath.cpp_sec8
111	ASSERT(m_animationElement);	108	ASSERT(m_animationElement);
112	ASSERT(m_contextElement);	109	ASSERT(m_contextElement);
113		110
114	SVGPathByteStream* fromPath = from->path();	111	auto& fromPath = static_cast<SVGPathByteStream&>(*from->values[0]);
115	SVGPathByteStream* toPath = to->path();	112	auto& toPath = static_cast<SVGPathByteStream&>(*to->values[0]);
116	SVGPathByteStream* toAtEndOfDurationPath = toAtEndOfDuration->path();	113	auto& toAtEndOfDurationPath = static_cast<SVGPathByteStream&>(*toAtEndOfDuration->values[0]);
117	SVGPathByteStream* animatedPath = animated->path();	114	auto& animatedPath = static_cast<SVGPathByteStream&>(*animated->values[0]);
118		115
119	std::unique_ptr<SVGPathByteStream> underlyingPath;
120	bool isToAnimation = m_animationElement->animationMode() == ToAnimation;	116	bool isToAnimation = m_animationElement->animationMode() == ToAnimation;
121	if (isToAnimation) {	117	if (isToAnimation)
122	underlyingPath = animatedPath->copy();	118	fromPath = animatedPath;
123	fromPath = underlyingPath.get();
124	}
125		119
126	// Cache the current animated value before the buildAnimatedSVGPathByteStream() clears animatedPath.	120	// Cache the current animated value before the buildAnimatedSVGPathByteStream() clears animatedPath.
127	std::unique_ptr<SVGPathByteStream> lastAnimatedPath;	121	SVGPathByteStream lastAnimatedPath;
128	if (!fromPath->size() \|\| (m_animationElement->isAdditive() && !isToAnimation))	122	if (!fromPath.size() \|\| (m_animationElement->isAdditive() && !isToAnimation))
129	lastAnimatedPath = animatedPath->copy();	123	lastAnimatedPath = animatedPath;
130		124
131	// Pass false to 'resizeAnimatedListIfNeeded' here, as the path animation is not a regular Vector<SVGXXX> type, but a SVGPathByteStream, that works differently.	125	// Pass false to 'resizeAnimatedListIfNeeded' here, as the path animation is not a regular Vector<SVGXXX> type, but a SVGPathByteStream, that works differently.
132	if (!m_animationElement->adjustFromToListValues<SVGPathByteStream>(fromPath, toPath, *animatedPath, percentage, false))	126	if (!m_animationElement->adjustFromToListValues<SVGPathByteStream>(fromPath, toPath, animatedPath, percentage, false))
133	return;	127	return;
134		128
135	buildAnimatedSVGPathByteStream(fromPath, toPath, *animatedPath, percentage);	129	buildAnimatedSVGPathByteStream(fromPath, toPath, animatedPath, percentage);
136		130
137	// Handle additive='sum'.	131	// Handle additive='sum'.
138	if (lastAnimatedPath)	132	if (!lastAnimatedPath.isEmpty())
139	addToSVGPathByteStream(animatedPath, lastAnimatedPath);	133	addToSVGPathByteStream(animatedPath, lastAnimatedPath);
140		134
141	// Handle accumulate='sum'.	135	// Handle accumulate='sum'.
142	if (m_animationElement->isAccumulated() && repeatCount)	136	if (m_animationElement->isAccumulated() && repeatCount)
143	addToSVGPathByteStream(animatedPath, toAtEndOfDurationPath, repeatCount);	137	addToSVGPathByteStream(animatedPath, toAtEndOfDurationPath, repeatCount);
144	}	138	}
145		139
146	float SVGAnimatedPathAnimator::calculateDistance(const String&, const String&)	140	float SVGAnimatedPathAnimator::calculateDistance(const String&, const String&)

Lines 34-47 SVGAnimatedPointListAnimator::SVGAnimate Source/WebCore/svg/SVGAnimatedPointList.cpp_sec1
- Source/WebCore/svg/SVGAnimatedPointList.cpp -19 / +17 lines
34		34
35	std::unique_ptr<SVGAnimatedType> SVGAnimatedPointListAnimator::constructFromString(const String& string)	35	std::unique_ptr<SVGAnimatedType> SVGAnimatedPointListAnimator::constructFromString(const String& string)
36	{	36	{
37	auto animatedType = SVGAnimatedType::createPointList(std::make_unique<SVGPointListValues>());	37	return SVGAnimatedType::create(SVGPropertyTraits<SVGPointListValues>::fromString(string));
38	pointsListFromSVGData(animatedType->pointList(), string);
39	return animatedType;
40	}	38	}
41		39
42	std::unique_ptr<SVGAnimatedType> SVGAnimatedPointListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	40	std::unique_ptr<SVGAnimatedType> SVGAnimatedPointListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
43	{	41	{
44	return SVGAnimatedType::createPointList(constructFromBaseValue<SVGAnimatedPointList>(animatedTypes));	42	return constructFromBaseValue<SVGAnimatedPointList>(animatedTypes);
45	}	43	}
46		44
47	void SVGAnimatedPointListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	45	void SVGAnimatedPointListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 51-57 void SVGAnimatedPointListAnimator::stopA Source/WebCore/svg/SVGAnimatedPointList.cpp_sec2
51		49
52	void SVGAnimatedPointListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	50	void SVGAnimatedPointListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
53	{	51	{
54	resetFromBaseValue<SVGAnimatedPointList>(animatedTypes, type, &SVGAnimatedType::pointList);	52	resetFromBaseValue<SVGAnimatedPointList>(animatedTypes, type);
55	}	53	}
56		54
57	void SVGAnimatedPointListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	55	void SVGAnimatedPointListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 69-93 void SVGAnimatedPointListAnimator::addAn Source/WebCore/svg/SVGAnimatedPointList.cpp_sec3
69	ASSERT(from->type() == AnimatedPoints);	67	ASSERT(from->type() == AnimatedPoints);
70	ASSERT(from->type() == to->type());	68	ASSERT(from->type() == to->type());
71		69
72	const auto& fromPointList = from->pointList();	70	const auto& fromPointList = static_cast<SVGPointListValues&>(*from->values[0]);
73	auto& toPointList = to->pointList();	71	auto& toPointList = static_cast<SVGPointListValues&>(*to->values[0]);
74		72
75	unsigned fromPointListSize = fromPointList.size();	73	unsigned fromPointListSize = fromPointList.size();
76	if (!fromPointListSize \|\| fromPointListSize != toPointList.size())	74	if (!fromPointListSize \|\| fromPointListSize != toPointList.size())
77	return;	75	return;
78		76
79	for (unsigned i = 0; i < fromPointListSize; ++i)	77	for (unsigned i = 0; i < fromPointListSize; ++i)
80	toPointList[i] += fromPointList[i];	78	toPointList.propertyAt(i) += fromPointList.propertyAt(i);
81	}	79	}
82		80
83	void SVGAnimatedPointListAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)	81	void SVGAnimatedPointListAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
84	{	82	{
85	ASSERT(m_animationElement);	83	ASSERT(m_animationElement);
86		84
87	const auto& fromPointList = m_animationElement->animationMode() == ToAnimation ? animated->pointList() : from->pointList();	85	const auto& fromPointList = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGPointListValues&>(animated->values[0]) : static_cast<SVGPointListValues&>(from->values[0]);
88	const auto& toPointList = to->pointList();	86	const auto& toPointList = static_cast<SVGPointListValues&>(*to->values[0]);
89	const auto& toAtEndOfDurationPointList = toAtEndOfDuration->pointList();	87	const auto& toAtEndOfDurationPointList = static_cast<SVGPointListValues&>(*toAtEndOfDuration->values[0]);
90	auto& animatedPointList = animated->pointList();	88	auto& animatedPointList = static_cast<SVGPointListValues&>(*animated->values[0]);
91	if (!m_animationElement->adjustFromToListValues<SVGPointListValues>(fromPointList, toPointList, animatedPointList, percentage))	89	if (!m_animationElement->adjustFromToListValues<SVGPointListValues>(fromPointList, toPointList, animatedPointList, percentage))
92	return;	90	return;
93		91
Lines 98-111 void SVGAnimatedPointListAnimator::calcu Source/WebCore/svg/SVGAnimatedPointList.cpp_sec4
98	for (unsigned i = 0; i < toPointListSize; ++i) {	96	for (unsigned i = 0; i < toPointListSize; ++i) {
99	FloatPoint effectiveFrom;	97	FloatPoint effectiveFrom;
100	if (fromPointListSize)	98	if (fromPointListSize)
101	effectiveFrom = fromPointList[i];	99	effectiveFrom = fromPointList.propertyAt(i);
102	FloatPoint effectiveToAtEnd = i < toAtEndOfDurationSize ? toAtEndOfDurationPointList[i] : FloatPoint();	100	FloatPoint effectiveToAtEnd = i < toAtEndOfDurationSize ? toAtEndOfDurationPointList.propertyAt(i) : FloatPoint();
103		101
104	float animatedX = animatedPointList[i].x();	102	float animatedX = animatedPointList.propertyAt(i).x();
105	float animatedY = animatedPointList[i].y();	103	float animatedY = animatedPointList.propertyAt(i).y();
106	m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom.x(), toPointList[i].x(), effectiveToAtEnd.x(), animatedX);	104	m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom.x(), toPointList.propertyAt(i).x(), effectiveToAtEnd.x(), animatedX);
107	m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom.y(), toPointList[i].y(), effectiveToAtEnd.y(), animatedY);	105	m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom.y(), toPointList.propertyAt(i).y(), effectiveToAtEnd.y(), animatedY);
108	animatedPointList[i] = FloatPoint(animatedX, animatedY);	106	animatedPointList.propertyAt(i) = FloatPoint(animatedX, animatedY);
109	}	107	}
110	}	108	}
111		109

Lines 31-44 SVGAnimatedPreserveAspectRatioAnimator:: Source/WebCore/svg/SVGAnimatedPreserveAspectRatio.cpp_sec1
- Source/WebCore/svg/SVGAnimatedPreserveAspectRatio.cpp -8 / +6 lines
31		31
32	std::unique_ptr<SVGAnimatedType> SVGAnimatedPreserveAspectRatioAnimator::constructFromString(const String& string)	32	std::unique_ptr<SVGAnimatedType> SVGAnimatedPreserveAspectRatioAnimator::constructFromString(const String& string)
33	{	33	{
34	auto animatedType = SVGAnimatedType::createPreserveAspectRatio(std::make_unique<SVGPreserveAspectRatioValue>());	34	return SVGAnimatedType::create(SVGPropertyTraits<SVGPreserveAspectRatioValue>::fromString(string));
35	animatedType->preserveAspectRatio().parse(string);
36	return animatedType;
37	}	35	}
38		36
39	std::unique_ptr<SVGAnimatedType> SVGAnimatedPreserveAspectRatioAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	37	std::unique_ptr<SVGAnimatedType> SVGAnimatedPreserveAspectRatioAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
40	{	38	{
41	return SVGAnimatedType::createPreserveAspectRatio(constructFromBaseValue<SVGAnimatedPreserveAspectRatio>(animatedTypes));	39	return constructFromBaseValue<SVGAnimatedPreserveAspectRatio>(animatedTypes);
42	}	40	}
43		41
44	void SVGAnimatedPreserveAspectRatioAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	42	void SVGAnimatedPreserveAspectRatioAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 48-54 void SVGAnimatedPreserveAspectRatioAnima Source/WebCore/svg/SVGAnimatedPreserveAspectRatio.cpp_sec2
48		46
49	void SVGAnimatedPreserveAspectRatioAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	47	void SVGAnimatedPreserveAspectRatioAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
50	{	48	{
51	resetFromBaseValue<SVGAnimatedPreserveAspectRatio>(animatedTypes, type, &SVGAnimatedType::preserveAspectRatio);	49	resetFromBaseValue<SVGAnimatedPreserveAspectRatio>(animatedTypes, type);
52	}	50	}
53		51
54	void SVGAnimatedPreserveAspectRatioAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	52	void SVGAnimatedPreserveAspectRatioAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 71-79 void SVGAnimatedPreserveAspectRatioAnima Source/WebCore/svg/SVGAnimatedPreserveAspectRatio.cpp_sec3
71	ASSERT(m_animationElement);	69	ASSERT(m_animationElement);
72	ASSERT(m_contextElement);	70	ASSERT(m_contextElement);
73		71
74	const auto& fromPreserveAspectRatio = m_animationElement->animationMode() == ToAnimation ? animated->preserveAspectRatio() : from->preserveAspectRatio();	72	const auto& fromPreserveAspectRatio = m_animationElement->animationMode() == ToAnimation ? static_cast<SVGPreserveAspectRatioValue&>(animated->values[0]) : static_cast<SVGPreserveAspectRatioValue&>(from->values[0]);
75	const auto& toPreserveAspectRatio = to->preserveAspectRatio();	73	const auto& toPreserveAspectRatio = static_cast<SVGPreserveAspectRatioValue&>(*to->values[0]);
76	auto& animatedPreserveAspectRatio = animated->preserveAspectRatio();	74	auto& animatedPreserveAspectRatio = static_cast<SVGPreserveAspectRatioValue&>(*animated->values[0]);
77		75
78	m_animationElement->animateDiscreteType<SVGPreserveAspectRatioValue>(percentage, fromPreserveAspectRatio, toPreserveAspectRatio, animatedPreserveAspectRatio);	76	m_animationElement->animateDiscreteType<SVGPreserveAspectRatioValue>(percentage, fromPreserveAspectRatio, toPreserveAspectRatio, animatedPreserveAspectRatio);
79	}	77	}

Lines 32-45 SVGAnimatedRectAnimator::SVGAnimatedRect Source/WebCore/svg/SVGAnimatedRect.cpp_sec1
- Source/WebCore/svg/SVGAnimatedRect.cpp -10 / +8 lines
32		32
33	std::unique_ptr<SVGAnimatedType> SVGAnimatedRectAnimator::constructFromString(const String& string)	33	std::unique_ptr<SVGAnimatedType> SVGAnimatedRectAnimator::constructFromString(const String& string)
34	{	34	{
35	auto animatedType = SVGAnimatedType::createRect(std::make_unique<FloatRect>());	35	return SVGAnimatedType::create(SVGPropertyTraits<FloatRect>::fromString(string));
36	parseRect(string, animatedType->rect());
37	return animatedType;
38	}	36	}
39		37
40	std::unique_ptr<SVGAnimatedType> SVGAnimatedRectAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	38	std::unique_ptr<SVGAnimatedType> SVGAnimatedRectAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
41	{	39	{
42	return SVGAnimatedType::createRect(constructFromBaseValue<SVGAnimatedRect>(animatedTypes));	40	return constructFromBaseValue<SVGAnimatedRect>(animatedTypes);
43	}	41	}
44		42
45	void SVGAnimatedRectAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	43	void SVGAnimatedRectAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 49-55 void SVGAnimatedRectAnimator::stopAnimVa Source/WebCore/svg/SVGAnimatedRect.cpp_sec2
49		47
50	void SVGAnimatedRectAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	48	void SVGAnimatedRectAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
51	{	49	{
52	resetFromBaseValue<SVGAnimatedRect>(animatedTypes, type, &SVGAnimatedType::rect);	50	resetFromBaseValue<SVGAnimatedRect>(animatedTypes, type);
53	}	51	}
54		52
55	void SVGAnimatedRectAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	53	void SVGAnimatedRectAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 67-73 void SVGAnimatedRectAnimator::addAnimate Source/WebCore/svg/SVGAnimatedRect.cpp_sec3
67	ASSERT(from->type() == AnimatedRect);	65	ASSERT(from->type() == AnimatedRect);
68	ASSERT(from->type() == to->type());	66	ASSERT(from->type() == to->type());
69		67
70	to->rect() += from->rect();	68	static_cast<FloatRect&>(to->values[0]) += static_cast<FloatRect&>(from->values[0]);
71	}	69	}
72		70
73	void SVGAnimatedRectAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)	71	void SVGAnimatedRectAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
Lines 75-84 void SVGAnimatedRectAnimator::calculateA Source/WebCore/svg/SVGAnimatedRect.cpp_sec4
75	ASSERT(m_animationElement);	73	ASSERT(m_animationElement);
76	ASSERT(m_contextElement);	74	ASSERT(m_contextElement);
77		75
78	const FloatRect& fromRect = m_animationElement->animationMode() == ToAnimation ? animated->rect() : from->rect();	76	const auto& fromRect = m_animationElement->animationMode() == ToAnimation ? static_cast<FloatRect&>(animated->values[0]) : static_cast<FloatRect&>(from->values[0]);
79	const FloatRect& toRect = to->rect();	77	const auto& toRect = static_cast<FloatRect&>(*to->values[0]);
80	const FloatRect& toAtEndOfDurationRect = toAtEndOfDuration->rect();	78	const auto& toAtEndOfDurationRect = static_cast<FloatRect&>(*toAtEndOfDuration->values[0]);
81	FloatRect& animatedRect = animated->rect();	79	auto& animatedRect = static_cast<FloatRect&>(*animated->values[0]);
82		80
83	float animatedX = animatedRect.x();	81	float animatedX = animatedRect.x();
84	float animatedY = animatedRect.y();	82	float animatedY = animatedRect.y();

Lines 1-5 Source/WebCore/svg/SVGAnimatedString.cpp_sec1
- Source/WebCore/svg/SVGAnimatedString.cpp -8 / +7 lines
1	/*	1	/*
2	* Copyright (C) Research In Motion Limited 2011. All rights reserved.	2	* Copyright (C) Research In Motion Limited 2011. All rights reserved.
		3	* Copyright (C) 2018 Apple Inc. All rights reserved.
3	*	4	*
4	* This library is free software; you can redistribute it and/or	5	* This library is free software; you can redistribute it and/or
5	* modify it under the terms of the GNU Library General Public	6	* modify it under the terms of the GNU Library General Public
Lines 31-44 SVGAnimatedStringAnimator::SVGAnimatedSt Source/WebCore/svg/SVGAnimatedString.cpp_sec2
31		32
32	std::unique_ptr<SVGAnimatedType> SVGAnimatedStringAnimator::constructFromString(const String& string)	33	std::unique_ptr<SVGAnimatedType> SVGAnimatedStringAnimator::constructFromString(const String& string)
33	{	34	{
34	auto animatedType = SVGAnimatedType::createString(std::make_unique<String>());	35	return SVGAnimatedType::create(SVGPropertyTraits<String>::fromString(string));
35	animatedType->string() = string;
36	return animatedType;
37	}	36	}
38		37
39	std::unique_ptr<SVGAnimatedType> SVGAnimatedStringAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	38	std::unique_ptr<SVGAnimatedType> SVGAnimatedStringAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
40	{	39	{
41	return SVGAnimatedType::createString(constructFromBaseValue<SVGAnimatedString>(animatedTypes));	40	return constructFromBaseValue<SVGAnimatedString>(animatedTypes);
42	}	41	}
43		42
44	void SVGAnimatedStringAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	43	void SVGAnimatedStringAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 48-54 void SVGAnimatedStringAnimator::stopAnim Source/WebCore/svg/SVGAnimatedString.cpp_sec3
48		47
49	void SVGAnimatedStringAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	48	void SVGAnimatedStringAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
50	{	49	{
51	resetFromBaseValue<SVGAnimatedString>(animatedTypes, type, &SVGAnimatedType::string);	50	resetFromBaseValue<SVGAnimatedString>(animatedTypes, type);
52	}	51	}
53		52
54	void SVGAnimatedStringAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	53	void SVGAnimatedStringAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 76-84 void SVGAnimatedStringAnimator::calculat Source/WebCore/svg/SVGAnimatedString.cpp_sec4
76	ASSERT(m_animationElement);	75	ASSERT(m_animationElement);
77	ASSERT(m_contextElement);	76	ASSERT(m_contextElement);
78		77
79	String fromString = from->string();	78	String fromString = static_cast<String&>(*from->values[0]);
80	String toString = to->string();	79	String toString = static_cast<String&>(*to->values[0]);
81	String& animatedString = animated->string();	80	String& animatedString = static_cast<String&>(*animated->values[0]);
82		81
83	// Apply CSS inheritance rules.	82	// Apply CSS inheritance rules.
84	m_animationElement->adjustForInheritance<String>(parseStringFromString, m_animationElement->fromPropertyValueType(), fromString, m_contextElement);	83	m_animationElement->adjustForInheritance<String>(parseStringFromString, m_animationElement->fromPropertyValueType(), fromString, m_contextElement);

Lines 41-55 SVGAnimatedTransformListAnimator::SVGAni Source/WebCore/svg/SVGAnimatedTransformList.cpp_sec1
- Source/WebCore/svg/SVGAnimatedTransformList.cpp -23 / +20 lines
41		41
42	std::unique_ptr<SVGAnimatedType> SVGAnimatedTransformListAnimator::constructFromString(const String& string)	42	std::unique_ptr<SVGAnimatedType> SVGAnimatedTransformListAnimator::constructFromString(const String& string)
43	{	43	{
44	auto animatedType = SVGAnimatedType::createTransformList(std::make_unique<SVGTransformListValues>());	44	return SVGAnimatedType::create(SVGPropertyTraits<SVGTransformListValues>::fromString(m_transformTypeString + string + ')'));
45	animatedType->transformList().parse(m_transformTypeString + string + ')');
46	ASSERT(animatedType->transformList().size() <= 1);
47	return animatedType;
48	}	45	}
49		46
50	std::unique_ptr<SVGAnimatedType> SVGAnimatedTransformListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	47	std::unique_ptr<SVGAnimatedType> SVGAnimatedTransformListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
51	{	48	{
52	return SVGAnimatedType::createTransformList(constructFromBaseValue<SVGAnimatedTransformList>(animatedTypes));	49	return constructFromBaseValue<SVGAnimatedTransformList>(animatedTypes);
53	}	50	}
54		51
55	void SVGAnimatedTransformListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)	52	void SVGAnimatedTransformListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 59-65 void SVGAnimatedTransformListAnimator::s Source/WebCore/svg/SVGAnimatedTransformList.cpp_sec2
59		56
60	void SVGAnimatedTransformListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)	57	void SVGAnimatedTransformListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
61	{	58	{
62	resetFromBaseValue<SVGAnimatedTransformList>(animatedTypes, type, &SVGAnimatedType::transformList);	59	resetFromBaseValue<SVGAnimatedTransformList>(animatedTypes, type);
63	}	60	}
64		61
65	void SVGAnimatedTransformListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)	62	void SVGAnimatedTransformListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
Lines 77-91 void SVGAnimatedTransformListAnimator::a Source/WebCore/svg/SVGAnimatedTransformList.cpp_sec3
77	ASSERT(from->type() == AnimatedTransformList);	74	ASSERT(from->type() == AnimatedTransformList);
78	ASSERT(from->type() == to->type());	75	ASSERT(from->type() == to->type());
79		76
80	const auto& fromTransformList = from->transformList();	77	const auto& fromTransformList = static_cast<SVGTransformListValues&>(*from->values[0]);
81	auto& toTransformList = to->transformList();	78	auto& toTransformList = static_cast<SVGTransformListValues&>(*to->values[0]);
82	auto fromTransformListSize = fromTransformList.size();	79	auto fromTransformListSize = fromTransformList.size();
83	if (!fromTransformListSize \|\| fromTransformListSize != toTransformList.size())	80	if (!fromTransformListSize \|\| fromTransformListSize != toTransformList.size())
84	return;	81	return;
85		82
86	ASSERT(fromTransformListSize == 1);	83	ASSERT(fromTransformListSize == 1);
87	const auto& fromTransform = fromTransformList[0];	84	const auto& fromTransform = fromTransformList.propertyAt(0);
88	auto& toTransform = toTransformList[0];	85	auto& toTransform = toTransformList.propertyAt(0);
89		86
90	ASSERT(fromTransform.type() == toTransform.type());	87	ASSERT(fromTransform.type() == toTransform.type());
91	toTransform = SVGTransformDistance::addSVGTransforms(fromTransform, toTransform);	88	toTransform = SVGTransformDistance::addSVGTransforms(fromTransform, toTransform);
Lines 98-107 void SVGAnimatedTransformListAnimator::c Source/WebCore/svg/SVGAnimatedTransformList.cpp_sec4
98	// Spec: To animations provide specific functionality to get a smooth change from the underlying value to the	95	// Spec: To animations provide specific functionality to get a smooth change from the underlying value to the
99	// ‘to’ attribute value, which conflicts mathematically with the requirement for additive transform animations	96	// ‘to’ attribute value, which conflicts mathematically with the requirement for additive transform animations
100	// to be post-multiplied. As a consequence, in SVG 1.1 the behavior of to animations for ‘animateTransform’ is undefined.	97	// to be post-multiplied. As a consequence, in SVG 1.1 the behavior of to animations for ‘animateTransform’ is undefined.
101	const auto& fromTransformList = from->transformList();	98	const auto& fromTransformList = static_cast<SVGTransformListValues&>(*from->values[0]);
102	const auto& toTransformList = to->transformList();	99	const auto& toTransformList = static_cast<SVGTransformListValues&>(*to->values[0]);
103	const auto& toAtEndOfDurationTransformList = toAtEndOfDuration->transformList();	100	const auto& toAtEndOfDurationTransformList = static_cast<SVGTransformListValues&>(*toAtEndOfDuration->values[0]);
104	auto& animatedTransformList = animated->transformList();	101	auto& animatedTransformList = static_cast<SVGTransformListValues&>(*animated->values[0]);
105		102
106	// Pass false to 'resizeAnimatedListIfNeeded' here, as the special post-multiplication behavior of <animateTransform> needs to be respected below.	103	// Pass false to 'resizeAnimatedListIfNeeded' here, as the special post-multiplication behavior of <animateTransform> needs to be respected below.
107	if (!m_animationElement->adjustFromToListValues<SVGTransformListValues>(fromTransformList, toTransformList, animatedTransformList, percentage, false))	104	if (!m_animationElement->adjustFromToListValues<SVGTransformListValues>(fromTransformList, toTransformList, animatedTransformList, percentage, false))
Lines 112-125 void SVGAnimatedTransformListAnimator::c Source/WebCore/svg/SVGAnimatedTransformList.cpp_sec5
112	animatedTransformList.clear();	109	animatedTransformList.clear();
113		110
114	auto fromTransformListSize = fromTransformList.size();	111	auto fromTransformListSize = fromTransformList.size();
115	const auto& toTransform = toTransformList[0];	112	const auto& toTransform = toTransformList.propertyAt(0);
116	const auto effectiveFrom = fromTransformListSize ? fromTransformList[0] : SVGTransformValue(toTransform.type(), SVGTransformValue::ConstructZeroTransform);	113	const auto effectiveFrom = fromTransformListSize ? fromTransformList.propertyAt(0) : SVGTransformValue(toTransform.type(), SVGTransformValue::ConstructZeroTransform);
117	auto currentTransform = SVGTransformDistance(effectiveFrom, toTransform).scaledDistance(percentage).addToSVGTransform(effectiveFrom);	114	auto currentTransform = SVGTransformDistance(effectiveFrom, toTransform).scaledDistance(percentage).addToSVGTransform(effectiveFrom);
118	if (m_animationElement->isAccumulated() && repeatCount) {	115	if (m_animationElement->isAccumulated() && repeatCount) {
119	const auto effectiveToAtEnd = toAtEndOfDurationTransformList.size() ? toAtEndOfDurationTransformList[0] : SVGTransformValue(toTransform.type(), SVGTransformValue::ConstructZeroTransform);	116	const auto effectiveToAtEnd = toAtEndOfDurationTransformList.size() ? toAtEndOfDurationTransformList.propertyAt(0) : SVGTransformValue(toTransform.type(), SVGTransformValue::ConstructZeroTransform);
120	animatedTransformList.append(SVGTransformDistance::addSVGTransforms(currentTransform, effectiveToAtEnd, repeatCount));	117	animatedTransformList.append(SVGValue::create<SVGTransformValue>(SVGTransformDistance::addSVGTransforms(currentTransform, effectiveToAtEnd, repeatCount)));
121	} else	118	} else
122	animatedTransformList.append(currentTransform);	119	animatedTransformList.append(SVGValue::create<SVGTransformValue>(currentTransform));
123	}	120	}
124		121
125	float SVGAnimatedTransformListAnimator::calculateDistance(const String& fromString, const String& toString)	122	float SVGAnimatedTransformListAnimator::calculateDistance(const String& fromString, const String& toString)
Lines 131-150 float SVGAnimatedTransformListAnimator:: Source/WebCore/svg/SVGAnimatedTransformList.cpp_sec6
131	auto from = constructFromString(fromString);	128	auto from = constructFromString(fromString);
132	auto to = constructFromString(toString);	129	auto to = constructFromString(toString);
133		130
134	auto& fromTransformList = from->transformList();	131	auto& fromTransformList = static_cast<SVGTransformListValues&>(*from->values[0]);
135	auto& toTransformList = to->transformList();	132	auto& toTransformList = static_cast<SVGTransformListValues&>(*to->values[0]);
136	unsigned itemsCount = fromTransformList.size();	133	unsigned itemsCount = fromTransformList.size();
137	if (!itemsCount \|\| itemsCount != toTransformList.size())	134	if (!itemsCount \|\| itemsCount != toTransformList.size())
138	return -1;	135	return -1;
139		136
140	ASSERT(itemsCount == 1);	137	ASSERT(itemsCount == 1);
141	if (fromTransformList[0].type() != toTransformList[0].type())	138	if (fromTransformList.propertyAt(0).type() != toTransformList.propertyAt(0).type())
142	return -1;	139	return -1;
143		140
144	// Spec: http://www.w3.org/TR/SVG/animate.html#complexDistances	141	// Spec: http://www.w3.org/TR/SVG/animate.html#complexDistances
145	// Paced animations assume a notion of distance between the various animation values defined by the ‘to’, ‘from’, ‘by’ and ‘values’ attributes.	142	// Paced animations assume a notion of distance between the various animation values defined by the ‘to’, ‘from’, ‘by’ and ‘values’ attributes.
146	// Distance is defined only for scalar types (such as <length>), colors and the subset of transformation types that are supported by ‘animateTransform’.	143	// Distance is defined only for scalar types (such as <length>), colors and the subset of transformation types that are supported by ‘animateTransform’.
147	return SVGTransformDistance(fromTransformList[0], toTransformList[0]).distance();	144	return SVGTransformDistance(fromTransformList.propertyAt(0), toTransformList.propertyAt(0)).distance();
148	}	145	}
149		146
150	}	147	}

Lines 1-327 Source/WebCore/svg/SVGAnimatedType.cpp_sec1
- Source/WebCore/svg/SVGAnimatedType.cpp -328 lines
1	/*
2	* Copyright (C) Research In Motion Limited 2011. All rights reserved.
3	*
4	* This library is free software; you can redistribute it and/or
5	* modify it under the terms of the GNU Library General Public
6	* License as published by the Free Software Foundation; either
7	* version 2 of the License, or (at your option) any later version.
8	*
9	* This library is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12	* Library General Public License for more details.
13	*
14	* You should have received a copy of the GNU Library General Public License
15	* along with this library; see the file COPYING.LIB. If not, write to
16	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17	* Boston, MA 02110-1301, USA.
18	*/
19
20	#include "config.h"
21	#include "SVGAnimatedType.h"
22
23	#include "CSSParser.h"
24	#include "SVGParserUtilities.h"
25	#include "SVGPathByteStream.h"
26
27	namespace WebCore {
28
29	SVGAnimatedType::SVGAnimatedType(AnimatedPropertyType type)
30	: m_type(type)
31	{
32	}
33
34	SVGAnimatedType::~SVGAnimatedType()
35	{
36	switch (m_type) {
37	case AnimatedAngle:
38	delete m_data.angleAndEnumeration;
39	break;
40	case AnimatedBoolean:
41	delete m_data.boolean;
42	break;
43	case AnimatedColor:
44	delete m_data.color;
45	break;
46	case AnimatedEnumeration:
47	delete m_data.enumeration;
48	break;
49	case AnimatedInteger:
50	delete m_data.integer;
51	break;
52	case AnimatedIntegerOptionalInteger:
53	delete m_data.integerOptionalInteger;
54	break;
55	case AnimatedLength:
56	delete m_data.length;
57	break;
58	case AnimatedLengthList:
59	delete m_data.lengthList;
60	break;
61	case AnimatedNumber:
62	delete m_data.number;
63	break;
64	case AnimatedNumberList:
65	delete m_data.numberList;
66	break;
67	case AnimatedNumberOptionalNumber:
68	delete m_data.numberOptionalNumber;
69	break;
70	case AnimatedPath:
71	delete m_data.path;
72	break;
73	case AnimatedPoints:
74	delete m_data.pointList;
75	break;
76	case AnimatedPreserveAspectRatio:
77	delete m_data.preserveAspectRatio;
78	break;
79	case AnimatedRect:
80	delete m_data.rect;
81	break;
82	case AnimatedString:
83	delete m_data.string;
84	break;
85	case AnimatedTransformList:
86	delete m_data.transformList;
87	break;
88	case AnimatedUnknown:
89	ASSERT_NOT_REACHED();
90	break;
91	}
92	}
93
94	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createAngleAndEnumeration(std::unique_ptr<std::pair<SVGAngleValue, unsigned>> angleAndEnumeration)
95	{
96	ASSERT(angleAndEnumeration);
97	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedAngle);
98	animatedType->m_data.angleAndEnumeration = angleAndEnumeration.release();
99	return animatedType;
100	}
101
102	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createBoolean(std::unique_ptr<bool> boolean)
103	{
104	ASSERT(boolean);
105	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedBoolean);
106	animatedType->m_data.boolean = boolean.release();
107	return animatedType;
108	}
109
110	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createColor(std::unique_ptr<Color> color)
111	{
112	ASSERT(color);
113	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedColor);
114	animatedType->m_data.color = color.release();
115	return animatedType;
116	}
117
118	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createEnumeration(std::unique_ptr<unsigned> enumeration)
119	{
120	ASSERT(enumeration);
121	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedEnumeration);
122	animatedType->m_data.enumeration = enumeration.release();
123	return animatedType;
124	}
125
126	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createInteger(std::unique_ptr<int> integer)
127	{
128	ASSERT(integer);
129	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedInteger);
130	animatedType->m_data.integer = integer.release();
131	return animatedType;
132	}
133
134	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createIntegerOptionalInteger(std::unique_ptr<std::pair<int, int>> integerOptionalInteger)
135	{
136	ASSERT(integerOptionalInteger);
137	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedIntegerOptionalInteger);
138	animatedType->m_data.integerOptionalInteger = integerOptionalInteger.release();
139	return animatedType;
140	}
141
142	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createLength(std::unique_ptr<SVGLengthValue> length)
143	{
144	ASSERT(length);
145	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedLength);
146	animatedType->m_data.length = length.release();
147	return animatedType;
148	}
149
150	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createLengthList(std::unique_ptr<SVGLengthListValues> lengthList)
151	{
152	ASSERT(lengthList);
153	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedLengthList);
154	animatedType->m_data.lengthList = lengthList.release();
155	return animatedType;
156	}
157
158	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createNumber(std::unique_ptr<float> number)
159	{
160	ASSERT(number);
161	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedNumber);
162	animatedType->m_data.number = number.release();
163	return animatedType;
164	}
165
166	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createNumberList(std::unique_ptr<SVGNumberListValues> numberList)
167	{
168	ASSERT(numberList);
169	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedNumberList);
170	animatedType->m_data.numberList = numberList.release();
171	return animatedType;
172	}
173
174	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createNumberOptionalNumber(std::unique_ptr<std::pair<float, float>> numberOptionalNumber)
175	{
176	ASSERT(numberOptionalNumber);
177	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedNumberOptionalNumber);
178	animatedType->m_data.numberOptionalNumber = numberOptionalNumber.release();
179	return animatedType;
180	}
181
182	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createPath(std::unique_ptr<SVGPathByteStream> path)
183	{
184	ASSERT(path);
185	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedPath);
186	animatedType->m_data.path = path.release();
187	return animatedType;
188	}
189
190	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createPointList(std::unique_ptr<SVGPointListValues> pointList)
191	{
192	ASSERT(pointList);
193	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedPoints);
194	animatedType->m_data.pointList = pointList.release();
195	return animatedType;
196	}
197
198	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createPreserveAspectRatio(std::unique_ptr<SVGPreserveAspectRatioValue> preserveAspectRatio)
199	{
200	ASSERT(preserveAspectRatio);
201	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedPreserveAspectRatio);
202	animatedType->m_data.preserveAspectRatio = preserveAspectRatio.release();
203	return animatedType;
204	}
205
206	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createRect(std::unique_ptr<FloatRect> rect)
207	{
208	ASSERT(rect);
209	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedRect);
210	animatedType->m_data.rect = rect.release();
211	return animatedType;
212	}
213
214	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createString(std::unique_ptr<String> string)
215	{
216	ASSERT(string);
217	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedString);
218	animatedType->m_data.string = string.release();
219	return animatedType;
220	}
221
222	std::unique_ptr<SVGAnimatedType> SVGAnimatedType::createTransformList(std::unique_ptr<SVGTransformListValues> transformList)
223	{
224	ASSERT(transformList);
225	auto animatedType = std::make_unique<SVGAnimatedType>(AnimatedTransformList);
226	animatedType->m_data.transformList = transformList.release();
227	return animatedType;
228	}
229
230	String SVGAnimatedType::valueAsString()
231	{
232	switch (m_type) {
233	case AnimatedColor:
234	ASSERT(m_data.color);
235	return m_data.color->serialized();
236	case AnimatedLength:
237	ASSERT(m_data.length);
238	return m_data.length->valueAsString();
239	case AnimatedLengthList:
240	ASSERT(m_data.lengthList);
241	return m_data.lengthList->valueAsString();
242	case AnimatedNumber:
243	ASSERT(m_data.number);
244	return String::number(*m_data.number);
245	case AnimatedRect:
246	ASSERT(m_data.rect);
247	return String::number(m_data.rect->x()) + ' ' + String::number(m_data.rect->y()) + ' '
248	+ String::number(m_data.rect->width()) + ' ' + String::number(m_data.rect->height());
249	case AnimatedString:
250	ASSERT(m_data.string);
251	return *m_data.string;
252
253	// These types don't appear in the table in SVGElement::cssPropertyToTypeMap() and thus don't need valueAsString() support.
254	case AnimatedAngle:
255	case AnimatedBoolean:
256	case AnimatedEnumeration:
257	case AnimatedInteger:
258	case AnimatedIntegerOptionalInteger:
259	case AnimatedNumberList:
260	case AnimatedNumberOptionalNumber:
261	case AnimatedPath:
262	case AnimatedPoints:
263	case AnimatedPreserveAspectRatio:
264	case AnimatedTransformList:
265	case AnimatedUnknown:
266	// Only SVG DOM animations use these property types - that means valueAsString() is never used for those.
267	ASSERT_NOT_REACHED();
268	break;
269	}
270	ASSERT_NOT_REACHED();
271	return String();
272	}
273
274	bool SVGAnimatedType::setValueAsString(const QualifiedName& attrName, const String& value)
275	{
276	switch (m_type) {
277	case AnimatedColor:
278	ASSERT(m_data.color);
279	*m_data.color = CSSParser::parseColor(value.stripWhiteSpace());
280	return true;
281	case AnimatedLength:
282	ASSERT(m_data.length);
283	return !m_data.length->setValueAsString(value, SVGLengthValue::lengthModeForAnimatedLengthAttribute(attrName)).hasException();
284	case AnimatedLengthList:
285	ASSERT(m_data.lengthList);
286	m_data.lengthList->parse(value, SVGLengthValue::lengthModeForAnimatedLengthAttribute(attrName));
287	return true;
288	case AnimatedNumber:
289	ASSERT(m_data.number);
290	parseNumberFromString(value, *m_data.number);
291	return true;
292	case AnimatedRect:
293	ASSERT(m_data.rect);
294	parseRect(value, *m_data.rect);
295	return true;
296	case AnimatedString:
297	ASSERT(m_data.string);
298	*m_data.string = value;
299	return true;
300
301	// These types don't appear in the table in SVGElement::cssPropertyToTypeMap() and thus don't need setValueAsString() support.
302	case AnimatedAngle:
303	case AnimatedBoolean:
304	case AnimatedEnumeration:
305	case AnimatedInteger:
306	case AnimatedIntegerOptionalInteger:
307	case AnimatedNumberList:
308	case AnimatedNumberOptionalNumber:
309	case AnimatedPath:
310	case AnimatedPoints:
311	case AnimatedPreserveAspectRatio:
312	case AnimatedTransformList:
313	case AnimatedUnknown:
314	// Only SVG DOM animations use these property types - that means setValueAsString() is never used for those.
315	ASSERT_NOT_REACHED();
316	break;
317	}
318	return true;
319	}
320
321	bool SVGAnimatedType::supportsAnimVal(AnimatedPropertyType type)
322	{
323	// AnimatedColor is only used for CSS property animations.
324	return type != AnimatedUnknown && type != AnimatedColor;
325	}
326
327	} // namespace WebCore
328	native

Lines 1-5 Source/WebCore/svg/SVGAnimatedType.h_sec1
- Source/WebCore/svg/SVGAnimatedType.h -226 / +72 lines
1	/*	1	/*
2	* Copyright (C) Research In Motion Limited 2011. All rights reserved.	2	* Copyright (C) Research In Motion Limited 2011. All rights reserved.
		3	* Copyright (C) 2018 Apple Inc. All rights reserved.
3	*	4	*
4	* This library is free software; you can redistribute it and/or	5	* This library is free software; you can redistribute it and/or
5	* modify it under the terms of the GNU Library General Public	6	* modify it under the terms of the GNU Library General Public
Lines 19-302 Source/WebCore/svg/SVGAnimatedType.h_sec2
19		20
20	#pragma once	21	#pragma once
21		22
22	#include "Color.h"	23	#include "SVGValue.h"
23	#include "FloatRect.h"
24	#include "SVGAngleValue.h"
25	#include "SVGLengthListValues.h"
26	#include "SVGLengthValue.h"
27	#include "SVGNumberListValues.h"
28	#include "SVGPointListValues.h"
29	#include "SVGPreserveAspectRatioValue.h"
30	#include "SVGPropertyInfo.h"
31	#include "SVGTransformListValues.h"
32		24
33	namespace WebCore {	25	namespace WebCore {
34		26
35	class SVGPathByteStream;	27	struct SVGAnimatedType {
36		28	template<typename PropertyType>
37	class SVGAnimatedType {	29	SVGAnimatedType(PropertyType&& property)
38	WTF_MAKE_FAST_ALLOCATED;	30	: values { SVGValue::create(WTFMove(property)) }
39	public:
40	SVGAnimatedType(AnimatedPropertyType);
41	virtual ~SVGAnimatedType();
42
43	static std::unique_ptr<SVGAnimatedType> createAngleAndEnumeration(std::unique_ptr<std::pair<SVGAngleValue, unsigned>>);
44	static std::unique_ptr<SVGAnimatedType> createBoolean(std::unique_ptr<bool>);
45	static std::unique_ptr<SVGAnimatedType> createColor(std::unique_ptr<Color>);
46	static std::unique_ptr<SVGAnimatedType> createEnumeration(std::unique_ptr<unsigned>);
47	static std::unique_ptr<SVGAnimatedType> createInteger(std::unique_ptr<int>);
48	static std::unique_ptr<SVGAnimatedType> createIntegerOptionalInteger(std::unique_ptr<std::pair<int, int>>);
49	static std::unique_ptr<SVGAnimatedType> createLength(std::unique_ptr<SVGLengthValue>);
50	static std::unique_ptr<SVGAnimatedType> createLengthList(std::unique_ptr<SVGLengthListValues>);
51	static std::unique_ptr<SVGAnimatedType> createNumber(std::unique_ptr<float>);
52	static std::unique_ptr<SVGAnimatedType> createNumberList(std::unique_ptr<SVGNumberListValues>);
53	static std::unique_ptr<SVGAnimatedType> createNumberOptionalNumber(std::unique_ptr<std::pair<float, float>>);
54	static std::unique_ptr<SVGAnimatedType> createPath(std::unique_ptr<SVGPathByteStream>);
55	static std::unique_ptr<SVGAnimatedType> createPointList(std::unique_ptr<SVGPointListValues>);
56	static std::unique_ptr<SVGAnimatedType> createPreserveAspectRatio(std::unique_ptr<SVGPreserveAspectRatioValue>);
57	static std::unique_ptr<SVGAnimatedType> createRect(std::unique_ptr<FloatRect>);
58	static std::unique_ptr<SVGAnimatedType> createString(std::unique_ptr<String>);
59	static std::unique_ptr<SVGAnimatedType> createTransformList(std::unique_ptr<SVGTransformListValues>);
60	static bool supportsAnimVal(AnimatedPropertyType);
61
62	AnimatedPropertyType type() const { return m_type; }
63
64	// Non-mutable accessors.
65	const std::pair<SVGAngleValue, unsigned>& angleAndEnumeration() const
66	{
67	ASSERT(m_type == AnimatedAngle);
68	return *m_data.angleAndEnumeration;
69	}
70
71	const bool& boolean() const
72	{
73	ASSERT(m_type == AnimatedBoolean);
74	return *m_data.boolean;
75	}
76
77	const Color& color() const
78	{
79	ASSERT(m_type == AnimatedColor);
80	return *m_data.color;
81	}
82
83	const unsigned& enumeration() const
84	{
85	ASSERT(m_type == AnimatedEnumeration);
86	return *m_data.enumeration;
87	}
88
89	const int& integer() const
90	{
91	ASSERT(m_type == AnimatedInteger);
92	return *m_data.integer;
93	}
94
95	const std::pair<int, int>& integerOptionalInteger() const
96	{
97	ASSERT(m_type == AnimatedIntegerOptionalInteger);
98	return *m_data.integerOptionalInteger;
99	}
100
101	const SVGLengthValue& length() const
102	{
103	ASSERT(m_type == AnimatedLength);
104	return *m_data.length;
105	}
106
107	const SVGLengthListValues& lengthList() const
108	{
109	ASSERT(m_type == AnimatedLengthList);
110	return *m_data.lengthList;
111	}
112
113	const float& number() const
114	{
115	ASSERT(m_type == AnimatedNumber);
116	return *m_data.number;
117	}
118
119	const SVGNumberListValues& numberList() const
120	{	31	{
121	ASSERT(m_type == AnimatedNumberList);
122	return *m_data.numberList;
123	}	32	}
124		33
125	const std::pair<float, float>& numberOptionalNumber() const	34	SVGAnimatedType(RefPtr<SVGValue>&& value)
		35	: values { WTFMove(value) }
126	{	36	{
127	ASSERT(m_type == AnimatedNumberOptionalNumber);
128	return *m_data.numberOptionalNumber;
129	}	37	}
130		38
131	const SVGPathByteStream* path() const	39	template<typename PropertyType1, typename PropertyType2>
		40	SVGAnimatedType(std::pair<PropertyType1, PropertyType2>&& properties)
		41	: values { SVGValue::create(properties.first), SVGValue::create(properties.second) }
132	{	42	{
133	ASSERT(m_type == AnimatedPath);
134	return m_data.path;
135	}	43	}
136		44
137	const SVGPointListValues& pointList() const	45	SVGAnimatedType(RefPtr<SVGValue>&& value1, RefPtr<SVGValue>&& value2)
		46	: values { WTFMove(value1), WTFMove(value2) }
138	{	47	{
139	ASSERT(m_type == AnimatedPoints);
140	return *m_data.pointList;
141	}	48	}
142		49
143	const SVGPreserveAspectRatioValue& preserveAspectRatio() const	50	template<typename PropertyType>
		51	static std::unique_ptr<SVGAnimatedType> create()
144	{	52	{
145	ASSERT(m_type == AnimatedPreserveAspectRatio);	53	return std::make_unique<SVGAnimatedType>(SVGPropertyTraits<PropertyType>::initialValue());
146	return *m_data.preserveAspectRatio;
147	}	54	}
148		55
149	const FloatRect& rect() const	56	template<typename PropertyType>
		57	static std::unique_ptr<SVGAnimatedType> create(PropertyType&& property)
150	{	58	{
151	ASSERT(m_type == AnimatedRect);	59	return std::make_unique<SVGAnimatedType>(WTFMove(property));
152	return *m_data.rect;
153	}	60	}
154		61
155	const String& string() const	62	static std::unique_ptr<SVGAnimatedType> create(RefPtr<SVGValue>&& value)
156	{	63	{
157	ASSERT(m_type == AnimatedString);	64	return std::make_unique<SVGAnimatedType>(WTFMove(value));
158	return *m_data.string;
159	}	65	}
160		66
161	const SVGTransformListValues& transformList() const	67	template<typename PropertyType1, typename PropertyType2>
		68	static std::unique_ptr<SVGAnimatedType> create()
162	{	69	{
163	ASSERT(m_type == AnimatedTransformList);	70	return std::make_unique<SVGAnimatedType>(SVGPropertyTraits<std::pair<PropertyType1, PropertyType2>>::initialValue());
164	return *m_data.transformList;
165	}	71	}
166		72
167	// Mutable accessors.	73	template<typename PropertyType1, typename PropertyType2>
168	std::pair<SVGAngleValue, unsigned>& angleAndEnumeration()	74	static std::unique_ptr<SVGAnimatedType> create(std::pair<PropertyType1, PropertyType2>&& properties)
169	{	75	{
170	ASSERT(m_type == AnimatedAngle);	76	return std::make_unique<SVGAnimatedType>(WTFMove(properties));
171	return *m_data.angleAndEnumeration;
172	}	77	}
173		78
174	bool& boolean()	79	static std::unique_ptr<SVGAnimatedType> create(RefPtr<SVGValue>&& value1, RefPtr<SVGValue>&& value2)
175	{	80	{
176	ASSERT(m_type == AnimatedBoolean);	81	return std::make_unique<SVGAnimatedType>(WTFMove(value1), WTFMove(value2));
177	return *m_data.boolean;
178	}	82	}
179		83
180	Color& color()	84	AnimatedPropertyType type() const
181	{	85	{
182	ASSERT(m_type == AnimatedColor);	86	ASSERT(values[0]);
183	return *m_data.color;	87	AnimatedPropertyType animatedType1 = valueAnimatedType(*values[0]);
184	}	88	AnimatedPropertyType animatedType2 = values[1] ? valueAnimatedType(*values[1]) : AnimatedUnknown;
185
186	unsigned& enumeration()
187	{
188	ASSERT(m_type == AnimatedEnumeration);
189	return *m_data.enumeration;
190	}
191
192	int& integer()
193	{
194	ASSERT(m_type == AnimatedInteger);
195	return *m_data.integer;
196	}
197
198	std::pair<int, int>& integerOptionalInteger()
199	{
200	ASSERT(m_type == AnimatedIntegerOptionalInteger);
201	return *m_data.integerOptionalInteger;
202	}
203
204	SVGLengthValue& length()
205	{
206	ASSERT(m_type == AnimatedLength);
207	return *m_data.length;
208	}
209
210	SVGLengthListValues& lengthList()
211	{
212	ASSERT(m_type == AnimatedLengthList);
213	return *m_data.lengthList;
214	}
215		89
216	float& number()	90	if (animatedType1 == AnimatedAngle) {
217	{	91	ASSERT(animatedType2 == AnimatedEnumeration);
218	ASSERT(m_type == AnimatedNumber);	92	return AnimatedAngle;
219	return *m_data.number;	93	}
220	}
221		94
222	SVGNumberListValues& numberList()	95	if (animatedType1 == AnimatedInteger && animatedType2 == AnimatedInteger)
223	{	96	return AnimatedIntegerOptionalInteger;
224	ASSERT(m_type == AnimatedNumberList);
225	return *m_data.numberList;
226	}
227		97
228	std::pair<float, float>& numberOptionalNumber()	98	if (animatedType1 == AnimatedNumber && animatedType2 == AnimatedNumber)
229	{	99	return AnimatedNumberOptionalNumber;
230	ASSERT(m_type == AnimatedNumberOptionalNumber);
231	return *m_data.numberOptionalNumber;
232	}
233		100
234	SVGPathByteStream* path()	101	ASSERT(animatedType2 == AnimatedUnknown);
235	{	102	return animatedType1;
236	ASSERT(m_type == AnimatedPath);
237	return m_data.path;
238	}	103	}
239		104
240	SVGPointListValues& pointList()	105	String valueAsString() const
241	{	106	{
242	ASSERT(m_type == AnimatedPoints);	107	ASSERT(values[0] && !values[1]);
243	return *m_data.pointList;	108	return values[0]->toString();
244	}	109	}
245		110
246	SVGPreserveAspectRatioValue& preserveAspectRatio()	111	bool setValueAsString(const QualifiedName& attrName, const String& string)
247	{	112	{
248	ASSERT(m_type == AnimatedPreserveAspectRatio);	113	ASSERT(values[0] && !values[1]);
249	return *m_data.preserveAspectRatio;	114	return values[0]->parse(attrName, string);
250	}	115	}
251		116
252	FloatRect& rect()	117	static bool supportsAnimVal(AnimatedPropertyType type)
253	{	118	{
254	ASSERT(m_type == AnimatedRect);	119	// AnimatedColor is only used for CSS property animations.
255	return *m_data.rect;	120	return type != AnimatedUnknown && type != AnimatedColor;
256	}	121	}
257		122
258	String& string()	123	static AnimatedPropertyType valueAnimatedType(const SVGValue& value)
259	{	124	{
260	ASSERT(m_type == AnimatedString);	125	return WTF::visit(WTF::makeVisitor(
261	return *m_data.string;	126	[](const SVGAngleValue&) { return AnimatedAngle; },
		127	[](const bool&) { return AnimatedBoolean; },
		128	[](const Color&) { return AnimatedColor; },
		129	[](const unsigned&) { return AnimatedEnumeration; },
		130	[](const int&) { return AnimatedInteger; },
		131	[](const SVGLengthValue&) { return AnimatedLength; },
		132	[](const SVGLengthListValues&) { return AnimatedLengthList; },
		133	[](const float) { return AnimatedNumber; },
		134	[](const SVGNumberListValues&) { return AnimatedNumberList; },
		135	[](const SVGPathByteStream&) { return AnimatedPath; },
		136	[](const SVGPreserveAspectRatioValue&) { return AnimatedPreserveAspectRatio; },
		137	[](const SVGPointListValues&) { return AnimatedPoints; },
		138	[](const FloatRect&) { return AnimatedRect; },
		139	[](const String&) { return AnimatedString; },
		140	[](const SVGTransformListValues&) { return AnimatedTransformList; },
		141	[](const auto&) { return AnimatedUnknown; }
		142	), static_cast<const SVGValueVariant&>(value));
262	}	143	}
263		144
264	SVGTransformListValues& transformList()	145	RefPtr<SVGValue> values[2];
265	{
266	ASSERT(m_type == AnimatedTransformList);
267	return *m_data.transformList;
268	}
269
270	String valueAsString();
271	bool setValueAsString(const QualifiedName&, const String&);
272
273	private:
274	AnimatedPropertyType m_type;
275
276	union DataUnion {
277	DataUnion()
278	: length(nullptr)
279	{
280	}
281
282	std::pair<SVGAngleValue, unsigned>* angleAndEnumeration;
283	bool* boolean;
284	Color* color;
285	unsigned* enumeration;
286	int* integer;
287	std::pair<int, int>* integerOptionalInteger;
288	SVGLengthValue* length;
289	SVGLengthListValues* lengthList;
290	float* number;
291	SVGNumberListValues* numberList;
292	std::pair<float, float>* numberOptionalNumber;
293	SVGPathByteStream* path;
294	SVGPreserveAspectRatioValue* preserveAspectRatio;
295	SVGPointListValues* pointList;
296	FloatRect* rect;
297	String* string;
298	SVGTransformListValues* transformList;
299	} m_data;
300	};	146	};
301		147
302	} // namespace WebCore	148	} // namespace WebCore

Lines 1-6 Source/WebCore/svg/SVGAnimatedTypeAnimator.h_sec1
- Source/WebCore/svg/SVGAnimatedTypeAnimator.h -43 / +48 lines
1	/*	1	/*
2	* Copyright (C) Research In Motion Limited 2011-2012. All rights reserved.	2	* Copyright (C) Research In Motion Limited 2011-2012. All rights reserved.
3	* Copyright (C) 2013 Samsung Electronics. All rights reserved.	3	* Copyright (C) 2013 Samsung Electronics. All rights reserved.
		4	* Copyright (C) 2018 Apple Inc. All rights reserved.
4	*	5	*
5	* This library is free software; you can redistribute it and/or	6	* This library is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU Library General Public	7	* modify it under the terms of the GNU Library General Public
Lines 63-90 protected: Source/WebCore/svg/SVGAnimatedTypeAnimator.h_sec2
63		64
64	// Helpers for animators that operate on single types, eg. just one SVGAnimatedInteger.	65	// Helpers for animators that operate on single types, eg. just one SVGAnimatedInteger.
65	template<typename AnimValType>	66	template<typename AnimValType>
66	std::unique_ptr<typename AnimValType::ContentType> constructFromBaseValue(const SVGElementAnimatedPropertyList& animatedTypes)	67	std::unique_ptr<SVGAnimatedType> constructFromBaseValue(const SVGElementAnimatedPropertyList& animatedTypes)
67	{	68	{
68	ASSERT(animatedTypes[0].properties.size() == 1);	69	ASSERT(animatedTypes[0].properties.size() == 1);
69	const typename AnimValType::ContentType& animatedType = castAnimatedPropertyToActualType<AnimValType>(animatedTypes[0].properties[0].get())->currentBaseValue();	70	const AnimValType* animatedType = castAnimatedPropertyToActualType<AnimValType>(animatedTypes[0].properties[0].get());
70		71
71	auto copy = std::make_unique<typename AnimValType::ContentType>(animatedType);	72	RefPtr<SVGValue> animatedValue = SVGValue::create(*animatedType->currentBaseValue());
72	executeAction<AnimValType>(StartAnimationAction, animatedTypes, 0, copy.get());	73	executeAction<AnimValType>(StartAnimationAction, animatedTypes, 0, animatedValue);
73	return copy;	74	return SVGAnimatedType::create(WTFMove(animatedValue));
74	}	75	}
75		76
76	template<typename AnimValType>	77	template<typename AnimValType>
77	void resetFromBaseValue(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type, typename AnimValType::ContentType& (SVGAnimatedType::*getter)())	78	void resetFromBaseValue(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
78	{	79	{
79	ASSERT(animatedTypes[0].properties.size() == 1);	80	ASSERT(animatedTypes[0].properties.size() == 1);
80	ASSERT(type.type() == m_type);	81	ASSERT(type.type() == m_type);
81	auto* property = castAnimatedPropertyToActualType<AnimValType>(animatedTypes[0].properties[0].get());	82	AnimValType* animatedType = castAnimatedPropertyToActualType<AnimValType>(animatedTypes[0].properties[0].get());
82	property->synchronizeWrappersIfNeeded();	83	animatedType->synchronizeWrappersIfNeeded();
83		84
84	typename AnimValType::ContentType& animatedTypeValue = (type.*getter)();	85	RefPtr<SVGValue> baseValue = animatedType->currentBaseValue();
85	animatedTypeValue = property->currentBaseValue();	86	RefPtr<SVGValue> animatedValue = type.values[0];
86		87	static_cast<typename AnimValType::ContentType&>(animatedValue) = static_cast<typename AnimValType::ContentType&>(baseValue);
87	executeAction<AnimValType>(StartAnimationAction, animatedTypes, 0, &animatedTypeValue);	88	executeAction<AnimValType>(StartAnimationAction, animatedTypes, 0, animatedValue);
88	}	89	}
89		90
90	template<typename AnimValType>	91	template<typename AnimValType>
Lines 110-143 protected: Source/WebCore/svg/SVGAnimatedTypeAnimator.h_sec3
110		111
111	// Helpers for animators that operate on pair types, eg. a pair of SVGAnimatedIntegers.	112	// Helpers for animators that operate on pair types, eg. a pair of SVGAnimatedIntegers.
112	template<typename AnimValType1, typename AnimValType2>	113	template<typename AnimValType1, typename AnimValType2>
113	std::unique_ptr<std::pair<typename AnimValType1::ContentType, typename AnimValType2::ContentType>> constructFromBaseValues(const SVGElementAnimatedPropertyList& animatedTypes)	114	std::unique_ptr<SVGAnimatedType> constructFromBaseValues(const SVGElementAnimatedPropertyList& animatedTypes)
114	{	115	{
115	ASSERT(animatedTypes[0].properties.size() == 2);	116	ASSERT(animatedTypes[0].properties.size() == 2);
116	const typename AnimValType1::ContentType& firstType = castAnimatedPropertyToActualType<AnimValType1>(animatedTypes[0].properties[0].get())->currentBaseValue();	117	const AnimValType1* firstAnimatedType = castAnimatedPropertyToActualType<AnimValType1>(animatedTypes[0].properties[0].get());
117	const typename AnimValType2::ContentType& secondType = castAnimatedPropertyToActualType<AnimValType2>(animatedTypes[0].properties[1].get())->currentBaseValue();	118	const AnimValType2* secondAnimatedType = castAnimatedPropertyToActualType<AnimValType2>(animatedTypes[0].properties[1].get());
118		119
119	auto copy = std::make_unique<std::pair<typename AnimValType1::ContentType, typename AnimValType2::ContentType>>(firstType, secondType);	120	RefPtr<SVGValue> firstAnimatedValue = SVGValue::create(*firstAnimatedType->currentBaseValue());
120	executeAction<AnimValType1>(StartAnimationAction, animatedTypes, 0, &copy->first);	121	RefPtr<SVGValue> secondAnimatedValue = SVGValue::create(*secondAnimatedType->currentBaseValue());
121	executeAction<AnimValType2>(StartAnimationAction, animatedTypes, 1, &copy->second);	122	executeAction<AnimValType1>(StartAnimationAction, animatedTypes, 0, firstAnimatedValue);
122	return copy;	123	executeAction<AnimValType2>(StartAnimationAction, animatedTypes, 1, secondAnimatedValue);
		124	return SVGAnimatedType::create(WTFMove(firstAnimatedValue), WTFMove(secondAnimatedValue));
123	}	125	}
124		126
125	template<typename AnimValType1, typename AnimValType2>	127	template<typename AnimValType1, typename AnimValType2>
126	void resetFromBaseValues(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type, std::pair<typename AnimValType1::ContentType, typename AnimValType2::ContentType>& (SVGAnimatedType::*getter)())	128	void resetFromBaseValues(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
127	{	129	{
128	ASSERT(animatedTypes[0].properties.size() == 2);	130	ASSERT(animatedTypes[0].properties.size() == 2);
129	ASSERT(type.type() == m_type);	131	ASSERT(type.type() == m_type);
130	auto* firstProperty = castAnimatedPropertyToActualType<AnimValType1>(animatedTypes[0].properties[0].get());	132	AnimValType1* firstAnimatedType = castAnimatedPropertyToActualType<AnimValType1>(animatedTypes[0].properties[0].get());
131	auto* secondProperty = castAnimatedPropertyToActualType<AnimValType2>(animatedTypes[0].properties[1].get());	133	AnimValType2* secondAnimatedType = castAnimatedPropertyToActualType<AnimValType2>(animatedTypes[0].properties[1].get());
132	firstProperty->synchronizeWrappersIfNeeded();	134	firstAnimatedType->synchronizeWrappersIfNeeded();
133	secondProperty->synchronizeWrappersIfNeeded();	135	secondAnimatedType->synchronizeWrappersIfNeeded();
134		136
135	std::pair<typename AnimValType1::ContentType, typename AnimValType2::ContentType>& animatedTypeValue = (type.*getter)();	137	RefPtr<SVGValue> firstBaseValue = firstAnimatedType->currentBaseValue();
136	animatedTypeValue.first = firstProperty->currentBaseValue();	138	RefPtr<SVGValue> firstAnimatedValue = type.values[0];
137	animatedTypeValue.second = secondProperty->currentBaseValue();	139	static_cast<typename AnimValType1::ContentType&>(firstAnimatedValue) = static_cast<typename AnimValType1::ContentType&>(firstBaseValue);
138		140	executeAction<AnimValType1>(StartAnimationAction, animatedTypes, 0, firstAnimatedValue);
139	executeAction<AnimValType1>(StartAnimationAction, animatedTypes, 0, &animatedTypeValue.first);	141
140	executeAction<AnimValType2>(StartAnimationAction, animatedTypes, 1, &animatedTypeValue.second);	142	RefPtr<SVGValue> secondBaseValue = secondAnimatedType->currentBaseValue();
		143	RefPtr<SVGValue> secondAnimatedValue = type.values[1];
		144	static_cast<typename AnimValType2::ContentType&>(secondAnimatedValue) = static_cast<typename AnimValType2::ContentType&>(secondBaseValue);
		145	executeAction<AnimValType2>(StartAnimationAction, animatedTypes, 1, secondAnimatedValue);
141	}	146	}
142		147
143	template<typename AnimValType1, typename AnimValType2>	148	template<typename AnimValType1, typename AnimValType2>
Lines 190-222 private: Source/WebCore/svg/SVGAnimatedTypeAnimator.h_sec4
190	};	195	};
191		196
192	template<typename AnimValType>	197	template<typename AnimValType>
193	void executeAction(AnimationAction action, const SVGElementAnimatedPropertyList& animatedTypes, unsigned whichProperty, typename AnimValType::ContentType* type = 0)	198	void executeAction(AnimationAction action, const SVGElementAnimatedPropertyList& animatedTypes, unsigned whichProperty, RefPtr<SVGValue> animatedValue = nullptr)
194	{	199	{
195	// FIXME: Can't use SVGElement::InstanceUpdateBlocker because of circular header dependency. Would be nice to untangle this.	200	// FIXME: Can't use SVGElement::InstanceUpdateBlocker because of circular header dependency. Would be nice to untangle this.
196	setInstanceUpdatesBlocked(*animatedTypes[0].element, true);	201	setInstanceUpdatesBlocked(*animatedTypes[0].element, true);
197		202
198	for (auto& animatedType : animatedTypes) {	203	for (auto& animatedType : animatedTypes) {
199	ASSERT_WITH_SECURITY_IMPLICATION(whichProperty < animatedType.properties.size());	204	ASSERT_WITH_SECURITY_IMPLICATION(whichProperty < animatedType.properties.size());
200	AnimValType* property = castAnimatedPropertyToActualType<AnimValType>(animatedType.properties[whichProperty].get());	205	AnimValType* animatedProperty = castAnimatedPropertyToActualType<AnimValType>(animatedType.properties[whichProperty].get());
201		206
202	switch (action) {	207	switch (action) {
203	case StartAnimationAction:	208	case StartAnimationAction:
204	ASSERT(type);	209	ASSERT(animatedValue);
205	if (!property->isAnimating())	210	if (!animatedProperty->isAnimating())
206	property->animationStarted(type);	211	animatedProperty->animationStarted(animatedValue);
207	break;	212	break;
208	case StopAnimationAction:	213	case StopAnimationAction:
209	ASSERT(!type);	214	ASSERT(!animatedValue);
210	if (property->isAnimating())	215	if (animatedProperty->isAnimating())
211	property->animationEnded();	216	animatedProperty->animationEnded();
212	break;	217	break;
213	case AnimValWillChangeAction:	218	case AnimValWillChangeAction:
214	ASSERT(!type);	219	ASSERT(!animatedValue);
215	property->animValWillChange();	220	animatedProperty->animValWillChange();
216	break;	221	break;
217	case AnimValDidChangeAction:	222	case AnimValDidChangeAction:
218	ASSERT(!type);	223	ASSERT(!animatedValue);
219	property->animValDidChange();	224	animatedProperty->animValDidChange();
220	break;	225	break;
221	}	226	}
222	}	227	}

Lines 46-53 END_REGISTER_ANIMATED_PROPERTIES Source/WebCore/svg/SVGCursorElement.cpp_sec1
- Source/WebCore/svg/SVGCursorElement.cpp -2 / +2 lines
46		46
47	inline SVGCursorElement::SVGCursorElement(const QualifiedName& tagName, Document& document)	47	inline SVGCursorElement::SVGCursorElement(const QualifiedName& tagName, Document& document)
48	: SVGElement(tagName, document)	48	: SVGElement(tagName, document)
49	, m_x(LengthModeWidth)	49	, m_x(SVGLengthValue(LengthModeWidth))
50	, m_y(LengthModeHeight)	50	, m_y(SVGLengthValue(LengthModeHeight))
51	{	51	{
52	ASSERT(hasTagName(SVGNames::cursorTag));	52	ASSERT(hasTagName(SVGNames::cursorTag));
53	registerAnimatedPropertiesForSVGCursorElement();	53	registerAnimatedPropertiesForSVGCursorElement();

Lines 48-57 END_REGISTER_ANIMATED_PROPERTIES Source/WebCore/svg/SVGEllipseElement.cpp_sec1
- Source/WebCore/svg/SVGEllipseElement.cpp -4 / +4 lines
48		48
49	inline SVGEllipseElement::SVGEllipseElement(const QualifiedName& tagName, Document& document)	49	inline SVGEllipseElement::SVGEllipseElement(const QualifiedName& tagName, Document& document)
50	: SVGGraphicsElement(tagName, document)	50	: SVGGraphicsElement(tagName, document)
51	, m_cx(LengthModeWidth)	51	, m_cx(SVGLengthValue(LengthModeWidth))
52	, m_cy(LengthModeHeight)	52	, m_cy(SVGLengthValue(LengthModeHeight))
53	, m_rx(LengthModeWidth)	53	, m_rx(SVGLengthValue(LengthModeWidth))
54	, m_ry(LengthModeHeight)	54	, m_ry(SVGLengthValue(LengthModeHeight))
55	{	55	{
56	ASSERT(hasTagName(SVGNames::ellipseTag));	56	ASSERT(hasTagName(SVGNames::ellipseTag));
57	registerAnimatedPropertiesForSVGEllipseElement();	57	registerAnimatedPropertiesForSVGEllipseElement();

Lines 83-89 bool SVGFEColorMatrixElement::setFilterE Source/WebCore/svg/SVGFEColorMatrixElement.cpp_sec1
- Source/WebCore/svg/SVGFEColorMatrixElement.cpp -2 / +2 lines
83	if (attrName == SVGNames::typeAttr)	83	if (attrName == SVGNames::typeAttr)
84	return colorMatrix->setType(type());	84	return colorMatrix->setType(type());
85	if (attrName == SVGNames::valuesAttr)	85	if (attrName == SVGNames::valuesAttr)
86	return colorMatrix->setValues(values());	86	return colorMatrix->setValues(values().properties());
87		87
88	ASSERT_NOT_REACHED();	88	ASSERT_NOT_REACHED();
89	return false;	89	return false;
Lines 133-139 RefPtr<FilterEffect> SVGFEColorMatrixEle Source/WebCore/svg/SVGFEColorMatrixElement.cpp_sec2
133	break;	133	break;
134	}	134	}
135	} else {	135	} else {
136	filterValues = values();	136	filterValues = values().properties();
137	unsigned size = filterValues.size();	137	unsigned size = filterValues.size();
138		138
139	if ((filterType == FECOLORMATRIX_TYPE_MATRIX && size != 20)	139	if ((filterType == FECOLORMATRIX_TYPE_MATRIX && size != 20)

Lines 282-293 RefPtr<FilterEffect> SVGFEConvolveMatrix Source/WebCore/svg/SVGFEConvolveMatrixElement.cpp_sec1
- Source/WebCore/svg/SVGFEConvolveMatrixElement.cpp -2 / +2 lines
282	return nullptr;	282	return nullptr;
283	if (!hasAttribute(SVGNames::divisorAttr)) {	283	if (!hasAttribute(SVGNames::divisorAttr)) {
284	for (int i = 0; i < kernelMatrixSize; ++i)	284	for (int i = 0; i < kernelMatrixSize; ++i)
285	divisorValue += kernelMatrix.at(i);	285	divisorValue += kernelMatrix.propertyAt(i);
286	if (!divisorValue)	286	if (!divisorValue)
287	divisorValue = 1;	287	divisorValue = 1;
288	}	288	}
289		289
290	auto effect = FEConvolveMatrix::create(filter, IntSize(orderXValue, orderYValue), divisorValue, bias(), IntPoint(targetXValue, targetYValue), edgeMode(), FloatPoint(kernelUnitLengthXValue, kernelUnitLengthYValue), preserveAlpha(), kernelMatrix);	290	auto effect = FEConvolveMatrix::create(filter, IntSize(orderXValue, orderYValue), divisorValue, bias(), IntPoint(targetXValue, targetYValue), edgeMode(), FloatPoint(kernelUnitLengthXValue, kernelUnitLengthYValue), preserveAlpha(), kernelMatrix.properties());
291	effect->inputEffects().append(input1);	291	effect->inputEffects().append(input1);
292	return WTFMove(effect);	292	return WTFMove(effect);
293	}	293	}

Lines 64-73 inline SVGFilterElement::SVGFilterElemen Source/WebCore/svg/SVGFilterElement.cpp_sec1
- Source/WebCore/svg/SVGFilterElement.cpp -4 / +4 lines
64	: SVGElement(tagName, document)	64	: SVGElement(tagName, document)
65	, m_filterUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)	65	, m_filterUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
66	, m_primitiveUnits(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)	66	, m_primitiveUnits(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
67	, m_x(LengthModeWidth, "-10%")	67	, m_x(SVGLengthValue(LengthModeWidth, "-10%"))
68	, m_y(LengthModeHeight, "-10%")	68	, m_y(SVGLengthValue(LengthModeHeight, "-10%"))
69	, m_width(LengthModeWidth, "120%")	69	, m_width(SVGLengthValue(LengthModeWidth, "120%"))
70	, m_height(LengthModeHeight, "120%")	70	, m_height(SVGLengthValue(LengthModeHeight, "120%"))
71	{	71	{
72	// Spec: If the x/y attribute is not specified, the effect is as if a value of "-10%" were specified.	72	// Spec: If the x/y attribute is not specified, the effect is as if a value of "-10%" were specified.
73	// Spec: If the width/height attribute is not specified, the effect is as if a value of "120%" were specified.	73	// Spec: If the width/height attribute is not specified, the effect is as if a value of "120%" were specified.

Lines 51-60 END_REGISTER_ANIMATED_PROPERTIES Source/WebCore/svg/SVGFilterPrimitiveStandardAttributes.cpp_sec1
- Source/WebCore/svg/SVGFilterPrimitiveStandardAttributes.cpp -4 / +4 lines
51		51
52	SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes(const QualifiedName& tagName, Document& document)	52	SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes(const QualifiedName& tagName, Document& document)
53	: SVGElement(tagName, document)	53	: SVGElement(tagName, document)
54	, m_x(LengthModeWidth, "0%")	54	, m_x(SVGLengthValue(LengthModeWidth, "0%"))
55	, m_y(LengthModeHeight, "0%")	55	, m_y(SVGLengthValue(LengthModeHeight, "0%"))
56	, m_width(LengthModeWidth, "100%")	56	, m_width(SVGLengthValue(LengthModeWidth, "100%"))
57	, m_height(LengthModeHeight, "100%")	57	, m_height(SVGLengthValue(LengthModeHeight, "100%"))
58	{	58	{
59	// Spec: If the x/y attribute is not specified, the effect is as if a value of "0%" were specified.	59	// Spec: If the x/y attribute is not specified, the effect is as if a value of "0%" were specified.
60	// Spec: If the width/height attribute is not specified, the effect is as if a value of "100%" were specified.	60	// Spec: If the width/height attribute is not specified, the effect is as if a value of "100%" were specified.