Changeset 207716 in webkit

Timestamp:

Oct 22, 2016, 1:56:47 PM (9 years ago)

Author:

Darin Adler

Message:

Move SVG from ExceptionCode to Exception
​https://bugs.webkit.org/show_bug.cgi?id=163837

Reviewed by Chris Dumez.

• WebCore.xcodeproj/project.pbxproj: Added SVGGraphicsElement.idl.

• bindings/js/JSSVGLengthCustom.cpp:

(WebCore::JSSVGLength::value): Use toJSNumber.
(WebCore::JSSVGLength::setValue): Use propagateException.
(WebCore::JSSVGLength::convertToSpecifiedUnits): Ditto.

• bindings/scripts/CodeGeneratorJS.pm:

(GenerateImplementation): Properly handle SetterMayThrowException
in the special case for SVG setters.

• rendering/style/SVGRenderStyle.h:

(WebCore::SVGRenderStyle::initialBaselineShiftValue): Removed
ASSERT_NO_EXCEPTION, no longer needed.
(WebCore::SVGRenderStyle::initialKerning): Ditto.

• svg/SVGAltGlyphElement.cpp:

(WebCore::SVGAltGlyphElement::setGlyphRef): Use ExceptionOr.
(WebCore::SVGAltGlyphElement::setFormat): Ditto.
(WebCore::SVGAltGlyphElement::hasValidGlyphElements): Tweaked a bit.

• svg/SVGAltGlyphElement.h: Updated for above changes.
• svg/SVGAltGlyphElement.idl: Use non-legacy exceptions.

• svg/SVGAngle.cpp:

(WebCore::SVGAngle::valueAsString): Removed unneeded String globals.
(WebCore::parseAngleType): Rewrote to be simpler and more direct.
(WebCore::SVGAngle::setValueAsString): Use ExceptionOr.
(WebCore::SVGAngle::newValueSpecifiedUnits): Ditto.
(WebCore::SVGAngle::convertToSpecifiedUnits): Ditto.

• svg/SVGAngle.h: Updated for above changes. Initialized data members

here in the class definite and removed constructor; default now works.

• svg/SVGAngle.idl: Use non-legacy exceptions.

• svg/SVGAnimateElementBase.cpp:

(WebCore::SVGAnimateElementBase::calculateAnimatedValue): Update since
CalcMode is now an enum class.

• svg/SVGAnimateMotionElement.cpp:

(WebCore::SVGAnimateMotionElement::SVGAnimateMotionElement): Ditto.

• svg/SVGAnimateTransformElement.cpp:

(WebCore::SVGAnimateTransformElement::hasValidAttributeType): Update
since AttributeType is now an enum class.

• svg/SVGAnimatedAngle.cpp:

(WebCore::SVGAnimatedAngleAnimator::calculateDistance): Removed
ASSERT_NO_EXCEPTION, no longer needed.

• svg/SVGAnimatedBoolean.idl: Use non-legacy exception.
• svg/SVGAnimatedEnumeration.idl: Ditto.
• svg/SVGAnimatedInteger.idl: Ditto.

• svg/SVGAnimatedLength.cpp:

(WebCore::sharedSVGLength): Deleted.
(WebCore::SVGAnimatedLengthAnimator::addAnimatedTypes): Removed
ASSERT_NO_EXCEPTION, no longer needed.
(WebCore::parseLengthFromString): Ditto. Also rewrote to not use
a shared SVGLength; no benefit to doing that.
(WebCore::SVGAnimatedLengthAnimator::calculateAnimatedValue): Ditto.

• svg/SVGAnimatedLengthList.cpp:

(WebCore::SVGAnimatedLengthListAnimator::addAnimatedTypes): Ditto.
(WebCore::SVGAnimatedLengthListAnimator::calculateAnimatedValue): Ditto.

• svg/SVGAnimatedNumber.idl: Use non-legacy exception.
• svg/SVGAnimatedString.idl: Ditto.

• svg/SVGAnimatedType.cpp:

(WebCore::SVGAnimatedType::setValueAsString): Updated since
setValueAsString now uses ExceptionOr.

• svg/SVGAnimationElement.cpp:

(WebCore::SVGAnimationElement::SVGAnimationElement): Initialized scalars
in the class definition instead of here.
(WebCore::SVGAnimationElement::getSimpleDuration): Removed uneeded ExceptionCode&.
(WebCore::SVGAnimationElement::setCalcMode): Updated since CalcMode is now an enum class.
(WebCore::SVGAnimationElement::setAttributeType): Updated since AttributeType
is now an enum class.
(WebCore::SVGAnimationElement::shouldApplyAnimation): Ditto.
(WebCore::SVGAnimationElement::calculateKeyTimesForCalcModePaced): Ditto.
(WebCore::SVGAnimationElement::calculatePercentForSpline): Ditto.
(WebCore::SVGAnimationElement::calculatePercentFromKeyPoints): Ditto.
(WebCore::SVGAnimationElement::calculatePercentForFromTo): Ditto.
(WebCore::SVGAnimationElement::currentValuesFromKeyPoints): Ditto.
(WebCore::SVGAnimationElement::currentValuesForValuesAnimation): Ditto.
(WebCore::SVGAnimationElement::startedActiveInterval): Ditto.
(WebCore::SVGAnimationElement::updateAnimation): Ditto.
(WebCore::SVGAnimationElement::checkInvalidCSSAttributeType): Ditto.

• svg/SVGAnimationElement.h: Changed CalcMode into an enum class.

Updated for above changes.

• svg/SVGAnimationElement.idl: Removed MayThrowLegacyException from

getSimpleDuration.

• svg/SVGColor.cpp:

(WebCore::SVGColor::SVGColor): Updated to take scalar in the straightforward
manner instead of constt SVGColorType&.
(WebCore::SVGColor::setRGBColor): Use ExceptionOr.
(WebCore::SVGColor::setRGBColorICCColor): Ditto.
(WebCore::SVGColor::setColor): Ditto.

• svg/SVGColor.h: Updated for above changes. Removed unneeded destructor.
• svg/SVGColor.idl: Use non-legacy exceptions.

• svg/SVGGlyphRefElement.cpp:

(WebCore::SVGGlyphRefElement::SVGGlyphRefElement): Initialize data members
in class definition, not here.
(WebCore::parseFloat): Added helper. Used in parseAttribute.
(WebCore::SVGGlyphRefElement::parseAttribute): Updated to use parseFloat helper.
(WebCore::SVGGlyphRefElement::glyphRef): Deleted.
(WebCore::SVGGlyphRefElement::setGlyphRef): Deleted.
(WebCore::SVGGlyphRefElement::setX): Removed unused Exception& argument.
(WebCore::SVGGlyphRefElement::setY): Ditto.
(WebCore::SVGGlyphRefElement::setDx): Ditto.
(WebCore::SVGGlyphRefElement::setDy): Ditto.

• svg/SVGGlyphRefElement.h: Updated for above changes.
• svg/SVGGlyphRefElement.idl: Use Reflect on glyphRef. Removed incorrect

SetterMayThrowLegacyException attributes for x, y, dx, and dy. Longer term
it might be nice to use [Reflect] on these too.

• svg/SVGGraphicsElement.idl: Use non-legacy exception.

• svg/SVGLength.cpp:

(WebCore::parseLengthType): Changed argument type since caller does not
need to know how many characters are consumed.
(WebCore::SVGLength::SVGLength): Removed IGNORE_EXCEPTION and ASSERT_NO_EXCEPTION.
Also removed the copy constructor, letting the compiler generate the default.
(WebCore::SVGLength::setValueAsString): Use ExceptionOr.
(WebCore::SVGLength::construct): Updated since setValueAsString uses ExceptionOr.
(WebCore::SVGLength::value): Ditto.
(WebCore::SVGLength::valueForBindings): Use ExceptionOr. Also renamed to
disambiguate with the version used outside of bindings.
(WebCore::SVGLength::setValue): Use ExceptionOr.
(WebCore::SVGLength::newValueSpecifiedUnits): Ditto.
(WebCore::SVGLength::convertToSpecifiedUnits): Ditto.
(WebCore::SVGLength::fromCSSPrimitiveValue): Updated since newValueSpecifiedUnits
uses ExceptionOr.
(WebCore::SVGLength::lengthModeForAnimatedLengthAttribute): Rewrote map generation
code to be more efficient and not unrolled. Only do one hash table lookup.

• svg/SVGLength.h: Updated for above changes.
• svg/SVGLength.idl: Use non-legacy exceptions.

• svg/SVGLengthContext.cpp:

(WebCore::SVGLengthContext::valueForLength): Update since function
uses ExceptionOr.
(WebCore::SVGLengthContext::convertValueToUserUnits): Use ExceptionOr.
(WebCore::SVGLengthContext::convertValueFromUserUnits): Ditto.
(WebCore::SVGLengthContext::convertValueFromUserUnitsToPercentage): Ditto.
(WebCore::SVGLengthContext::convertValueFromPercentageToUserUnits): Ditto.
(WebCore::SVGLengthContext::convertValueFromUserUnitsToEMS): Ditto.
(WebCore::SVGLengthContext::convertValueFromEMSToUserUnits): Ditto.
(WebCore::SVGLengthContext::convertValueFromUserUnitsToEXS): Ditto.
(WebCore::SVGLengthContext::convertValueFromEXSToUserUnits): Ditto.

• svg/SVGLengthContext.h: Updatedfor above changes.

• svg/SVGLengthList.cpp:

(WebCore::SVGLengthList::parse): Updated since setValueAsString uses
ExceptionOr now.

• svg/SVGLengthList.h: Removed unneeded constructor.
• svg/SVGLengthList.idl: Use non-legacy exceptions.

• svg/SVGLocatable.cpp:

(WebCore::SVGLocatable::getTransformToElement): Use ExceptionOr.

• svg/SVGLocatable.h: Updated for above change.

• svg/SVGMarkerElement.h:

(WebCore::SVGPropertyTraits<SVGMarkerOrientType>::fromString):
Updated since setValueAsString uses ExceptionOr now.

• svg/SVGMatrix.h: Use ExceptionOr.
• svg/SVGMatrix.idl: Use non-legacy exceptions.

• svg/SVGNumberList.h: Removed unneeded constructor.
• svg/SVGNumberList.idl: Use non-legacy exceptions.

• svg/SVGPaint.cpp:

(WebCore::SVGPaint::setPaint): Use ExceptionOr.

• svg/SVGPaint.h: Updated for above chagne.
• svg/SVGPaint.idl: Use non-legacy exception.

• svg/SVGPathSegList.h: Tweaked a bit.
• svg/SVGPathSegList.idl: Use non-legacy exceptions.

• svg/SVGPointList.h: Removed unneeded constructor.
• svg/SVGPointList.idl: Use non-legacy exceptions.

• svg/SVGPreserveAspectRatio.cpp:

(WebCore::SVGPreserveAspectRatio::setAlign): Use ExceptionOr.
(WebCore::SVGPreserveAspectRatio::setMeetOrSlice): Ditto.

• svg/SVGPreserveAspectRatio.h: Updated for above changes.
• svg/SVGPreserveAspectRatio.idl: Use non-legacy exceptions.

• svg/SVGSVGElement.cpp:

(WebCore::SVGSVGElement::currentView): Pass a reference.

• svg/SVGStringList.h: Tweaked a bit.
• svg/SVGStringList.idl: Use non-legacy exceptions.

• svg/SVGStyleElement.cpp:

(WebCore::SVGStyleElement::setType): Removed unneeded ExceptionCode&.
(WebCore::SVGStyleElement::setMedia): Ditto.
(WebCore::SVGStyleElement::setTitle): Deleted.

• svg/SVGStyleElement.h: Updated for above changes, and made the title

function override be private.

• svg/SVGStyleElement.idl: Use Reflect for title. Removed unneeded

SetterMayThrowLegacyException on all attributes.

• svg/SVGTextContentElement.cpp:

(WebCore::SVGTextContentElement::textLengthAnimated): Removed
ASSERT_NO_EXCEPTION, won't work any more.
(WebCore::SVGTextContentElement::getSubStringLength): Use ExceptionOr.
Also remove redundant call to updateLayoutIgnorePendingStylesheets,
called by getNumberOfChars.
(WebCore::SVGTextContentElement::getStartPositionOfChar): Ditto.
(WebCore::SVGTextContentElement::getEndPositionOfChar): Ditto.
(WebCore::SVGTextContentElement::getExtentOfChar): Ditto.
(WebCore::SVGTextContentElement::getRotationOfChar): Ditto.
(WebCore::SVGTextContentElement::selectSubString): Ditto.

• svg/SVGTextContentElement.h: Updated for above changes.
• svg/SVGTextContentElement.idl: Use non-legacy exceptions.

• svg/SVGTransformList.h: Removed unneeded constructor.
• svg/SVGTransformList.idl: Use non-legacy exceptions.

• svg/SVGViewSpec.cpp:

(WebCore::SVGViewSpec::SVGViewSpec): Updated to take a reference.
(WebCore::SVGViewSpec::setZoomAndPan): Use ExceptionOr.
(WebCore::SVGViewSpec::setTransformString): Deleted.
(WebCore::SVGViewSpec::viewBoxString): Use m_viewBox directly.
(WebCore::SVGViewSpec::preserveAspectRatioString): Use
m_preserveAspectRatio directly.
(WebCore::SVGViewSpec::viewTarget): Use is<SVGElement>.
(WebCore::SVGViewSpec::lookupOrCreateViewBoxWrapper): Use
m_contextElement directly.
(WebCore::SVGViewSpec::lookupOrCreatePreserveAspectRatioWrapper):
Ditto.
(WebCore::SVGViewSpec::lookupOrCreateTransformWrapper): Ditto.
(WebCore::SVGViewSpec::parseViewSpec): Set m_viewTargetString directly.

• svg/SVGViewSpec.h: Updated for above changes. Removed unneeded virtual

destructor, unneeded using for ref/deref, unused functions including
setTransformString, setViewTargetString, non-exception setZoomAndPan,
contextElement, viewBoxBaseValue, and preserveAspectRatioBaseValue.

• svg/SVGViewSpec.idl: Use non-legacy exceptions. Also specify

ImplementationLacksVTable.

• svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:

Use ExceptionOr.

• svg/properties/SVGAnimatedStaticPropertyTearOff.h: Ditto.
• svg/properties/SVGListProperty.h: Ditto.
• svg/properties/SVGListPropertyTearOff.h: Ditto.
  • svg/properties/SVGPathSegListPropertyTearOff.cpp:

(WebCore::SVGPathSegListPropertyTearOff::clear): Ditto.
(WebCore::SVGPathSegListPropertyTearOff::getItem): Ditto.
(WebCore::SVGPathSegListPropertyTearOff::replaceItem): Ditto.
(WebCore::SVGPathSegListPropertyTearOff::removeItem): Ditto.

• svg/properties/SVGPathSegListPropertyTearOff.h: Ditto.
• svg/properties/SVGPropertyTearOff.h: Ditto. Also added an overload

of create that knows how to deal with exceptions.

• svg/properties/SVGStaticListPropertyTearOff.h: Ditto.
• svg/properties/SVGTransformListPropertyTearOff.h: Ditto.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• WebCore.xcodeproj/project.pbxproj (modified) (2 diffs)
• bindings/js/JSSVGLengthCustom.cpp (modified) (4 diffs)
• bindings/scripts/CodeGeneratorJS.pm (modified) (1 diff)
• rendering/style/SVGRenderStyle.h (modified) (2 diffs)
• svg/SVGAltGlyphElement.cpp (modified) (4 diffs)
• svg/SVGAltGlyphElement.h (modified) (4 diffs)
• svg/SVGAltGlyphElement.idl (modified) (1 diff)
• svg/SVGAngle.cpp (modified) (7 diffs)
• svg/SVGAngle.h (modified) (3 diffs)
• svg/SVGAngle.idl (modified) (1 diff)
• svg/SVGAnimateElementBase.cpp (modified) (1 diff)
• svg/SVGAnimateMotionElement.cpp (modified) (1 diff)
• svg/SVGAnimateTransformElement.cpp (modified) (1 diff)
• svg/SVGAnimatedAngle.cpp (modified) (1 diff)
• svg/SVGAnimatedBoolean.idl (modified) (1 diff)
• svg/SVGAnimatedEnumeration.idl (modified) (1 diff)
• svg/SVGAnimatedInteger.idl (modified) (1 diff)
• svg/SVGAnimatedLength.cpp (modified) (3 diffs)
• svg/SVGAnimatedLengthList.cpp (modified) (2 diffs)
• svg/SVGAnimatedNumber.idl (modified) (1 diff)
• svg/SVGAnimatedString.idl (modified) (1 diff)
• svg/SVGAnimatedType.cpp (modified) (1 diff)
• svg/SVGAnimationElement.cpp (modified) (18 diffs)
• svg/SVGAnimationElement.h (modified) (11 diffs)
• svg/SVGAnimationElement.idl (modified) (1 diff)
• svg/SVGColor.cpp (modified) (3 diffs)
• svg/SVGColor.h (modified) (5 diffs)
• svg/SVGColor.idl (modified) (1 diff)
• svg/SVGGlyphRefElement.cpp (modified) (4 diffs)
• svg/SVGGlyphRefElement.h (modified) (4 diffs)
• svg/SVGGlyphRefElement.idl (modified) (1 diff)
• svg/SVGGraphicsElement.idl (modified) (1 diff)
• svg/SVGLength.cpp (modified) (12 diffs)
• svg/SVGLength.h (modified) (11 diffs)
• svg/SVGLength.idl (modified) (1 diff)
• svg/SVGLengthContext.cpp (modified) (10 diffs)
• svg/SVGLengthContext.h (modified) (5 diffs)
• svg/SVGLengthList.cpp (modified) (2 diffs)
• svg/SVGLengthList.h (modified) (3 diffs)
• svg/SVGLengthList.idl (modified) (1 diff)
• svg/SVGLocatable.cpp (modified) (2 diffs)
• svg/SVGLocatable.h (modified) (4 diffs)
• svg/SVGMarkerElement.h (modified) (2 diffs)
• svg/SVGMatrix.h (modified) (3 diffs)
• svg/SVGMatrix.idl (modified) (2 diffs)
• svg/SVGNumberList.h (modified) (3 diffs)
• svg/SVGNumberList.idl (modified) (1 diff)
• svg/SVGPaint.cpp (modified) (1 diff)
• svg/SVGPaint.h (modified) (3 diffs)
• svg/SVGPaint.idl (modified) (1 diff)
• svg/SVGPathSegList.h (modified) (4 diffs)
• svg/SVGPathSegList.idl (modified) (1 diff)
• svg/SVGPointList.h (modified) (3 diffs)
• svg/SVGPointList.idl (modified) (1 diff)
• svg/SVGPreserveAspectRatio.cpp (modified) (1 diff)
• svg/SVGPreserveAspectRatio.h (modified) (5 diffs)
• svg/SVGPreserveAspectRatio.idl (modified) (1 diff)
• svg/SVGSVGElement.cpp (modified) (1 diff)
• svg/SVGStringList.h (modified) (2 diffs)
• svg/SVGStringList.idl (modified) (1 diff)
• svg/SVGStyleElement.cpp (modified) (3 diffs)
• svg/SVGStyleElement.h (modified) (4 diffs)
• svg/SVGStyleElement.idl (modified) (1 diff)
• svg/SVGTextContentElement.cpp (modified) (5 diffs)
• svg/SVGTextContentElement.h (modified) (5 diffs)
• svg/SVGTextContentElement.idl (modified) (1 diff)
• svg/SVGTransformList.h (modified) (4 diffs)
• svg/SVGTransformList.idl (modified) (1 diff)
• svg/SVGViewSpec.cpp (modified) (8 diffs)
• svg/SVGViewSpec.h (modified) (7 diffs)
• svg/SVGViewSpec.idl (modified) (1 diff)
• svg/properties/SVGAnimatedEnumerationPropertyTearOff.h (modified) (1 diff)
• svg/properties/SVGAnimatedStaticPropertyTearOff.h (modified) (3 diffs)
• svg/properties/SVGListProperty.h (modified) (19 diffs)
• svg/properties/SVGListPropertyTearOff.h (modified) (3 diffs)
• svg/properties/SVGPathSegListPropertyTearOff.cpp (modified) (2 diffs)
• svg/properties/SVGPathSegListPropertyTearOff.h (modified) (4 diffs)
• svg/properties/SVGPropertyTearOff.h (modified) (3 diffs)
• svg/properties/SVGStaticListPropertyTearOff.h (modified) (5 diffs)
• svg/properties/SVGTransformListPropertyTearOff.h (modified) (5 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2016-10-22  Darin Adler  <darin@apple.com>
+
+        Move SVG from ExceptionCode to Exception
+        https://bugs.webkit.org/show_bug.cgi?id=163837
+
+        Reviewed by Chris Dumez.
+
+        * WebCore.xcodeproj/project.pbxproj: Added SVGGraphicsElement.idl.
+
+        * bindings/js/JSSVGLengthCustom.cpp:
+        (WebCore::JSSVGLength::value): Use toJSNumber.
+        (WebCore::JSSVGLength::setValue): Use propagateException.
+        (WebCore::JSSVGLength::convertToSpecifiedUnits): Ditto.
+
+        * bindings/scripts/CodeGeneratorJS.pm:
+        (GenerateImplementation): Properly handle SetterMayThrowException
+        in the special case for SVG setters.
+
+        * rendering/style/SVGRenderStyle.h:
+        (WebCore::SVGRenderStyle::initialBaselineShiftValue): Removed
+        ASSERT_NO_EXCEPTION, no longer needed.
+        (WebCore::SVGRenderStyle::initialKerning): Ditto.
+
+        * svg/SVGAltGlyphElement.cpp:
+        (WebCore::SVGAltGlyphElement::setGlyphRef): Use ExceptionOr.
+        (WebCore::SVGAltGlyphElement::setFormat): Ditto.
+        (WebCore::SVGAltGlyphElement::hasValidGlyphElements): Tweaked a bit.
+        * svg/SVGAltGlyphElement.h: Updated for above changes.
+        * svg/SVGAltGlyphElement.idl: Use non-legacy exceptions.
+
+        * svg/SVGAngle.cpp:
+        (WebCore::SVGAngle::valueAsString): Removed unneeded String globals.
+        (WebCore::parseAngleType): Rewrote to be simpler and more direct.
+        (WebCore::SVGAngle::setValueAsString): Use ExceptionOr.
+        (WebCore::SVGAngle::newValueSpecifiedUnits): Ditto.
+        (WebCore::SVGAngle::convertToSpecifiedUnits): Ditto.
+        * svg/SVGAngle.h: Updated for above changes. Initialized data members
+        here in the class definite and removed constructor; default now works.
+        * svg/SVGAngle.idl: Use non-legacy exceptions.
+
+        * svg/SVGAnimateElementBase.cpp:
+        (WebCore::SVGAnimateElementBase::calculateAnimatedValue): Update since
+        CalcMode is now an enum class.
+        * svg/SVGAnimateMotionElement.cpp:
+        (WebCore::SVGAnimateMotionElement::SVGAnimateMotionElement): Ditto.
+
+        * svg/SVGAnimateTransformElement.cpp:
+        (WebCore::SVGAnimateTransformElement::hasValidAttributeType): Update
+        since AttributeType is now an enum class.
+
+        * svg/SVGAnimatedAngle.cpp:
+        (WebCore::SVGAnimatedAngleAnimator::calculateDistance): Removed
+        ASSERT_NO_EXCEPTION, no longer needed.
+
+        * svg/SVGAnimatedBoolean.idl: Use non-legacy exception.
+        * svg/SVGAnimatedEnumeration.idl: Ditto.
+        * svg/SVGAnimatedInteger.idl: Ditto.
+
+        * svg/SVGAnimatedLength.cpp:
+        (WebCore::sharedSVGLength): Deleted.
+        (WebCore::SVGAnimatedLengthAnimator::addAnimatedTypes): Removed
+        ASSERT_NO_EXCEPTION, no longer needed.
+        (WebCore::parseLengthFromString): Ditto. Also rewrote to not use
+        a shared SVGLength; no benefit to doing that.
+        (WebCore::SVGAnimatedLengthAnimator::calculateAnimatedValue): Ditto.
+        * svg/SVGAnimatedLengthList.cpp:
+        (WebCore::SVGAnimatedLengthListAnimator::addAnimatedTypes): Ditto.
+        (WebCore::SVGAnimatedLengthListAnimator::calculateAnimatedValue): Ditto.
+
+        * svg/SVGAnimatedNumber.idl: Use non-legacy exception.
+        * svg/SVGAnimatedString.idl: Ditto.
+
+        * svg/SVGAnimatedType.cpp:
+        (WebCore::SVGAnimatedType::setValueAsString): Updated since
+        setValueAsString now uses ExceptionOr.
+
+        * svg/SVGAnimationElement.cpp:
+        (WebCore::SVGAnimationElement::SVGAnimationElement): Initialized scalars
+        in the class definition instead of here.
+        (WebCore::SVGAnimationElement::getSimpleDuration): Removed uneeded ExceptionCode&.
+        (WebCore::SVGAnimationElement::setCalcMode): Updated since CalcMode is now an enum class.
+        (WebCore::SVGAnimationElement::setAttributeType): Updated since AttributeType
+        is now an enum class.
+        (WebCore::SVGAnimationElement::shouldApplyAnimation): Ditto.
+        (WebCore::SVGAnimationElement::calculateKeyTimesForCalcModePaced): Ditto.
+        (WebCore::SVGAnimationElement::calculatePercentForSpline): Ditto.
+        (WebCore::SVGAnimationElement::calculatePercentFromKeyPoints): Ditto.
+        (WebCore::SVGAnimationElement::calculatePercentForFromTo): Ditto.
+        (WebCore::SVGAnimationElement::currentValuesFromKeyPoints): Ditto.
+        (WebCore::SVGAnimationElement::currentValuesForValuesAnimation): Ditto.
+        (WebCore::SVGAnimationElement::startedActiveInterval): Ditto.
+        (WebCore::SVGAnimationElement::updateAnimation): Ditto.
+        (WebCore::SVGAnimationElement::checkInvalidCSSAttributeType): Ditto.
+
+        * svg/SVGAnimationElement.h: Changed CalcMode into an enum class.
+        Updated for above changes.
+
+        * svg/SVGAnimationElement.idl: Removed MayThrowLegacyException from
+        getSimpleDuration.
+
+        * svg/SVGColor.cpp:
+        (WebCore::SVGColor::SVGColor): Updated to take scalar in the straightforward
+        manner instead of constt SVGColorType&.
+        (WebCore::SVGColor::setRGBColor): Use ExceptionOr.
+        (WebCore::SVGColor::setRGBColorICCColor): Ditto.
+        (WebCore::SVGColor::setColor): Ditto.
+        * svg/SVGColor.h: Updated for above changes. Removed unneeded destructor.
+        * svg/SVGColor.idl: Use non-legacy exceptions.
+
+        * svg/SVGGlyphRefElement.cpp:
+        (WebCore::SVGGlyphRefElement::SVGGlyphRefElement): Initialize data members
+        in class definition, not here.
+        (WebCore::parseFloat): Added helper. Used in parseAttribute.
+        (WebCore::SVGGlyphRefElement::parseAttribute): Updated to use parseFloat helper.
+        (WebCore::SVGGlyphRefElement::glyphRef): Deleted.
+        (WebCore::SVGGlyphRefElement::setGlyphRef): Deleted.
+        (WebCore::SVGGlyphRefElement::setX): Removed unused Exception& argument.
+        (WebCore::SVGGlyphRefElement::setY): Ditto.
+        (WebCore::SVGGlyphRefElement::setDx): Ditto.
+        (WebCore::SVGGlyphRefElement::setDy): Ditto.
+        * svg/SVGGlyphRefElement.h: Updated for above changes.
+        * svg/SVGGlyphRefElement.idl: Use Reflect on glyphRef. Removed incorrect
+        SetterMayThrowLegacyException attributes for x, y, dx, and dy. Longer term
+        it might be nice to use [Reflect] on these too.
+
+        * svg/SVGGraphicsElement.idl: Use non-legacy exception.
+
+        * svg/SVGLength.cpp:
+        (WebCore::parseLengthType): Changed argument type since caller does not
+        need to know how many characters are consumed.
+        (WebCore::SVGLength::SVGLength): Removed IGNORE_EXCEPTION and ASSERT_NO_EXCEPTION.
+        Also removed the copy constructor, letting the compiler generate the default.
+        (WebCore::SVGLength::setValueAsString): Use ExceptionOr.
+        (WebCore::SVGLength::construct): Updated since setValueAsString uses ExceptionOr.
+        (WebCore::SVGLength::value): Ditto.
+        (WebCore::SVGLength::valueForBindings): Use ExceptionOr. Also renamed to
+        disambiguate with the version used outside of bindings.
+        (WebCore::SVGLength::setValue): Use ExceptionOr.
+        (WebCore::SVGLength::newValueSpecifiedUnits): Ditto.
+        (WebCore::SVGLength::convertToSpecifiedUnits): Ditto.
+        (WebCore::SVGLength::fromCSSPrimitiveValue): Updated since newValueSpecifiedUnits
+        uses ExceptionOr.
+        (WebCore::SVGLength::lengthModeForAnimatedLengthAttribute): Rewrote map generation
+        code to be more efficient and not unrolled. Only do one hash table lookup.
+        * svg/SVGLength.h: Updated for above changes.
+        * svg/SVGLength.idl: Use non-legacy exceptions.
+
+        * svg/SVGLengthContext.cpp:
+        (WebCore::SVGLengthContext::valueForLength): Update since function
+        uses ExceptionOr.
+        (WebCore::SVGLengthContext::convertValueToUserUnits): Use ExceptionOr.
+        (WebCore::SVGLengthContext::convertValueFromUserUnits): Ditto.
+        (WebCore::SVGLengthContext::convertValueFromUserUnitsToPercentage): Ditto.
+        (WebCore::SVGLengthContext::convertValueFromPercentageToUserUnits): Ditto.
+        (WebCore::SVGLengthContext::convertValueFromUserUnitsToEMS): Ditto.
+        (WebCore::SVGLengthContext::convertValueFromEMSToUserUnits): Ditto.
+        (WebCore::SVGLengthContext::convertValueFromUserUnitsToEXS): Ditto.
+        (WebCore::SVGLengthContext::convertValueFromEXSToUserUnits): Ditto.
+        * svg/SVGLengthContext.h: Updatedfor above changes.
+
+        * svg/SVGLengthList.cpp:
+        (WebCore::SVGLengthList::parse): Updated since setValueAsString uses
+        ExceptionOr now.
+        * svg/SVGLengthList.h: Removed unneeded constructor.
+        * svg/SVGLengthList.idl: Use non-legacy exceptions.
+
+        * svg/SVGLocatable.cpp:
+        (WebCore::SVGLocatable::getTransformToElement): Use ExceptionOr.
+        * svg/SVGLocatable.h: Updated for above change.
+
+        * svg/SVGMarkerElement.h:
+        (WebCore::SVGPropertyTraits<SVGMarkerOrientType>::fromString):
+        Updated since setValueAsString uses ExceptionOr now.
+
+        * svg/SVGMatrix.h: Use ExceptionOr.
+        * svg/SVGMatrix.idl: Use non-legacy exceptions.
+
+        * svg/SVGNumberList.h: Removed unneeded constructor.
+        * svg/SVGNumberList.idl: Use non-legacy exceptions.
+
+        * svg/SVGPaint.cpp:
+        (WebCore::SVGPaint::setPaint): Use ExceptionOr.
+        * svg/SVGPaint.h: Updated for above chagne.
+        * svg/SVGPaint.idl: Use non-legacy exception.
+
+        * svg/SVGPathSegList.h: Tweaked a bit.
+        * svg/SVGPathSegList.idl: Use non-legacy exceptions.
+
+        * svg/SVGPointList.h: Removed unneeded constructor.
+        * svg/SVGPointList.idl: Use non-legacy exceptions.
+
+        * svg/SVGPreserveAspectRatio.cpp:
+        (WebCore::SVGPreserveAspectRatio::setAlign): Use ExceptionOr.
+        (WebCore::SVGPreserveAspectRatio::setMeetOrSlice): Ditto.
+        * svg/SVGPreserveAspectRatio.h: Updated for above changes.
+        * svg/SVGPreserveAspectRatio.idl: Use non-legacy exceptions.
+
+        * svg/SVGSVGElement.cpp:
+        (WebCore::SVGSVGElement::currentView): Pass a reference.
+
+        * svg/SVGStringList.h: Tweaked a bit.
+        * svg/SVGStringList.idl: Use non-legacy exceptions.
+
+        * svg/SVGStyleElement.cpp:
+        (WebCore::SVGStyleElement::setType): Removed unneeded ExceptionCode&.
+        (WebCore::SVGStyleElement::setMedia): Ditto.
+        (WebCore::SVGStyleElement::setTitle): Deleted.
+        * svg/SVGStyleElement.h: Updated for above changes, and made the title
+        function override be private.
+        * svg/SVGStyleElement.idl: Use Reflect for title. Removed unneeded
+        SetterMayThrowLegacyException on all attributes.
+
+        * svg/SVGTextContentElement.cpp:
+        (WebCore::SVGTextContentElement::textLengthAnimated): Removed
+        ASSERT_NO_EXCEPTION, won't work any more.
+        (WebCore::SVGTextContentElement::getSubStringLength): Use ExceptionOr.
+        Also remove redundant call to updateLayoutIgnorePendingStylesheets,
+        called by getNumberOfChars.
+        (WebCore::SVGTextContentElement::getStartPositionOfChar): Ditto.
+        (WebCore::SVGTextContentElement::getEndPositionOfChar): Ditto.
+        (WebCore::SVGTextContentElement::getExtentOfChar): Ditto.
+        (WebCore::SVGTextContentElement::getRotationOfChar): Ditto.
+        (WebCore::SVGTextContentElement::selectSubString): Ditto.
+        * svg/SVGTextContentElement.h: Updated for above changes.
+        * svg/SVGTextContentElement.idl: Use non-legacy exceptions.
+
+        * svg/SVGTransformList.h: Removed unneeded constructor.
+        * svg/SVGTransformList.idl: Use non-legacy exceptions.
+
+        * svg/SVGViewSpec.cpp:
+        (WebCore::SVGViewSpec::SVGViewSpec): Updated to take a reference.
+        (WebCore::SVGViewSpec::setZoomAndPan): Use ExceptionOr.
+        (WebCore::SVGViewSpec::setTransformString): Deleted.
+        (WebCore::SVGViewSpec::viewBoxString): Use m_viewBox directly.
+        (WebCore::SVGViewSpec::preserveAspectRatioString): Use
+        m_preserveAspectRatio directly.
+        (WebCore::SVGViewSpec::viewTarget): Use is<SVGElement>.
+        (WebCore::SVGViewSpec::lookupOrCreateViewBoxWrapper): Use
+        m_contextElement directly.
+        (WebCore::SVGViewSpec::lookupOrCreatePreserveAspectRatioWrapper):
+        Ditto.
+        (WebCore::SVGViewSpec::lookupOrCreateTransformWrapper): Ditto.
+        (WebCore::SVGViewSpec::parseViewSpec): Set m_viewTargetString directly.
+        * svg/SVGViewSpec.h: Updated for above changes. Removed unneeded virtual
+        destructor, unneeded using for ref/deref, unused functions including
+        setTransformString, setViewTargetString, non-exception setZoomAndPan,
+        contextElement, viewBoxBaseValue, and preserveAspectRatioBaseValue.
+        * svg/SVGViewSpec.idl: Use non-legacy exceptions. Also specify
+        ImplementationLacksVTable.
+
+        * svg/properties/SVGAnimatedEnumerationPropertyTearOff.h:
+        Use ExceptionOr.
+        * svg/properties/SVGAnimatedStaticPropertyTearOff.h: Ditto.
+        * svg/properties/SVGListProperty.h: Ditto.
+        * svg/properties/SVGListPropertyTearOff.h: Ditto.
+         * svg/properties/SVGPathSegListPropertyTearOff.cpp:
+        (WebCore::SVGPathSegListPropertyTearOff::clear): Ditto.
+        (WebCore::SVGPathSegListPropertyTearOff::getItem): Ditto.
+        (WebCore::SVGPathSegListPropertyTearOff::replaceItem): Ditto.
+        (WebCore::SVGPathSegListPropertyTearOff::removeItem): Ditto.
+        * svg/properties/SVGPathSegListPropertyTearOff.h: Ditto.
+        * svg/properties/SVGPropertyTearOff.h: Ditto. Also added an overload
+        of create that knows how to deal with exceptions.
+        * svg/properties/SVGStaticListPropertyTearOff.h: Ditto.
+        * svg/properties/SVGTransformListPropertyTearOff.h: Ditto.
+
 2016-10-22  Chris Dumez  <cdumez@apple.com>
 

trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -10614 +10614 @@
                 933A14B70B7D1D5200A53FFD /* JSTextEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSTextEvent.h; sourceTree = "<group>"; };
                 933C7A741C0FBC440034FB97 /* NSSpellCheckerSPI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NSSpellCheckerSPI.h; sourceTree = "<group>"; };
+                934305961DB9FA0E00E712A7 /* SVGGraphicsElement.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = SVGGraphicsElement.idl; sourceTree = "<group>"; };
                 9343CB7F12F25E510033C5EE /* TextCodecUTF8.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TextCodecUTF8.cpp; sourceTree = "<group>"; };
                 9343CB8012F25E510033C5EE /* TextCodecUTF8.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TextCodecUTF8.h; sourceTree = "<group>"; };
@@ -20714 +20715 @@
                                 B222791F0D00BF210071B782 /* SVGGraphicsElement.cpp */,
                                 B22279200D00BF210071B782 /* SVGGraphicsElement.h */,
+                                934305961DB9FA0E00E712A7 /* SVGGraphicsElement.idl */,
                                 650FBF270D9AF046008FC292 /* SVGHKernElement.cpp */,
                                 650FBF280D9AF047008FC292 /* SVGHKernElement.h */,

trunk/Source/WebCore/bindings/js/JSSVGLengthCustom.cpp

@@ -35 +35 @@
 JSValue JSSVGLength::value(ExecState& state) const
 {
-    SVGLength& podImp = wrapped().propertyReference();
-    ExceptionCode ec = 0;
-    SVGLengthContext lengthContext(wrapped().contextElement());
-    float value = podImp.value(lengthContext, ec);
-    if (ec) {
-        setDOMException(&state, ec);
-        return jsUndefined();
-    }
-
-    return jsNumber(value);
+    VM& vm = state.vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    return toJSNumber(state, scope, wrapped().propertyReference().valueForBindings(SVGLengthContext { wrapped().contextElement() }));
 }
 
@@ -62 +55 @@
     }
 
-    SVGLength& podImp = wrapped().propertyReference();
+    auto floatValue = value.toFloat(&state);
+    RETURN_IF_EXCEPTION(scope, void());
 
-    ExceptionCode ec = 0;
-    SVGLengthContext lengthContext(wrapped().contextElement());
-    podImp.setValue(value.toFloat(&state), lengthContext, ec);
-    if (ec) {
-        setDOMException(&state, ec);
+    auto result = wrapped().propertyReference().setValue(floatValue, SVGLengthContext { wrapped().contextElement() });
+    if (result.hasException()) {
+        propagateException(state, scope, result.releaseException());
         return;
     }
@@ -82 +74 @@
     if (wrapped().isReadOnly()) {
         setDOMException(&state, NO_MODIFICATION_ALLOWED_ERR);
-        return jsUndefined();
+        return { };
     }
-
-    SVGLength& podImp = wrapped().propertyReference();
 
     if (state.argumentCount() < 1)
@@ -93 +83 @@
     RETURN_IF_EXCEPTION(scope, JSValue());
 
-    ExceptionCode ec = 0;
-    SVGLengthContext lengthContext(wrapped().contextElement());
-    podImp.convertToSpecifiedUnits(unitType, lengthContext, ec);
-    if (ec) {
-        setDOMException(&state, ec);
-        return jsUndefined();
+    auto result = wrapped().propertyReference().convertToSpecifiedUnits(unitType, SVGLengthContext { wrapped().contextElement() });
+    if (result.hasException()) {
+        propagateException(state, scope, result.releaseException());
+        return { };
     }
 

trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

@@ -3539 +3539 @@
                         push(@implContent, "    podImpl = nativeValue;\n");
                     } else {
-                        push(@implContent, "    podImpl.set$implSetterFunctionName(nativeValue");
-                        push(@implContent, ", ec") if $setterMayThrowLegacyException;
-                        push(@implContent, ");\n");
+                        my $functionString = "podImpl.set$implSetterFunctionName(nativeValue";
+                        $functionString .= ", ec" if $setterMayThrowLegacyException;
+                        $functionString .= ")";
+                        $functionString = "propagateException(state, throwScope, $functionString)" if $attribute->signature->extendedAttributes->{SetterMayThrowException};
+                        push(@implContent, "    $functionString;\n");
                         push(@implContent, "    setDOMException(&state, throwScope, ec);\n") if $setterMayThrowLegacyException;
                     }

trunk/Source/WebCore/rendering/style/SVGRenderStyle.h

@@ -101 +101 @@
     {
         SVGLength length;
-        length.newValueSpecifiedUnits(LengthTypeNumber, 0, ASSERT_NO_EXCEPTION);
+        length.newValueSpecifiedUnits(LengthTypeNumber, 0);
         return length;
     }
@@ -108 +108 @@
     {
         SVGLength length;
-        length.newValueSpecifiedUnits(LengthTypeNumber, 0, ASSERT_NO_EXCEPTION);
+        length.newValueSpecifiedUnits(LengthTypeNumber, 0);
         return length;
     }

trunk/Source/WebCore/svg/SVGAltGlyphElement.cpp

@@ -56 +56 @@
 }
 
-void SVGAltGlyphElement::setGlyphRef(const AtomicString&, ExceptionCode& ec)
+ExceptionOr<void> SVGAltGlyphElement::setGlyphRef(const AtomicString&)
 {
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
@@ -66 +66 @@
 }
 
-void SVGAltGlyphElement::setFormat(const AtomicString&, ExceptionCode& ec)
+ExceptionOr<void> SVGAltGlyphElement::setFormat(const AtomicString&)
 {
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
@@ -78 +78 @@
 bool SVGAltGlyphElement::childShouldCreateRenderer(const Node& child) const
 {
-    if (child.isTextNode())
-        return true;
-    return false;
+    return child.isTextNode();
 }
 
@@ -91 +89 @@
 {
     String target;
-    Element* element = targetElementFromIRIString(getAttribute(XLinkNames::hrefAttr), document(), &target);
-    if (!element)
-        return false;
+    auto* element = targetElementFromIRIString(getAttribute(XLinkNames::hrefAttr), document(), &target);
 
-    if (is<SVGGlyphElement>(*element)) {
+    if (is<SVGGlyphElement>(element)) {
         glyphNames.append(target);
         return true;
     }
 
-    if (is<SVGAltGlyphDefElement>(*element)
-        && downcast<SVGAltGlyphDefElement>(*element).hasValidGlyphElements(glyphNames))
+    if (is<SVGAltGlyphDefElement>(element) && downcast<SVGAltGlyphDefElement>(*element).hasValidGlyphElements(glyphNames))
         return true;
 

trunk/Source/WebCore/svg/SVGAltGlyphElement.h

@@ -20 +20 @@
  */
 
-#ifndef SVGAltGlyphElement_h
-#define SVGAltGlyphElement_h
+#pragma once
 
 #if ENABLE(SVG_FONTS)
@@ -27 +26 @@
 #include "SVGTextPositioningElement.h"
 #include "SVGURIReference.h"
-#include <wtf/Vector.h>
 
 namespace WebCore {
@@ -33 +31 @@
 class SVGGlyphElement;
 
-class SVGAltGlyphElement final : public SVGTextPositioningElement,
-                                 public SVGURIReference {
+class SVGAltGlyphElement final : public SVGTextPositioningElement, public SVGURIReference {
 public:
     static Ref<SVGAltGlyphElement> create(const QualifiedName&, Document&);
 
     const AtomicString& glyphRef() const;
-    void setGlyphRef(const AtomicString&, ExceptionCode&);
+    ExceptionOr<void> setGlyphRef(const AtomicString&);
     const AtomicString& format() const;
-    void setFormat(const AtomicString&, ExceptionCode&);
+    ExceptionOr<void> setFormat(const AtomicString&);
 
     bool hasValidGlyphElements(Vector<String>& glyphNames) const;
@@ -59 +56 @@
 
 #endif
-#endif

trunk/Source/WebCore/svg/SVGAltGlyphElement.idl

@@ -27 +27 @@
     Conditional=SVG_FONTS,
 ] interface SVGAltGlyphElement : SVGTextPositioningElement {
-    [SetterMayThrowLegacyException] attribute DOMString glyphRef;
-    [SetterMayThrowLegacyException] attribute DOMString format;
+    [SetterMayThrowException] attribute DOMString glyphRef;
+    [SetterMayThrowException] attribute DOMString format;
 };
 

trunk/Source/WebCore/svg/SVGAngle.cpp

@@ -26 +26 @@
 #include "SVGParserUtilities.h"
 #include <wtf/MathExtras.h>
-#include <wtf/NeverDestroyed.h>
 #include <wtf/text/StringView.h>
 
 namespace WebCore {
 
-SVGAngle::SVGAngle()
-    : m_unitType(SVG_ANGLETYPE_UNSPECIFIED)
-    , m_valueInSpecifiedUnits(0)
-{
-}
-
 float SVGAngle::value() const
 {
@@ -49 +42 @@
         return m_valueInSpecifiedUnits;
     }
-
     ASSERT_NOT_REACHED();
     return 0;
@@ -59 +51 @@
     case SVG_ANGLETYPE_GRAD:
         m_valueInSpecifiedUnits = deg2grad(value);
-        break;
+        return;
     case SVG_ANGLETYPE_RAD:
         m_valueInSpecifiedUnits = deg2rad(value);
-        break;
+        return;
     case SVG_ANGLETYPE_UNSPECIFIED:
     case SVG_ANGLETYPE_UNKNOWN:
     case SVG_ANGLETYPE_DEG:
         m_valueInSpecifiedUnits = value;
-        break;
-    }
-}
-
-inline SVGAngle::SVGAngleType stringToAngleType(const UChar*& ptr, const UChar* end)
-{
-    // If there's no unit given, the angle type is unspecified.
-    if (ptr == end)
-        return SVGAngle::SVG_ANGLETYPE_UNSPECIFIED;
-
-    const UChar firstChar = *ptr;
-    
-    // If the unit contains only one character, the angle type is unknown.
-    ++ptr;
-    if (ptr == end)
-        return SVGAngle::SVG_ANGLETYPE_UNKNOWN;
-
-    const UChar secondChar = *ptr;
- 
-    // If the unit contains only two characters, the angle type is unknown.
-    ++ptr;
-    if (ptr == end)
-        return SVGAngle::SVG_ANGLETYPE_UNKNOWN;
-
-    const UChar thirdChar = *ptr;
-    if (firstChar == 'd' && secondChar == 'e' && thirdChar == 'g')
-        return SVGAngle::SVG_ANGLETYPE_DEG;
-    if (firstChar == 'r' && secondChar == 'a' && thirdChar == 'd')
-        return SVGAngle::SVG_ANGLETYPE_RAD;
-
-    // If the unit contains three characters, but is not deg or rad, then it's unknown.
-    ++ptr;
-    if (ptr == end)
-        return SVGAngle::SVG_ANGLETYPE_UNKNOWN;
-
-    const UChar fourthChar = *ptr;
-
-    if (firstChar == 'g' && secondChar == 'r' && thirdChar == 'a' && fourthChar == 'd')
-        return SVGAngle::SVG_ANGLETYPE_GRAD;
-
-    return SVGAngle::SVG_ANGLETYPE_UNKNOWN;
+        return;
+    }
+    ASSERT_NOT_REACHED();
 }
 
@@ -113 +67 @@
 {
     switch (m_unitType) {
-    case SVG_ANGLETYPE_DEG: {
-        static NeverDestroyed<String> degString(ASCIILiteral("deg"));
-        return String::number(m_valueInSpecifiedUnits) + degString.get();
-    }
-    case SVG_ANGLETYPE_RAD: {
-        static NeverDestroyed<String> radString(ASCIILiteral("rad"));
-        return String::number(m_valueInSpecifiedUnits) + radString.get();
-    }
-    case SVG_ANGLETYPE_GRAD: {
-        static NeverDestroyed<String> gradString(ASCIILiteral("grad"));
-        return String::number(m_valueInSpecifiedUnits) + gradString.get();
-    }
+    case SVG_ANGLETYPE_DEG:
+        return String::number(m_valueInSpecifiedUnits) + "deg";
+    case SVG_ANGLETYPE_RAD:
+        return String::number(m_valueInSpecifiedUnits) + "rad";
+    case SVG_ANGLETYPE_GRAD:
+        return String::number(m_valueInSpecifiedUnits) + "grad";
     case SVG_ANGLETYPE_UNSPECIFIED:
     case SVG_ANGLETYPE_UNKNOWN:
@@ -134 +82 @@
 }
 
-void SVGAngle::setValueAsString(const String& value, ExceptionCode& ec)
+static inline SVGAngle::SVGAngleType parseAngleType(const UChar* ptr, const UChar* end)
+{
+    switch (end - ptr) {
+    case 0:
+        return SVGAngle::SVG_ANGLETYPE_UNSPECIFIED;
+    case 3:
+        if (ptr[0] == 'd' && ptr[1] == 'e' && ptr[2] == 'g')
+            return SVGAngle::SVG_ANGLETYPE_DEG;
+        if (ptr[0] == 'r' && ptr[1] == 'a' && ptr[2] == 'd')
+            return SVGAngle::SVG_ANGLETYPE_RAD;
+        break;
+    case 4:
+        if (ptr[0] == 'g' && ptr[1] == 'r' && ptr[2] == 'a' && ptr[3] == 'd')
+            return SVGAngle::SVG_ANGLETYPE_GRAD;
+        break;
+    }
+    return SVGAngle::SVG_ANGLETYPE_UNKNOWN;
+}
+
+ExceptionOr<void> SVGAngle::setValueAsString(const String& value)
 {
     if (value.isEmpty()) {
         m_unitType = SVG_ANGLETYPE_UNSPECIFIED;
-        return;
-    }
-
-    float valueInSpecifiedUnits = 0;
+        return { };
+    }
+
     auto upconvertedCharacters = StringView(value).upconvertedCharacters();
     const UChar* ptr = upconvertedCharacters;
     const UChar* end = ptr + value.length();
 
-    if (!parseNumber(ptr, end, valueInSpecifiedUnits, false)) {
-        ec = SYNTAX_ERR;
-        return;
-    }
-
-    SVGAngleType unitType = stringToAngleType(ptr, end);
-    if (unitType == SVG_ANGLETYPE_UNKNOWN) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    float valueInSpecifiedUnits = 0;
+    if (!parseNumber(ptr, end, valueInSpecifiedUnits, false))
+        return Exception { SYNTAX_ERR };
+
+    auto unitType = parseAngleType(ptr, end);
+    if (unitType == SVG_ANGLETYPE_UNKNOWN)
+        return Exception { SYNTAX_ERR };
 
     m_unitType = unitType;
     m_valueInSpecifiedUnits = valueInSpecifiedUnits;
-}
-
-void SVGAngle::newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits, ExceptionCode& ec)
-{
-    if (unitType == SVG_ANGLETYPE_UNKNOWN || unitType > SVG_ANGLETYPE_GRAD) {
-        ec = NOT_SUPPORTED_ERR;
-        return;
-    }
-
-    if (unitType != m_unitType)
-        m_unitType = static_cast<SVGAngleType>(unitType);
-
+    return { };
+}
+
+ExceptionOr<void> SVGAngle::newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits)
+{
+    if (unitType == SVG_ANGLETYPE_UNKNOWN || unitType > SVG_ANGLETYPE_GRAD)
+        return Exception { NOT_SUPPORTED_ERR };
+
+    m_unitType = static_cast<SVGAngleType>(unitType);
     m_valueInSpecifiedUnits = valueInSpecifiedUnits;
-}
-
-void SVGAngle::convertToSpecifiedUnits(unsigned short unitType, ExceptionCode& ec)
-{
-    if (unitType == SVG_ANGLETYPE_UNKNOWN || m_unitType == SVG_ANGLETYPE_UNKNOWN || unitType > SVG_ANGLETYPE_GRAD) {
-        ec = NOT_SUPPORTED_ERR;
-        return;
-    }
+    return { };
+}
+
+ExceptionOr<void> SVGAngle::convertToSpecifiedUnits(unsigned short unitType)
+{
+    if (unitType == SVG_ANGLETYPE_UNKNOWN || m_unitType == SVG_ANGLETYPE_UNKNOWN || unitType > SVG_ANGLETYPE_GRAD)
+        return Exception { NOT_SUPPORTED_ERR };
 
     if (unitType == m_unitType)
-        return;
+        return { };
 
     switch (m_unitType) {
@@ -226 +185 @@
             break;
         case SVG_ANGLETYPE_UNSPECIFIED:
-            break;
         case SVG_ANGLETYPE_DEG:
+            break;
         case SVG_ANGLETYPE_UNKNOWN:
             ASSERT_NOT_REACHED();
@@ -239 +198 @@
 
     m_unitType = static_cast<SVGAngleType>(unitType);
-}
-
-}
+
+    return { };
+}
+
+}

trunk/Source/WebCore/svg/SVGAngle.h

@@ -20 +20 @@
  */
 
-#ifndef SVGAngle_h
-#define SVGAngle_h
+#pragma once
 
+#include "ExceptionOr.h"
 #include "SVGPropertyTraits.h"
 
 namespace WebCore {
 
-typedef int ExceptionCode;
-
 class SVGAngle {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    SVGAngle();
-
     enum SVGAngleType {
         SVG_ANGLETYPE_UNKNOWN = 0,
@@ -50 +46 @@
     float valueInSpecifiedUnits() const { return m_valueInSpecifiedUnits; }
 
-    void setValueAsString(const String&, ExceptionCode&);
+    ExceptionOr<void> setValueAsString(const String&);
     String valueAsString() const;
 
-    void newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits, ExceptionCode&);
-    void convertToSpecifiedUnits(unsigned short unitType, ExceptionCode&);
+    ExceptionOr<void> newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits);
+    ExceptionOr<void> convertToSpecifiedUnits(unsigned short unitType);
 
 private:
-    SVGAngleType m_unitType;
-    float m_valueInSpecifiedUnits;
+    SVGAngleType m_unitType { SVG_ANGLETYPE_UNSPECIFIED };
+    float m_valueInSpecifiedUnits { 0 };
 };
 
-template<>
-struct SVGPropertyTraits<SVGAngle> {
+template<> struct SVGPropertyTraits<SVGAngle> {
     static SVGAngle initialValue() { return SVGAngle(); }
     static String toString(const SVGAngle& type) { return type.valueAsString(); }
@@ -68 +63 @@
 
 } // namespace WebCore
-
-#endif // SVGAngle_h

trunk/Source/WebCore/svg/SVGAngle.idl

@@ -33 +33 @@
     attribute unrestricted float valueInSpecifiedUnits;
 
-    [SetterMayThrowLegacyException] attribute DOMString valueAsString;
+    [SetterMayThrowException] attribute DOMString valueAsString;
 
-    [MayThrowLegacyException] void newValueSpecifiedUnits(unsigned short unitType, unrestricted float valueInSpecifiedUnits);
-
-    [MayThrowLegacyException] void convertToSpecifiedUnits(unsigned short unitType);
+    [MayThrowException] void newValueSpecifiedUnits(unsigned short unitType, unrestricted float valueInSpecifiedUnits);
+    [MayThrowException] void convertToSpecifiedUnits(unsigned short unitType);
 };
-

trunk/Source/WebCore/svg/SVGAnimateElementBase.cpp

@@ -110 +110 @@
         percentage = 1;
 
-    if (calcMode() == CalcModeDiscrete)
+    if (calcMode() == CalcMode::Discrete)
         percentage = percentage < 0.5 ? 0 : 1;
 

trunk/Source/WebCore/svg/SVGAnimateMotionElement.cpp

@@ -47 +47 @@
     , m_hasToPointAtEndOfDuration(false)
 {
-    setCalcMode(CalcModePaced);
+    setCalcMode(CalcMode::Paced);
     ASSERT(hasTagName(animateMotionTag));
 }

trunk/Source/WebCore/svg/SVGAnimateTransformElement.cpp

@@ -47 +47 @@
         return false;
 
-    if (attributeType() == AttributeTypeCSS)
+    if (attributeType() == AttributeType::CSS)
         return false;
 

trunk/Source/WebCore/svg/SVGAnimatedAngle.cpp

@@ -138 +138 @@
 {
     SVGAngle from = SVGAngle();
-    from.setValueAsString(fromString, ASSERT_NO_EXCEPTION);
+    from.setValueAsString(fromString);
     SVGAngle to = SVGAngle();
-    to.setValueAsString(toString, ASSERT_NO_EXCEPTION);
+    to.setValueAsString(toString);
     return fabsf(to.value() - from.value());
 }

trunk/Source/WebCore/svg/SVGAnimatedBoolean.idl

@@ -27 +27 @@
     SkipVTableValidation
 ] interface SVGAnimatedBoolean {
-    [SetterMayThrowLegacyException] attribute boolean baseVal;
+    [SetterMayThrowException] attribute boolean baseVal;
     readonly attribute boolean animVal;
 };

trunk/Source/WebCore/svg/SVGAnimatedEnumeration.idl

@@ -27 +27 @@
     SkipVTableValidation
 ] interface SVGAnimatedEnumeration {
-    [SetterMayThrowLegacyException] attribute unsigned short baseVal;
+    [SetterMayThrowException] attribute unsigned short baseVal;
     readonly attribute unsigned short animVal;
 };

trunk/Source/WebCore/svg/SVGAnimatedInteger.idl

@@ -27 +27 @@
     SkipVTableValidation
 ] interface SVGAnimatedInteger {
-    [SetterMayThrowLegacyException] attribute long baseVal;
+    [SetterMayThrowException] attribute long baseVal;
     readonly attribute long animVal;
 };

trunk/Source/WebCore/svg/SVGAnimatedLength.cpp

@@ -31 +31 @@
     , m_lengthMode(SVGLength::lengthModeForAnimatedLengthAttribute(animationElement->attributeName()))
 {
-}
-
-static inline SVGLength& sharedSVGLength(SVGLengthMode mode, const String& valueAsString)
-{
-    static NeverDestroyed<SVGLength> sharedLength;
-    sharedLength.get().setValueAsString(valueAsString, mode, ASSERT_NO_EXCEPTION);
-    return sharedLength;
 }
 
@@ -79 +72 @@
     SVGLength& toLength = to->length();
 
-    toLength.setValue(toLength.value(lengthContext) + fromLength.value(lengthContext), lengthContext, ASSERT_NO_EXCEPTION);
+    toLength.setValue(toLength.value(lengthContext) + fromLength.value(lengthContext), lengthContext);
 }
 
 static SVGLength parseLengthFromString(SVGAnimationElement* animationElement, const String& string)
 {
-    return sharedSVGLength(SVGLength::lengthModeForAnimatedLengthAttribute(animationElement->attributeName()), string);
+    SVGLength length;
+    length.setValueAsString(string, SVGLength::lengthModeForAnimatedLengthAttribute(animationElement->attributeName()));
+    return length;
 }
 
@@ -106 +101 @@
     m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromSVGLength.value(lengthContext), toSVGLength.value(lengthContext), toAtEndOfDurationSVGLength.value(lengthContext), animatedNumber);
 
-    animatedSVGLength.setValue(lengthContext, animatedNumber, m_lengthMode, unitType, ASSERT_NO_EXCEPTION);
+    animatedSVGLength.setValue(lengthContext, animatedNumber, m_lengthMode, unitType);
 }
 

trunk/Source/WebCore/svg/SVGAnimatedLengthList.cpp

@@ -78 +78 @@
     SVGLengthContext lengthContext(m_contextElement);
     for (unsigned i = 0; i < fromLengthListSize; ++i)
-        toLengthList[i].setValue(toLengthList[i].value(lengthContext) + fromLengthList[i].value(lengthContext), lengthContext, ASSERT_NO_EXCEPTION);
+        toLengthList[i].setValue(toLengthList[i].value(lengthContext) + fromLengthList[i].value(lengthContext), lengthContext);
 }
 
@@ -122 +122 @@
 
         m_animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom, toLengthList[i].value(lengthContext), effectiveToAtEnd, animatedNumber);
-        animatedLengthList[i].setValue(lengthContext, animatedNumber, m_lengthMode, unitType, ASSERT_NO_EXCEPTION);
+        animatedLengthList[i].setValue(lengthContext, animatedNumber, m_lengthMode, unitType);
     }
 }

trunk/Source/WebCore/svg/SVGAnimatedNumber.idl

@@ -28 +28 @@
     SkipVTableValidation
 ] interface SVGAnimatedNumber {
-    [SetterMayThrowLegacyException] attribute unrestricted float baseVal;
+    [SetterMayThrowException] attribute unrestricted float baseVal;
     readonly attribute unrestricted float animVal;
 };

trunk/Source/WebCore/svg/SVGAnimatedString.idl

@@ -27 +27 @@
     SkipVTableValidation
 ] interface SVGAnimatedString {
-    [SetterMayThrowLegacyException] attribute DOMString baseVal;
+    [SetterMayThrowException] attribute DOMString baseVal;
     readonly attribute DOMString animVal;
 };

trunk/Source/WebCore/svg/SVGAnimatedType.cpp

@@ -277 +277 @@
         ASSERT(m_data.color);
         *m_data.color = SVGColor::colorFromRGBColorString(value);
-        break;
-    case AnimatedLength: {
+        return true;
+    case AnimatedLength:
         ASSERT(m_data.length);
-        ExceptionCode ec = 0;
-        m_data.length->setValueAsString(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName), ec);
-        return !ec;
-    }
+        return !m_data.length->setValueAsString(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName)).hasException();
     case AnimatedLengthList:
         ASSERT(m_data.lengthList);
         m_data.lengthList->parse(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName));
-        break;
+        return true;
     case AnimatedNumber:
         ASSERT(m_data.number);
         parseNumberFromString(value, *m_data.number);
-        break;
+        return true;
     case AnimatedRect:
         ASSERT(m_data.rect);
         parseRect(value, *m_data.rect);
-        break;
+        return true;
     case AnimatedString:
         ASSERT(m_data.string);
         *m_data.string = value;
-        break;
+        return true;
 
     // These types don't appear in the table in SVGElement::cssPropertyToTypeMap() and thus don't need setValueAsString() support. 

trunk/Source/WebCore/svg/SVGAnimationElement.cpp

@@ -54 +54 @@
 SVGAnimationElement::SVGAnimationElement(const QualifiedName& tagName, Document& document)
     : SVGSMILElement(tagName, document)
-    , m_fromPropertyValueType(RegularPropertyValue)
-    , m_toPropertyValueType(RegularPropertyValue)
-    , m_animationValid(false)
-    , m_attributeType(AttributeTypeAuto)
-    , m_hasInvalidCSSAttributeType(false)
-    , m_calcMode(CalcModeLinear)
-    , m_animationMode(NoAnimation)
 {
     registerAnimatedPropertiesForSVGAnimationElement();
@@ -242 +235 @@
 }
 
-float SVGAnimationElement::getSimpleDuration(ExceptionCode&) const
+float SVGAnimationElement::getSimpleDuration() const
 {
     return narrowPrecisionToFloat(simpleDuration().value());
@@ -293 +286 @@
     static NeverDestroyed<const AtomicString> spline("spline", AtomicString::ConstructFromLiteral);
     if (calcMode == discrete)
-        setCalcMode(CalcModeDiscrete);
+        setCalcMode(CalcMode::Discrete);
     else if (calcMode == linear)
-        setCalcMode(CalcModeLinear);
+        setCalcMode(CalcMode::Linear);
     else if (calcMode == paced)
-        setCalcMode(CalcModePaced);
+        setCalcMode(CalcMode::Paced);
     else if (calcMode == spline)
-        setCalcMode(CalcModeSpline);
+        setCalcMode(CalcMode::Spline);
     else
-        setCalcMode(hasTagName(SVGNames::animateMotionTag) ? CalcModePaced : CalcModeLinear);
+        setCalcMode(hasTagName(SVGNames::animateMotionTag) ? CalcMode::Paced : CalcMode::Linear);
 }
 
@@ -309 +302 @@
     static NeverDestroyed<const AtomicString> xml("XML", AtomicString::ConstructFromLiteral);
     if (attributeType == css)
-        m_attributeType = AttributeTypeCSS;
+        m_attributeType = AttributeType::CSS;
     else if (attributeType == xml)
-        m_attributeType = AttributeTypeXML;
+        m_attributeType = AttributeType::XML;
     else
-        m_attributeType = AttributeTypeAuto;
+        m_attributeType = AttributeType::Auto;
     checkInvalidCSSAttributeType(targetElement());
 }
@@ -369 +362 @@
 
     // If attributeType="CSS" and attributeName doesn't point to a CSS property, ignore the animation.
-    if (attributeType() == AttributeTypeCSS)
+    if (attributeType() == AttributeType::CSS)
         return DontApplyAnimation;
 
@@ -377 +370 @@
 void SVGAnimationElement::calculateKeyTimesForCalcModePaced()
 {
-    ASSERT(calcMode() == CalcModePaced);
+    ASSERT(calcMode() == CalcMode::Paced);
     ASSERT(animationMode() == ValuesAnimation);
 
@@ -429 +422 @@
 float SVGAnimationElement::calculatePercentForSpline(float percent, unsigned splineIndex) const
 {
-    ASSERT(calcMode() == CalcModeSpline);
+    ASSERT(calcMode() == CalcMode::Spline);
     ASSERT_WITH_SECURITY_IMPLICATION(splineIndex < m_keySplines.size());
     UnitBezier bezier = m_keySplines[splineIndex];
@@ -441 +434 @@
 {
     ASSERT(!m_keyPoints.isEmpty());
-    ASSERT(calcMode() != CalcModePaced);
+    ASSERT(calcMode() != CalcMode::Paced);
     ASSERT(m_keyTimes.size() > 1);
     ASSERT(m_keyPoints.size() == m_keyTimes.size());
@@ -454 +447 @@
     float toKeyPoint = m_keyPoints[index + 1];
     
-    if (calcMode() == CalcModeDiscrete)
+    if (calcMode() == CalcMode::Discrete)
         return fromKeyPoint;
     
     float keyPointPercent = (percent - fromPercent) / (toPercent - fromPercent);
     
-    if (calcMode() == CalcModeSpline) {
+    if (calcMode() == CalcMode::Spline) {
         ASSERT(m_keySplines.size() == m_keyPoints.size() - 1);
         keyPointPercent = calculatePercentForSpline(keyPointPercent, index);
@@ -468 +461 @@
 float SVGAnimationElement::calculatePercentForFromTo(float percent) const
 {
-    if (calcMode() == CalcModeDiscrete && m_keyTimes.size() == 2)
+    if (calcMode() == CalcMode::Discrete && m_keyTimes.size() == 2)
         return percent > m_keyTimes[1] ? 1 : 0;
 
@@ -478 +471 @@
     ASSERT(!m_keyPoints.isEmpty());
     ASSERT(m_keyPoints.size() == m_keyTimes.size());
-    ASSERT(calcMode() != CalcModePaced);
+    ASSERT(calcMode() != CalcMode::Paced);
     effectivePercent = calculatePercentFromKeyPoints(percent);
     unsigned index = effectivePercent == 1 ? m_values.size() - 2 : static_cast<unsigned>(effectivePercent * (m_values.size() - 1));
@@ -503 +496 @@
         AnimatedPropertyType type = downcast<SVGAnimateElementBase>(*this).determineAnimatedPropertyType(*targetElement());
         if (type == AnimatedBoolean || type == AnimatedEnumeration || type == AnimatedPreserveAspectRatio || type == AnimatedString)
-            calcMode = CalcModeDiscrete;
-    }
-    if (!m_keyPoints.isEmpty() && calcMode != CalcModePaced)
+            calcMode = CalcMode::Discrete;
+    }
+    if (!m_keyPoints.isEmpty() && calcMode != CalcMode::Paced)
         return currentValuesFromKeyPoints(percent, effectivePercent, from, to);
     
@@ -513 +506 @@
 
     unsigned index = calculateKeyTimesIndex(percent);
-    if (calcMode == CalcModeDiscrete) {
+    if (calcMode == CalcMode::Discrete) {
         if (!keyTimesCount) 
             index = static_cast<unsigned>(percent * valuesCount);
@@ -540 +533 @@
     effectivePercent = (percent - fromPercent) / (toPercent - fromPercent);
 
-    if (calcMode == CalcModeSpline) {
+    if (calcMode == CalcMode::Spline) {
         ASSERT(m_keySplines.size() == m_values.size() - 1);
         effectivePercent = calculatePercentForSpline(effectivePercent, index);
@@ -559 +552 @@
     AnimationMode animationMode = this->animationMode();
     CalcMode calcMode = this->calcMode();
-    if (calcMode == CalcModeSpline) {
+    if (calcMode == CalcMode::Spline) {
         unsigned splinesCount = m_keySplines.size();
         if (!splinesCount
@@ -588 +581 @@
     else if (animationMode == ValuesAnimation) {
         m_animationValid = m_values.size() >= 1
-            && (calcMode == CalcModePaced || !hasAttributeWithoutSynchronization(SVGNames::keyTimesAttr) || hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) || (m_values.size() == m_keyTimes.size()))
-            && (calcMode == CalcModeDiscrete || !m_keyTimes.size() || m_keyTimes.last() == 1)
-            && (calcMode != CalcModeSpline || ((m_keySplines.size() && (m_keySplines.size() == m_values.size() - 1)) || m_keySplines.size() == m_keyPoints.size() - 1))
+            && (calcMode == CalcMode::Paced || !hasAttributeWithoutSynchronization(SVGNames::keyTimesAttr) || hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) || (m_values.size() == m_keyTimes.size()))
+            && (calcMode == CalcMode::Discrete || !m_keyTimes.size() || m_keyTimes.last() == 1)
+            && (calcMode != CalcMode::Spline || ((m_keySplines.size() && (m_keySplines.size() == m_values.size() - 1)) || m_keySplines.size() == m_keyPoints.size() - 1))
             && (!hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) || (m_keyTimes.size() > 1 && m_keyTimes.size() == m_keyPoints.size()));
         if (m_animationValid)
             m_animationValid = calculateToAtEndOfDurationValue(m_values.last());
-        if (calcMode == CalcModePaced && m_animationValid)
+        if (calcMode == CalcMode::Paced && m_animationValid)
             calculateKeyTimesForCalcModePaced();
     } else if (animationMode == PathAnimation)
-        m_animationValid = calcMode == CalcModePaced || !hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) || (m_keyTimes.size() > 1 && m_keyTimes.size() == m_keyPoints.size());
+        m_animationValid = calcMode == CalcMode::Paced || !hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) || (m_keyTimes.size() > 1 && m_keyTimes.size() == m_keyPoints.size());
 }
 
@@ -619 +612 @@
             m_lastValuesAnimationTo = to;
         }
-    } else if (!m_keyPoints.isEmpty() && calcMode != CalcModePaced)
+    } else if (!m_keyPoints.isEmpty() && calcMode != CalcMode::Paced)
         effectivePercent = calculatePercentFromKeyPoints(percent);
-    else if (m_keyPoints.isEmpty() && calcMode == CalcModeSpline && m_keyTimes.size() > 1)
+    else if (m_keyPoints.isEmpty() && calcMode == CalcMode::Spline && m_keyTimes.size() > 1)
         effectivePercent = calculatePercentForSpline(percent, calculateKeyTimesIndex(percent));
     else if (animationMode == FromToAnimation || animationMode == ToAnimation)
@@ -690 +683 @@
 void SVGAnimationElement::checkInvalidCSSAttributeType(SVGElement* target)
 {
-    m_hasInvalidCSSAttributeType = target && hasValidAttributeName() && attributeType() == AttributeTypeCSS && !isTargetAttributeCSSProperty(target, attributeName());
-}
-
-}
+    m_hasInvalidCSSAttributeType = target && hasValidAttributeName() && attributeType() == AttributeType::CSS && !isTargetAttributeCSSProperty(target, attributeName());
+}
+
+}

trunk/Source/WebCore/svg/SVGAnimationElement.h

@@ -23 +23 @@
  */
 
-#ifndef SVGAnimationElement_h
-#define SVGAnimationElement_h
+#pragma once
 
 #include "SMILTime.h"
@@ -34 +33 @@
 
 namespace WebCore {
+
+class ConditionEventListener;
+class SVGAnimatedType;
+class TimeContainer;
 
 enum AnimationMode {
@@ -47 +50 @@
 // If we have 'currentColor' or 'inherit' as animation value, we need to grab
 // the value during the animation since the value can be animated itself.
-enum AnimatedPropertyValueType {
-    RegularPropertyValue,
-    CurrentColorValue,
-    InheritValue
-};
-
-enum CalcMode {
-    CalcModeDiscrete,
-    CalcModeLinear,
-    CalcModePaced,
-    CalcModeSpline
-};
-
-class ConditionEventListener;
-class TimeContainer;
-class SVGAnimatedType;
-
-class SVGAnimationElement : public SVGSMILElement,
-                            public SVGTests,
-                            public SVGExternalResourcesRequired {
+enum AnimatedPropertyValueType { RegularPropertyValue, CurrentColorValue, InheritValue };
+
+enum class CalcMode { Discrete, Linear, Paced, Spline };
+
+class SVGAnimationElement : public SVGSMILElement, public SVGTests, public SVGExternalResourcesRequired {
 public:
-    // SVGAnimationElement
     float getStartTime() const;
     float getCurrentTime() const;
-    float getSimpleDuration(ExceptionCode&) const;
+    float getSimpleDuration() const;
 
     void beginElement();
@@ -97 +84 @@
     AnimatedPropertyValueType toPropertyValueType() const { return m_toPropertyValueType; }
 
-    template<typename AnimatedType>
-    void adjustForInheritance(AnimatedType (*parseTypeFromString)(SVGAnimationElement*, const String&),
-                              AnimatedPropertyValueType valueType, AnimatedType& animatedType, SVGElement* contextElement)
+    template<typename AnimatedType> void adjustForInheritance(AnimatedType (*parseTypeFromString)(SVGAnimationElement*, const String&), AnimatedPropertyValueType valueType, AnimatedType& animatedType, SVGElement* contextElement)
     {
         if (valueType != InheritValue)
@@ -110 +95 @@
     }
 
-    template<typename AnimatedType>
-    bool adjustFromToListValues(const AnimatedType& fromList, const AnimatedType& toList, AnimatedType& animatedList, float percentage, bool resizeAnimatedListIfNeeded = true)
+    template<typename AnimatedType> bool adjustFromToListValues(const AnimatedType& fromList, const AnimatedType& toList, AnimatedType& animatedList, float percentage, bool resizeAnimatedListIfNeeded = true)
     {
         // If no 'to' value is given, nothing to animate.
@@ -137 +121 @@
     }
 
-    template<typename AnimatedType>
-    void animateDiscreteType(float percentage, const AnimatedType& fromType, const AnimatedType& toType, AnimatedType& animatedType)
+    template<typename AnimatedType> void animateDiscreteType(float percentage, const AnimatedType& fromType, const AnimatedType& toType, AnimatedType& animatedType)
     {
         if ((animationMode() == FromToAnimation && percentage > 0.5) || animationMode() == ToAnimation || percentage == 1) {
@@ -150 +133 @@
     {
         float number;
-        if (calcMode() == CalcModeDiscrete)
+        if (calcMode() == CalcMode::Discrete)
             number = percentage < 0.5 ? fromNumber : toNumber;
         else
@@ -175 +158 @@
     void svgAttributeChanged(const QualifiedName&) override;
 
-    enum AttributeType {
-        AttributeTypeCSS,
-        AttributeTypeXML,
-        AttributeTypeAuto
-    };
+    enum class AttributeType { CSS, XML, Auto };
     AttributeType attributeType() const { return m_attributeType; }
 
@@ -192 +171 @@
     void updateAnimation(float percent, unsigned repeat, SVGSMILElement* resultElement) override;
 
-    AnimatedPropertyValueType m_fromPropertyValueType;
-    AnimatedPropertyValueType m_toPropertyValueType;
+    AnimatedPropertyValueType m_fromPropertyValueType { RegularPropertyValue };
+    AnimatedPropertyValueType m_toPropertyValueType { RegularPropertyValue };
 
     void setTargetElement(SVGElement*) override;
@@ -236 +215 @@
     void setCalcMode(const AtomicString&);
 
-    bool m_animationValid;
-
-    AttributeType m_attributeType;
+    bool m_animationValid { false };
+
+    AttributeType m_attributeType { AttributeType::Auto };
     Vector<String> m_values;
     Vector<float> m_keyTimes;
@@ -245 +224 @@
     String m_lastValuesAnimationFrom;
     String m_lastValuesAnimationTo;
-    bool m_hasInvalidCSSAttributeType;
-    CalcMode m_calcMode;
-    AnimationMode m_animationMode;
+    bool m_hasInvalidCSSAttributeType { false };
+    CalcMode m_calcMode { CalcMode::Linear };
+    AnimationMode m_animationMode { NoAnimation };
 };
 
 } // namespace WebCore
-
-#endif // SVGAnimationElement_h

trunk/Source/WebCore/svg/SVGAnimationElement.idl

@@ -30 +30 @@
     unrestricted float getStartTime();
     unrestricted float getCurrentTime();
-    [MayThrowLegacyException] unrestricted float getSimpleDuration();
+    unrestricted float getSimpleDuration();
 
     void beginElement();

trunk/Source/WebCore/svg/SVGColor.cpp

@@ -29 +29 @@
 namespace WebCore {
 
-SVGColor::SVGColor(const SVGColorType& colorType)
+SVGColor::SVGColor(SVGColorType colorType)
     : CSSValue(SVGColorClass)
     , m_colorType(colorType)
@@ -35 +35 @@
 }
 
-SVGColor::SVGColor(ClassType classType, const SVGColorType& colorType)
+SVGColor::SVGColor(ClassType classType, SVGColorType colorType)
     : CSSValue(classType)
     , m_colorType(colorType)
@@ -55 +55 @@
 }
 
-void SVGColor::setRGBColor(const String&, ExceptionCode& ec)
+ExceptionOr<void> SVGColor::setRGBColor(const String&)
 {
     // The whole SVGColor interface is deprecated in SVG 1.1 (2nd edition).
     // Since the setters are the most problematic part, we removed the support for those first.
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
-void SVGColor::setRGBColorICCColor(const String&, const String&, ExceptionCode& ec)
+ExceptionOr<void> SVGColor::setRGBColorICCColor(const String&, const String&)
 {
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
-void SVGColor::setColor(unsigned short, const String&, const String&, ExceptionCode& ec)
+ExceptionOr<void> SVGColor::setColor(unsigned short, const String&, const String&)
 {
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 

trunk/Source/WebCore/svg/SVGColor.h

@@ -20 +20 @@
  */
 
-#ifndef SVGColor_h
-#define SVGColor_h
+#pragma once
 
 #include "CSSValue.h"
@@ -64 +63 @@
     static Color colorFromRGBColorString(const String&);
 
-    void setRGBColor(const String& rgbColor, ExceptionCode&);
-    void setRGBColorICCColor(const String& rgbColor, const String& iccColor, ExceptionCode&);
-    void setColor(unsigned short colorType, const String& rgbColor, const String& iccColor, ExceptionCode&);
+    ExceptionOr<void> setRGBColor(const String&);
+    ExceptionOr<void> setRGBColorICCColor(const String& rgbColor, const String& iccColor);
+    ExceptionOr<void> setColor(unsigned short colorType, const String& rgbColor, const String& iccColor);
 
     String customCSSText() const;
 
-    ~SVGColor() { }
-    
     Ref<SVGColor> cloneForCSSOM() const;
 
@@ -79 +76 @@
     friend class CSSComputedStyleDeclaration;
 
-    SVGColor(ClassType, const SVGColorType&);
+    SVGColor(ClassType, SVGColorType);
     SVGColor(ClassType, const SVGColor& cloneFrom);
 
@@ -86 +83 @@
 
 private:
-    SVGColor(const SVGColorType&);
+    explicit SVGColor(SVGColorType);
 
     Color m_color;
@@ -95 +92 @@
 
 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(SVGColor, isSVGColor())
-
-#endif // SVGColor_h

trunk/Source/WebCore/svg/SVGColor.idl

@@ -32 +32 @@
     // FIXME: readonly attribute SVGICCColor iccColor;
 
-    [MayThrowLegacyException] void setRGBColor(DOMString rgbColor);
-
-    [MayThrowLegacyException] void setRGBColorICCColor(DOMString rgbColor, DOMString iccColor);
-
-    [MayThrowLegacyException] void setColor(unsigned short colorType, DOMString rgbColor, DOMString iccColor);
+    [MayThrowException] void setRGBColor(DOMString rgbColor);
+    [MayThrowException] void setRGBColorICCColor(DOMString rgbColor, DOMString iccColor);
+    [MayThrowException] void setColor(unsigned short colorType, DOMString rgbColor, DOMString iccColor);
 };
-

trunk/Source/WebCore/svg/SVGGlyphRefElement.cpp

@@ -28 +28 @@
 #include "XLinkNames.h"
 #include <wtf/text/AtomicString.h>
-#include <wtf/text/StringView.h>
 
 namespace WebCore {
@@ -42 +41 @@
 inline SVGGlyphRefElement::SVGGlyphRefElement(const QualifiedName& tagName, Document& document)
     : SVGElement(tagName, document)
-    , m_x(0)
-    , m_y(0)
-    , m_dx(0)
-    , m_dy(0)
 {
     ASSERT(hasTagName(SVGNames::glyphRefTag));
@@ -63 +58 @@
 }
 
+static float parseFloat(const AtomicString& value)
+{
+    float result;
+    if (!parseNumberFromString(value, result))
+        return 0;
+    return result;
+}
+
 void SVGGlyphRefElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
-    auto upconvertedCharacters = StringView(value.string()).upconvertedCharacters();
-    const UChar* startPtr = upconvertedCharacters;
-    const UChar* endPtr = startPtr + value.length();
-
-    // FIXME: We need some error handling here.
+    // FIXME: Is the error handling in parseFloat correct for these attributes?
     if (name == SVGNames::xAttr)
-        parseNumber(startPtr, endPtr, m_x);
+        m_x = parseFloat(value);
     else if (name == SVGNames::yAttr)
-        parseNumber(startPtr, endPtr, m_y);
+        m_y = parseFloat(value);
     else if (name == SVGNames::dxAttr)
-        parseNumber(startPtr, endPtr, m_dx);
+        m_dx = parseFloat(value);
     else if (name == SVGNames::dyAttr)
-        parseNumber(startPtr, endPtr, m_dy);
+        m_dy = parseFloat(value);
     else {
         SVGURIReference::parseAttribute(name, value);
@@ -84 +83 @@
 }
 
-const AtomicString& SVGGlyphRefElement::glyphRef() const
+void SVGGlyphRefElement::setX(float x)
 {
-    return attributeWithoutSynchronization(SVGNames::glyphRefAttr);
+    setAttribute(SVGNames::xAttr, AtomicString::number(x));
 }
 
-void SVGGlyphRefElement::setGlyphRef(const AtomicString&, ExceptionCode&)
+void SVGGlyphRefElement::setY(float y)
 {
-    // FIXME: Set and honor attribute change.
-    // https://bugs.webkit.org/show_bug.cgi?id=64787
+    setAttribute(SVGNames::yAttr, AtomicString::number(y));
 }
 
-void SVGGlyphRefElement::setX(float x, ExceptionCode&)
+void SVGGlyphRefElement::setDx(float dx)
 {
-    // FIXME: Honor attribute change.
-    // https://bugs.webkit.org/show_bug.cgi?id=64787
-    m_x = x;
+    setAttribute(SVGNames::dxAttr, AtomicString::number(dx));
 }
 
-void SVGGlyphRefElement::setY(float y , ExceptionCode&)
+void SVGGlyphRefElement::setDy(float dy)
 {
-    // FIXME: Honor attribute change.
-    // https://bugs.webkit.org/show_bug.cgi?id=64787
-    m_y = y;
-}
-
-void SVGGlyphRefElement::setDx(float dx, ExceptionCode&)
-{
-    // FIXME: Honor attribute change.
-    // https://bugs.webkit.org/show_bug.cgi?id=64787
-    m_dx = dx;
-}
-
-void SVGGlyphRefElement::setDy(float dy, ExceptionCode&)
-{
-    // FIXME: Honor attribute change.
-    // https://bugs.webkit.org/show_bug.cgi?id=64787
-    m_dy = dy;
+    setAttribute(SVGNames::dyAttr, AtomicString::number(dy));
 }
 

trunk/Source/WebCore/svg/SVGGlyphRefElement.h

@@ -18 +18 @@
  */
 
-#ifndef SVGGlyphRefElement_h
-#define SVGGlyphRefElement_h
+#pragma once
 
 #if ENABLE(SVG_FONTS)
+
 #include "SVGElement.h"
 #include "SVGURIReference.h"
@@ -27 +27 @@
 namespace WebCore {
 
-class SVGGlyphRefElement final : public SVGElement,
-                                 public SVGURIReference {
+class SVGGlyphRefElement final : public SVGElement, public SVGURIReference {
 public:
     static Ref<SVGGlyphRefElement> create(const QualifiedName&, Document&);
 
     bool hasValidGlyphElement(String& glyphName) const;
-    void parseAttribute(const QualifiedName&, const AtomicString&) final;
 
-    // DOM interface
-    const AtomicString& glyphRef() const;
-    void setGlyphRef(const AtomicString&, ExceptionCode&);
     float x() const { return m_x; }
-    void setX(float, ExceptionCode&);
+    void setX(float);
     float y() const { return m_y; }
-    void setY(float, ExceptionCode&);
+    void setY(float);
     float dx() const { return m_dx; }
-    void setDx(float, ExceptionCode&);
+    void setDx(float);
     float dy() const { return m_dy; }
-    void setDy(float, ExceptionCode&);
+    void setDy(float);
 
 private:
     SVGGlyphRefElement(const QualifiedName&, Document&);
 
+    void parseAttribute(const QualifiedName&, const AtomicString&) final;
     bool rendererIsNeeded(const RenderStyle&) final { return false; }
 
@@ -56 +52 @@
     END_DECLARE_ANIMATED_PROPERTIES
 
-    float m_x;
-    float m_y;
-    float m_dx;
-    float m_dy;
+    float m_x { 0 };
+    float m_y { 0 };
+    float m_dx { 0 };
+    float m_dy { 0 };
 };
 
@@ -65 +61 @@
 
 #endif
-#endif

trunk/Source/WebCore/svg/SVGGlyphRefElement.idl

@@ -21 +21 @@
     Conditional=SVG_FONTS
 ] interface SVGGlyphRefElement : SVGElement {
-    // FIXME: Use [Reflect] after https://bugs.webkit.org/show_bug.cgi?id=64843 is fixed.
-    [SetterMayThrowLegacyException] attribute DOMString glyphRef;
+    [Reflect=glyphRef] attribute DOMString glyphRef;
     [Reflect] attribute DOMString format;
-    [SetterMayThrowLegacyException] attribute unrestricted float x;
-    [SetterMayThrowLegacyException] attribute unrestricted float y;
-    [SetterMayThrowLegacyException] attribute unrestricted float dx;
-    [SetterMayThrowLegacyException] attribute unrestricted float dy;
+    attribute unrestricted float x;
+    attribute unrestricted float y;
+    attribute unrestricted float dx;
+    attribute unrestricted float dy;
 };
 

trunk/Source/WebCore/svg/SVGGraphicsElement.idl

@@ -33 +33 @@
     SVGMatrix getCTM();
     SVGMatrix getScreenCTM();
-    [MayThrowLegacyException] SVGMatrix getTransformToElement(optional SVGElement? element = null);
+    [MayThrowException] SVGMatrix getTransformToElement(optional SVGElement? element = null);
 };
 

trunk/Source/WebCore/svg/SVGLength.cpp

@@ -26 +26 @@
 #include "CSSPrimitiveValue.h"
 #include "ExceptionCode.h"
-#include "ExceptionCodePlaceholder.h"
 #include "FloatConversion.h"
 #include "SVGNames.h"
@@ -86 +85 @@
 }
 
-inline SVGLengthType stringToLengthType(const UChar*& ptr, const UChar* end)
+inline SVGLengthType parseLengthType(const UChar* ptr, const UChar* end)
 {
     if (ptr == end)
@@ -125 +124 @@
     , m_unit(storeUnit(mode, LengthTypeNumber))
 {
-    setValueAsString(valueAsString, IGNORE_EXCEPTION);
+    setValueAsString(valueAsString);
 }
 
@@ -132 +131 @@
     , m_unit(storeUnit(mode, unitType))
 {
-    setValue(value, context, ASSERT_NO_EXCEPTION);
-}
-
-SVGLength::SVGLength(const SVGLength& other)
-    : m_valueInSpecifiedUnits(other.m_valueInSpecifiedUnits)
-    , m_unit(other.m_unit)
-{
-}
-
-void SVGLength::setValueAsString(const String& valueAsString, SVGLengthMode mode, ExceptionCode& ec)
+    setValue(value, context);
+}
+
+ExceptionOr<void> SVGLength::setValueAsString(const String& valueAsString, SVGLengthMode mode)
 {
     m_valueInSpecifiedUnits = 0;
     m_unit = storeUnit(mode, LengthTypeNumber);
-    setValueAsString(valueAsString, ec);
+    return setValueAsString(valueAsString);
 }
 
@@ -161 +154 @@
 SVGLength SVGLength::construct(SVGLengthMode mode, const String& valueAsString, SVGParsingError& parseError, SVGLengthNegativeValuesMode negativeValuesMode)
 {
-    ExceptionCode ec = 0;
     SVGLength length(mode);
 
-    length.setValueAsString(valueAsString, ec);
-
-    if (ec)
+    if (length.setValueAsString(valueAsString).hasException())
         parseError = ParsingAttributeFailedError;
     else if (negativeValuesMode == ForbidNegativeLengths && length.valueInSpecifiedUnits() < 0)
@@ -186 +176 @@
 float SVGLength::value(const SVGLengthContext& context) const
 {
-    return value(context, IGNORE_EXCEPTION);
-}
-
-float SVGLength::value(const SVGLengthContext& context, ExceptionCode& ec) const
-{
-    return context.convertValueToUserUnits(m_valueInSpecifiedUnits, extractMode(m_unit), extractType(m_unit), ec);
-}
-
-void SVGLength::setValue(const SVGLengthContext& context, float value, SVGLengthMode mode, SVGLengthType unitType, ExceptionCode& ec)
-{
+    auto result = valueForBindings(context);
+    if (result.hasException())
+        return 0;
+    return result.releaseReturnValue();
+}
+
+ExceptionOr<float> SVGLength::valueForBindings(const SVGLengthContext& context) const
+{
+    return context.convertValueToUserUnits(m_valueInSpecifiedUnits, extractMode(m_unit), extractType(m_unit));
+}
+
+ExceptionOr<void> SVGLength::setValue(const SVGLengthContext& context, float value, SVGLengthMode mode, SVGLengthType unitType)
+{
+    // FIXME: Seems like a bug that we change the value of m_unit even if setValue throws an exception.
     m_unit = storeUnit(mode, unitType);
-    setValue(value, context, ec);
-}
-
-void SVGLength::setValue(float value, const SVGLengthContext& context, ExceptionCode& ec)
+    return setValue(value, context);
+}
+
+ExceptionOr<void> SVGLength::setValue(float value, const SVGLengthContext& context)
 {
     // 100% = 100.0 instead of 1.0 for historical reasons, this could eventually be changed
@@ -206 +200 @@
         value = value / 100;
 
-    ec = 0;
-    float convertedValue = context.convertValueFromUserUnits(value, extractMode(m_unit), extractType(m_unit), ec);
-    if (!ec)
-        m_valueInSpecifiedUnits = convertedValue;
+    auto convertedValue = context.convertValueFromUserUnits(value, extractMode(m_unit), extractType(m_unit));
+    if (convertedValue.hasException())
+        return convertedValue.releaseException();
+    m_valueInSpecifiedUnits = convertedValue.releaseReturnValue();
+    return { };
 }
 float SVGLength::valueAsPercentage() const
@@ -220 +215 @@
 }
 
-void SVGLength::setValueAsString(const String& string, ExceptionCode& ec)
+ExceptionOr<void> SVGLength::setValueAsString(const String& string)
 {
     if (string.isEmpty())
-        return;
+        return { };
 
     float convertedNumber = 0;
@@ -230 +225 @@
     const UChar* end = ptr + string.length();
 
-    if (!parseNumber(ptr, end, convertedNumber, false)) {
-        ec = SYNTAX_ERR;
-        return;
-    }
-
-    SVGLengthType type = stringToLengthType(ptr, end);
-    ASSERT(ptr <= end);
-    if (type == LengthTypeUnknown) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (!parseNumber(ptr, end, convertedNumber, false))
+        return Exception { SYNTAX_ERR };
+
+    auto type = parseLengthType(ptr, end);
+    if (type == LengthTypeUnknown)
+        return Exception { SYNTAX_ERR };
 
     m_unit = storeUnit(extractMode(m_unit), type);
     m_valueInSpecifiedUnits = convertedNumber;
+    return { };
 }
 
@@ -251 +242 @@
 }
 
-void SVGLength::newValueSpecifiedUnits(unsigned short type, float value, ExceptionCode& ec)
-{
-    if (type == LengthTypeUnknown || type > LengthTypePC) {
-        ec = NOT_SUPPORTED_ERR;
-        return;
-    }
+ExceptionOr<void> SVGLength::newValueSpecifiedUnits(unsigned short type, float value)
+{
+    if (type == LengthTypeUnknown || type > LengthTypePC)
+        return Exception { NOT_SUPPORTED_ERR };
 
     m_unit = storeUnit(extractMode(m_unit), static_cast<SVGLengthType>(type));
     m_valueInSpecifiedUnits = value;
-}
-
-void SVGLength::convertToSpecifiedUnits(unsigned short type, const SVGLengthContext& context, ExceptionCode& ec)
-{
-    if (type == LengthTypeUnknown || type > LengthTypePC) {
-        ec = NOT_SUPPORTED_ERR;
-        return;
+    return { };
+}
+
+ExceptionOr<void> SVGLength::convertToSpecifiedUnits(unsigned short type, const SVGLengthContext& context)
+{
+    if (type == LengthTypeUnknown || type > LengthTypePC)
+        return Exception { NOT_SUPPORTED_ERR };
+
+    auto valueInUserUnits = valueForBindings(context);
+    if (valueInUserUnits.hasException())
+        return valueInUserUnits.releaseException();
+
+    auto originalUnitAndType = m_unit;
+    m_unit = storeUnit(extractMode(m_unit), static_cast<SVGLengthType>(type));
+    auto result = setValue(valueInUserUnits.releaseReturnValue(), context);
+    if (result.hasException()) {
+        m_unit = originalUnitAndType;
+        return result.releaseException();
     }
 
-    float valueInUserUnits = value(context, ec);
-    if (ec)
-        return;
-
-    unsigned int originalUnitAndType = m_unit;    
-    m_unit = storeUnit(extractMode(m_unit), static_cast<SVGLengthType>(type));
-    setValue(valueInUserUnits, context, ec);
-    if (!ec)
-        return;
-
-    // Eventually restore old unit and type
-    m_unit = originalUnitAndType;
+    return { };
 }
 
@@ -326 +315 @@
         return SVGLength();
 
-    ExceptionCode ec = 0;
     SVGLength length;
-    length.newValueSpecifiedUnits(svgType, value.floatValue(), ec);
-    if (ec)    
-        return SVGLength();
-
+    length.newValueSpecifiedUnits(svgType, value.floatValue());
     return length;
 }
@@ -378 +363 @@
 SVGLengthMode SVGLength::lengthModeForAnimatedLengthAttribute(const QualifiedName& attrName)
 {
-    typedef HashMap<QualifiedName, SVGLengthMode> LengthModeForLengthAttributeMap;
-    static NeverDestroyed<LengthModeForLengthAttributeMap> s_lengthModeMap;
+    using Map = HashMap<QualifiedName, SVGLengthMode>;
+    static NeverDestroyed<Map> map = [] {
+        struct Mode {
+            const QualifiedName& name;
+            SVGLengthMode mode;
+        };
+        static const Mode modes[] = {
+            { SVGNames::xAttr, LengthModeWidth },
+            { SVGNames::yAttr, LengthModeHeight },
+            { SVGNames::cxAttr, LengthModeWidth },
+            { SVGNames::cyAttr, LengthModeHeight },
+            { SVGNames::dxAttr, LengthModeWidth },
+            { SVGNames::dyAttr, LengthModeHeight },
+            { SVGNames::fxAttr, LengthModeWidth },
+            { SVGNames::fyAttr, LengthModeHeight },
+            { SVGNames::widthAttr, LengthModeWidth },
+            { SVGNames::heightAttr, LengthModeHeight },
+            { SVGNames::x1Attr, LengthModeWidth },
+            { SVGNames::x2Attr, LengthModeWidth },
+            { SVGNames::y1Attr, LengthModeHeight },
+            { SVGNames::y2Attr, LengthModeHeight },
+            { SVGNames::refXAttr, LengthModeWidth },
+            { SVGNames::refYAttr, LengthModeHeight },
+            { SVGNames::markerWidthAttr, LengthModeWidth },
+            { SVGNames::markerHeightAttr, LengthModeHeight },
+            { SVGNames::textLengthAttr, LengthModeWidth },
+            { SVGNames::startOffsetAttr, LengthModeWidth },
+        };
+        Map map;
+        for (auto& mode : modes)
+            map.add(mode.name, mode.mode);
+        return map;
+    }();
     
-    if (s_lengthModeMap.get().isEmpty()) {
-        s_lengthModeMap.get().set(SVGNames::xAttr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::yAttr, LengthModeHeight);
-        s_lengthModeMap.get().set(SVGNames::cxAttr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::cyAttr, LengthModeHeight);
-        s_lengthModeMap.get().set(SVGNames::dxAttr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::dyAttr, LengthModeHeight);
-        s_lengthModeMap.get().set(SVGNames::fxAttr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::fyAttr, LengthModeHeight);
-        s_lengthModeMap.get().set(SVGNames::rAttr, LengthModeOther);
-        s_lengthModeMap.get().set(SVGNames::widthAttr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::heightAttr, LengthModeHeight);
-        s_lengthModeMap.get().set(SVGNames::x1Attr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::x2Attr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::y1Attr, LengthModeHeight);
-        s_lengthModeMap.get().set(SVGNames::y2Attr, LengthModeHeight);
-        s_lengthModeMap.get().set(SVGNames::refXAttr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::refYAttr, LengthModeHeight);
-        s_lengthModeMap.get().set(SVGNames::markerWidthAttr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::markerHeightAttr, LengthModeHeight);        
-        s_lengthModeMap.get().set(SVGNames::textLengthAttr, LengthModeWidth);
-        s_lengthModeMap.get().set(SVGNames::startOffsetAttr, LengthModeWidth);
-    }
-    
-    if (s_lengthModeMap.get().contains(attrName))
-        return s_lengthModeMap.get().get(attrName);
-    
-    return LengthModeOther;
+    auto result = map.get().find(attrName);
+    if (result == map.get().end())
+        return LengthModeOther;
+    return result->value;
 }
 

trunk/Source/WebCore/svg/SVGLength.h

@@ -19 +19 @@
  */
 
-#ifndef SVGLength_h
-#define SVGLength_h
+#pragma once
 
 #include "AnimationUtilities.h"
@@ -31 +30 @@
 class CSSPrimitiveValue;
 class QualifiedName;
-
-typedef int ExceptionCode;
 
 enum SVGLengthNegativeValuesMode {
@@ -60 +57 @@
     SVGLength(SVGLengthMode = LengthModeOther, const String& valueAsString = String());
     SVGLength(const SVGLengthContext&, float, SVGLengthMode = LengthModeOther, SVGLengthType = LengthTypeNumber);
-    SVGLength(const SVGLength&);
 
     SVGLengthType unitType() const;
@@ -71 +67 @@
 
     float value(const SVGLengthContext&) const;
-    float value(const SVGLengthContext&, ExceptionCode&) const;
-    void setValue(float, const SVGLengthContext&, ExceptionCode&);
-    void setValue(const SVGLengthContext&, float, SVGLengthMode, SVGLengthType, ExceptionCode&);
+    ExceptionOr<float> valueForBindings(const SVGLengthContext&) const;
+    ExceptionOr<void> setValue(float, const SVGLengthContext&);
+    ExceptionOr<void> setValue(const SVGLengthContext&, float, SVGLengthMode, SVGLengthType);
 
     float valueInSpecifiedUnits() const { return m_valueInSpecifiedUnits; }
@@ -81 +77 @@
 
     String valueAsString() const;
-    void setValueAsString(const String&, ExceptionCode&);
-    void setValueAsString(const String&, SVGLengthMode, ExceptionCode&);
+    ExceptionOr<void> setValueAsString(const String&);
+    ExceptionOr<void> setValueAsString(const String&, SVGLengthMode);
     
-    void newValueSpecifiedUnits(unsigned short, float valueInSpecifiedUnits, ExceptionCode&);
-    void convertToSpecifiedUnits(unsigned short, const SVGLengthContext&, ExceptionCode&);
+    ExceptionOr<void> newValueSpecifiedUnits(unsigned short, float valueInSpecifiedUnits);
+    ExceptionOr<void> convertToSpecifiedUnits(unsigned short, const SVGLengthContext&);
 
     // Helper functions
-    inline bool isRelative() const
+    bool isRelative() const
     {
         SVGLengthType type = unitType();
@@ -95 +91 @@
 
     bool isZero() const 
-    { 
+    {
         return !m_valueInSpecifiedUnits;
     }
@@ -116 +112 @@
 
         SVGLength length;
-        ExceptionCode ec = 0;
 
         if (fromType == LengthTypePercentage || toType == LengthTypePercentage) {
             float fromPercent = from.valueAsPercentage() * 100;
             float toPercent = valueAsPercentage() * 100;
-            length.newValueSpecifiedUnits(LengthTypePercentage, WebCore::blend(fromPercent, toPercent, progress), ec);
-            if (ec)
+            auto result = length.newValueSpecifiedUnits(LengthTypePercentage, WebCore::blend(fromPercent, toPercent, progress));
+            if (result.hasException())
                 return SVGLength();
             return length;
@@ -130 +125 @@
             float fromValue = from.valueInSpecifiedUnits();
             float toValue = valueInSpecifiedUnits();
-            if (isZero())
-                length.newValueSpecifiedUnits(fromType, WebCore::blend(fromValue, toValue, progress), ec);
-            else
-                length.newValueSpecifiedUnits(toType, WebCore::blend(fromValue, toValue, progress), ec);
-            if (ec)
-                return SVGLength();
+            if (isZero()) {
+                auto result = length.newValueSpecifiedUnits(fromType, WebCore::blend(fromValue, toValue, progress));
+                if (result.hasException())
+                    return SVGLength();
+            } else {
+                auto result = length.newValueSpecifiedUnits(toType, WebCore::blend(fromValue, toValue, progress));
+                if (result.hasException())
+                    return SVGLength();
+            }
             return length;
         }
@@ -143 +141 @@
 
         SVGLengthContext nonRelativeLengthContext(nullptr);
-        float fromValueInUserUnits = nonRelativeLengthContext.convertValueToUserUnits(from.valueInSpecifiedUnits(), from.unitMode(), fromType, ec);
-        if (ec)
+        auto fromValueInUserUnits = nonRelativeLengthContext.convertValueToUserUnits(from.valueInSpecifiedUnits(), from.unitMode(), fromType);
+        if (fromValueInUserUnits.hasException())
             return SVGLength();
 
-        float fromValue = nonRelativeLengthContext.convertValueFromUserUnits(fromValueInUserUnits, unitMode(), toType, ec);
-        if (ec)
+        auto fromValue = nonRelativeLengthContext.convertValueFromUserUnits(fromValueInUserUnits.releaseReturnValue(), unitMode(), toType);
+        if (fromValue.hasException())
             return SVGLength();
 
         float toValue = valueInSpecifiedUnits();
-        length.newValueSpecifiedUnits(toType, WebCore::blend(fromValue, toValue, progress), ec);
-
-        if (ec)
+        auto result = length.newValueSpecifiedUnits(toType, WebCore::blend(fromValue.releaseReturnValue(), toValue, progress));
+        if (result.hasException())
             return SVGLength();
         return length;
@@ -161 +158 @@
 private:
     float m_valueInSpecifiedUnits;
-    unsigned int m_unit;
+    unsigned m_unit;
 };
 
-template<>
-struct SVGPropertyTraits<SVGLength> {
+template<> struct SVGPropertyTraits<SVGLength> {
     static SVGLength initialValue() { return SVGLength(); }
     static String toString(const SVGLength& type) { return type.valueAsString(); }
@@ -173 +169 @@
 
 } // namespace WebCore
-
-#endif // SVGLength_h

trunk/Source/WebCore/svg/SVGLength.idl

@@ -23 +23 @@
 interface SVGLength { 
     // Length Unit Types
-    const unsigned short SVG_LENGTHTYPE_UNKNOWN    = 0;
-    const unsigned short SVG_LENGTHTYPE_NUMBER     = 1;
+    const unsigned short SVG_LENGTHTYPE_UNKNOWN = 0;
+    const unsigned short SVG_LENGTHTYPE_NUMBER = 1;
     const unsigned short SVG_LENGTHTYPE_PERCENTAGE = 2;
-    const unsigned short SVG_LENGTHTYPE_EMS        = 3;
-    const unsigned short SVG_LENGTHTYPE_EXS        = 4;
-    const unsigned short SVG_LENGTHTYPE_PX         = 5;
-    const unsigned short SVG_LENGTHTYPE_CM         = 6;
-    const unsigned short SVG_LENGTHTYPE_MM         = 7;
-    const unsigned short SVG_LENGTHTYPE_IN         = 8;
-    const unsigned short SVG_LENGTHTYPE_PT         = 9;
-    const unsigned short SVG_LENGTHTYPE_PC         = 10;
+    const unsigned short SVG_LENGTHTYPE_EMS = 3;
+    const unsigned short SVG_LENGTHTYPE_EXS = 4;
+    const unsigned short SVG_LENGTHTYPE_PX = 5;
+    const unsigned short SVG_LENGTHTYPE_CM = 6;
+    const unsigned short SVG_LENGTHTYPE_MM = 7;
+    const unsigned short SVG_LENGTHTYPE_IN = 8;
+    const unsigned short SVG_LENGTHTYPE_PT = 9;
+    const unsigned short SVG_LENGTHTYPE_PC = 10;
 
     readonly attribute unsigned short unitType;
-    [GetterMayThrowLegacyException, SetterMayThrowLegacyException, Custom] attribute unrestricted float value;
+    [Custom, GetterMayThrowException, SetterMayThrowException] attribute unrestricted float value;
 
     attribute unrestricted float valueInSpecifiedUnits;
+    [SetterMayThrowException] attribute DOMString valueAsString;
 
-    [SetterMayThrowLegacyException] attribute DOMString valueAsString;
-
-    [MayThrowLegacyException] void newValueSpecifiedUnits(unsigned short unitType,
-                                                     unrestricted float valueInSpecifiedUnits);
-
-    [Custom, MayThrowLegacyException] void convertToSpecifiedUnits(unsigned short unitType);
+    [MayThrowException] void newValueSpecifiedUnits(unsigned short unitType, unrestricted float valueInSpecifiedUnits);
+    [Custom, MayThrowException] void convertToSpecifiedUnits(unsigned short unitType);
 };
-

trunk/Source/WebCore/svg/SVGLengthContext.cpp

@@ -90 +90 @@
 float SVGLengthContext::valueForLength(const Length& length, SVGLengthMode mode)
 {
-    if (length.isPercent())
-        return convertValueFromPercentageToUserUnits(length.value() / 100, mode, IGNORE_EXCEPTION);
+    if (length.isPercent()) {
+        auto result = convertValueFromPercentageToUserUnits(length.value() / 100, mode);
+        if (result.hasException())
+            return 0;
+        return result.releaseReturnValue();
+    }
     if (length.isAuto() || !length.isSpecified())
         return 0;
@@ -104 +108 @@
         return floatValueForLength(length, viewportSize.height());
     case LengthModeOther:
-        return floatValueForLength(length, sqrtf(viewportSize.diagonalLengthSquared() / 2));
+        return floatValueForLength(length, std::sqrt(viewportSize.diagonalLengthSquared() / 2));
     };
     return 0;
 }
 
-float SVGLengthContext::convertValueToUserUnits(float value, SVGLengthMode mode, SVGLengthType fromUnit, ExceptionCode& ec) const
+ExceptionOr<float> SVGLengthContext::convertValueToUserUnits(float value, SVGLengthMode mode, SVGLengthType fromUnit) const
 {
     // If the SVGLengthContext carries a custom viewport, force resolving against it.
@@ -116 +120 @@
         if (fromUnit == LengthTypePercentage)
             value /= 100;
-        return convertValueFromPercentageToUserUnits(value, mode, ec);
+        return convertValueFromPercentageToUserUnits(value, mode);
     }
 
     switch (fromUnit) {
     case LengthTypeUnknown:
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
+        return Exception { NOT_SUPPORTED_ERR };
     case LengthTypeNumber:
         return value;
@@ -128 +131 @@
         return value;
     case LengthTypePercentage:
-        return convertValueFromPercentageToUserUnits(value / 100, mode, ec);
+        return convertValueFromPercentageToUserUnits(value / 100, mode);
     case LengthTypeEMS:
-        return convertValueFromEMSToUserUnits(value, ec);
+        return convertValueFromEMSToUserUnits(value);
     case LengthTypeEXS:
-        return convertValueFromEXSToUserUnits(value, ec);
+        return convertValueFromEXSToUserUnits(value);
     case LengthTypeCM:
         return value * cssPixelsPerInch / 2.54f;
@@ -149 +152 @@
 }
 
-float SVGLengthContext::convertValueFromUserUnits(float value, SVGLengthMode mode, SVGLengthType toUnit, ExceptionCode& ec) const
+ExceptionOr<float> SVGLengthContext::convertValueFromUserUnits(float value, SVGLengthMode mode, SVGLengthType toUnit) const
 {
     switch (toUnit) {
     case LengthTypeUnknown:
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
+        return Exception { NOT_SUPPORTED_ERR };
     case LengthTypeNumber:
         return value;
     case LengthTypePercentage:
-        return convertValueFromUserUnitsToPercentage(value * 100, mode, ec);
+        return convertValueFromUserUnitsToPercentage(value * 100, mode);
     case LengthTypeEMS:
-        return convertValueFromUserUnitsToEMS(value, ec);
+        return convertValueFromUserUnitsToEMS(value);
     case LengthTypeEXS:
-        return convertValueFromUserUnitsToEXS(value, ec);
+        return convertValueFromUserUnitsToEXS(value);
     case LengthTypePX:
         return value;
@@ -181 +183 @@
 }
 
-float SVGLengthContext::convertValueFromUserUnitsToPercentage(float value, SVGLengthMode mode, ExceptionCode& ec) const
+ExceptionOr<float> SVGLengthContext::convertValueFromUserUnitsToPercentage(float value, SVGLengthMode mode) const
 {
     FloatSize viewportSize;
-    if (!determineViewport(viewportSize)) {
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
-    }
+    if (!determineViewport(viewportSize))
+        return Exception { NOT_SUPPORTED_ERR };
 
     switch (mode) {
@@ -195 +195 @@
         return value / viewportSize.height() * 100;
     case LengthModeOther:
-        return value / (sqrtf(viewportSize.diagonalLengthSquared() / 2)) * 100;
+        return value / (std::sqrt(viewportSize.diagonalLengthSquared() / 2)) * 100;
     };
 
@@ -202 +202 @@
 }
 
-float SVGLengthContext::convertValueFromPercentageToUserUnits(float value, SVGLengthMode mode, ExceptionCode& ec) const
+ExceptionOr<float> SVGLengthContext::convertValueFromPercentageToUserUnits(float value, SVGLengthMode mode) const
 {
     FloatSize viewportSize;
-    if (!determineViewport(viewportSize)) {
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
-    }
+    if (!determineViewport(viewportSize))
+        return Exception { NOT_SUPPORTED_ERR };
 
     switch (mode) {
@@ -216 +214 @@
         return value * viewportSize.height();
     case LengthModeOther:
-        return value * sqrtf(viewportSize.diagonalLengthSquared() / 2);
+        return value * std::sqrt(viewportSize.diagonalLengthSquared() / 2);
     };
 
@@ -240 +238 @@
 }
 
-float SVGLengthContext::convertValueFromUserUnitsToEMS(float value, ExceptionCode& ec) const
+ExceptionOr<float> SVGLengthContext::convertValueFromUserUnitsToEMS(float value) const
 {
     auto* style = renderStyleForLengthResolving(m_context);
-    if (!style) {
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
-    }
+    if (!style)
+        return Exception { NOT_SUPPORTED_ERR };
 
     float fontSize = style->fontSize();
-    if (!fontSize) {
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
-    }
+    if (!fontSize)
+        return Exception { NOT_SUPPORTED_ERR };
 
     return value / fontSize;
 }
 
-float SVGLengthContext::convertValueFromEMSToUserUnits(float value, ExceptionCode& ec) const
+ExceptionOr<float> SVGLengthContext::convertValueFromEMSToUserUnits(float value) const
 {
     auto* style = renderStyleForLengthResolving(m_context);
-    if (!style) {
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
-    }
+    if (!style)
+        return Exception { NOT_SUPPORTED_ERR };
 
     return value * style->fontSize();
 }
 
-float SVGLengthContext::convertValueFromUserUnitsToEXS(float value, ExceptionCode& ec) const
+ExceptionOr<float> SVGLengthContext::convertValueFromUserUnitsToEXS(float value) const
 {
     auto* style = renderStyleForLengthResolving(m_context);
-    if (!style) {
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
-    }
+    if (!style)
+        return Exception { NOT_SUPPORTED_ERR };
 
     // Use of ceil allows a pixel match to the W3Cs expected output of coords-units-03-b.svg
     // if this causes problems in real world cases maybe it would be best to remove this
-    float xHeight = ceilf(style->fontMetrics().xHeight());
-    if (!xHeight) {
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
-    }
+    float xHeight = std::ceil(style->fontMetrics().xHeight());
+    if (!xHeight)
+        return Exception { NOT_SUPPORTED_ERR };
 
     return value / xHeight;
 }
 
-float SVGLengthContext::convertValueFromEXSToUserUnits(float value, ExceptionCode& ec) const
+ExceptionOr<float> SVGLengthContext::convertValueFromEXSToUserUnits(float value) const
 {
     auto* style = renderStyleForLengthResolving(m_context);
-    if (!style) {
-        ec = NOT_SUPPORTED_ERR;
-        return 0;
-    }
+    if (!style)
+        return Exception { NOT_SUPPORTED_ERR };
 
     // Use of ceil allows a pixel match to the W3Cs expected output of coords-units-03-b.svg
     // if this causes problems in real world cases maybe it would be best to remove this
-    return value * ceilf(style->fontMetrics().xHeight());
+    return value * std::ceil(style->fontMetrics().xHeight());
 }
 

trunk/Source/WebCore/svg/SVGLengthContext.h

@@ -18 +18 @@
  */
 
-#ifndef SVGLengthContext_h
-#define SVGLengthContext_h
+#pragma once
 
+#include "ExceptionOr.h"
 #include "FloatRect.h"
 #include "SVGUnitTypes.h"
@@ -28 +28 @@
 class SVGElement;
 class SVGLength;
+
 struct Length;
-
-typedef int ExceptionCode;
 
 enum SVGLengthType {
@@ -67 +66 @@
 
     float valueForLength(const Length&, SVGLengthMode = LengthModeOther);
-    float convertValueToUserUnits(float, SVGLengthMode, SVGLengthType fromUnit, ExceptionCode&) const;
-    float convertValueFromUserUnits(float, SVGLengthMode, SVGLengthType toUnit, ExceptionCode&) const;
+    ExceptionOr<float> convertValueToUserUnits(float, SVGLengthMode, SVGLengthType fromUnit) const;
+    ExceptionOr<float> convertValueFromUserUnits(float, SVGLengthMode, SVGLengthType toUnit) const;
 
     bool determineViewport(FloatSize&) const;
@@ -75 +74 @@
     SVGLengthContext(const SVGElement*, const FloatRect& viewport);
 
-    float convertValueFromUserUnitsToPercentage(float value, SVGLengthMode, ExceptionCode&) const;
-    float convertValueFromPercentageToUserUnits(float value, SVGLengthMode, ExceptionCode&) const;
+    ExceptionOr<float> convertValueFromUserUnitsToPercentage(float value, SVGLengthMode) const;
+    ExceptionOr<float> convertValueFromPercentageToUserUnits(float value, SVGLengthMode) const;
 
-    float convertValueFromUserUnitsToEMS(float value, ExceptionCode&) const;
-    float convertValueFromEMSToUserUnits(float value, ExceptionCode&) const;
+    ExceptionOr<float> convertValueFromUserUnitsToEMS(float value) const;
+    ExceptionOr<float> convertValueFromEMSToUserUnits(float value) const;
 
-    float convertValueFromUserUnitsToEXS(float value, ExceptionCode&) const;
-    float convertValueFromEXSToUserUnits(float value, ExceptionCode&) const;
+    ExceptionOr<float> convertValueFromUserUnitsToEXS(float value) const;
+    ExceptionOr<float> convertValueFromEXSToUserUnits(float value) const;
 
     const SVGElement* m_context;
@@ -89 +88 @@
 
 } // namespace WebCore
-
-#endif // SVGLengthContext_h

trunk/Source/WebCore/svg/SVGLengthList.cpp

@@ -30 +30 @@
 {
     clear();
-    ExceptionCode ec = 0;
 
     auto upconvertedCharacters = StringView(value).upconvertedCharacters();
@@ -46 +45 @@
         if (valueString.isEmpty())
             return;
-        length.setValueAsString(valueString, ec);
-        if (ec)
+        if (length.setValueAsString(valueString).hasException())
             return;
         append(length);

trunk/Source/WebCore/svg/SVGLengthList.h

@@ -19 +19 @@
  */
 
-#ifndef SVGLengthList_h
-#define SVGLengthList_h
+#pragma once
 
 #include "SVGLength.h"
@@ -29 +28 @@
 class SVGLengthList final : public Vector<SVGLength> {
 public:
-    SVGLengthList() { }
-
-    void parse(const String& value, SVGLengthMode); 
+    void parse(const String& value, SVGLengthMode);
     String valueAsString() const;
 };
 
-template<>
-struct SVGPropertyTraits<SVGLengthList> {
+template<> struct SVGPropertyTraits<SVGLengthList> {
     typedef SVGLength ListItemType;
 
@@ -44 +40 @@
 
 } // namespace WebCore
-
-#endif

trunk/Source/WebCore/svg/SVGLengthList.idl

@@ -28 +28 @@
     readonly attribute unsigned long numberOfItems;
 
-    [MayThrowLegacyException] void clear();
-    [MayThrowLegacyException] SVGLength initialize(SVGLength item);
-    [MayThrowLegacyException] SVGLength getItem(unsigned long index);
-    [MayThrowLegacyException] SVGLength insertItemBefore(SVGLength item, unsigned long index);
-    [MayThrowLegacyException] SVGLength replaceItem(SVGLength item, unsigned long index);
-    [MayThrowLegacyException] SVGLength removeItem(unsigned long index);
-    [MayThrowLegacyException] SVGLength appendItem(SVGLength item);
+    [MayThrowException] void clear();
+    [MayThrowException] SVGLength initialize(SVGLength item);
+    [MayThrowException] SVGLength getItem(unsigned long index);
+    [MayThrowException] SVGLength insertItemBefore(SVGLength item, unsigned long index);
+    [MayThrowException] SVGLength replaceItem(SVGLength item, unsigned long index);
+    [MayThrowException] SVGLength removeItem(unsigned long index);
+    [MayThrowException] SVGLength appendItem(SVGLength item);
 };

trunk/Source/WebCore/svg/SVGLocatable.cpp

@@ -98 +98 @@
 }
 
-AffineTransform SVGLocatable::getTransformToElement(SVGElement* target, ExceptionCode& ec, StyleUpdateStrategy styleUpdateStrategy)
+ExceptionOr<AffineTransform> SVGLocatable::getTransformToElement(SVGElement* target, StyleUpdateStrategy styleUpdateStrategy)
 {
     AffineTransform ctm = getCTM(styleUpdateStrategy);
@@ -106 +106 @@
         if (auto inverse = targetCTM.inverse())
             ctm = inverse.value() * ctm;
-        else {
-            ec = SVGException::SVG_MATRIX_NOT_INVERTABLE;
-            return ctm;
-        }
+        else
+            return Exception { SVGException::SVG_MATRIX_NOT_INVERTABLE };
     }
 
-    return ctm;
+    return WTFMove(ctm);
 }
 

trunk/Source/WebCore/svg/SVGLocatable.h

@@ -20 +20 @@
  */
 
-#ifndef SVGLocatable_h
-#define SVGLocatable_h
+#pragma once
 
 #include "AffineTransform.h"
+#include "ExceptionOr.h"
 
 namespace WebCore {
@@ -29 +29 @@
 class FloatRect;
 class SVGElement;
-
-typedef int ExceptionCode;
 
 class SVGLocatable {
@@ -45 +43 @@
     virtual AffineTransform getCTM(StyleUpdateStrategy) = 0;
     virtual AffineTransform getScreenCTM(StyleUpdateStrategy) = 0;
-    AffineTransform getTransformToElement(SVGElement*, ExceptionCode&, StyleUpdateStrategy = AllowStyleUpdate);
+    ExceptionOr<AffineTransform> getTransformToElement(SVGElement*, StyleUpdateStrategy = AllowStyleUpdate);
 
     static SVGElement* nearestViewportElement(const SVGElement*);
@@ -63 +61 @@
 
 } // namespace WebCore
-
-#endif // SVGLocatable_h

trunk/Source/WebCore/svg/SVGMarkerElement.h

@@ -82 +82 @@
 inline unsigned SVGIDLEnumLimits<SVGMarkerOrientType>::highestExposedEnumValue() { return SVGMarkerOrientAngle; }
 
-template<>
-struct SVGPropertyTraits<SVGMarkerOrientType> {
+template<> struct SVGPropertyTraits<SVGMarkerOrientType> {
     static unsigned highestEnumValue() { return SVGMarkerOrientAutoStartReverse; }
 
@@ -94 +93 @@
         if (value == "auto-start-reverse")
             return SVGMarkerOrientAutoStartReverse;
-
-        ExceptionCode ec = 0;
-        angle.setValueAsString(value, ec);
-        if (!ec)
-            return SVGMarkerOrientAngle;
-        return SVGMarkerOrientUnknown;
+        auto setValueResult = angle.setValueAsString(value);
+        if (setValueResult.hasException())
+            return SVGMarkerOrientUnknown;
+        return SVGMarkerOrientAngle;
     }
 };

trunk/Source/WebCore/svg/SVGMatrix.h

@@ -18 +18 @@
  */
 
-#ifndef SVGMatrix_h
-#define SVGMatrix_h
+#pragma once
 
 #include "AffineTransform.h"
+#include "ExceptionOr.h"
 #include "SVGException.h"
 
 namespace WebCore {
 
-typedef int ExceptionCode;
-
-// Only used in the bindings.
 class SVGMatrix final : public AffineTransform {
 public:
@@ -44 +41 @@
     SVGMatrix translate(double tx, double ty)
     {
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy.translate(tx, ty);
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
     SVGMatrix scale(double s)
     {
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy.scale(s, s);
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
     SVGMatrix scaleNonUniform(double sx, double sy)
     {
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy.scale(sx, sy);
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
     SVGMatrix rotate(double d)
     {
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy.rotate(d);
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
     SVGMatrix flipX()
     {
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy.flipX();
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
     SVGMatrix flipY()
     {
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy.flipY();
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
     SVGMatrix skewX(double angle)
     {
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy.skewX(angle);
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
     SVGMatrix skewY(double angle)
     {
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy.skewY(angle);
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
     SVGMatrix multiply(const SVGMatrix& other)
     {
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy *= static_cast<const AffineTransform&>(other);
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
-    SVGMatrix inverse(ExceptionCode& ec) const
+    ExceptionOr<SVGMatrix> inverse() const
     {
         if (auto inverse = AffineTransform::inverse())
-            return inverse.value();
+            return SVGMatrix { inverse.value() };
         
-        ec = SVGException::SVG_MATRIX_NOT_INVERTABLE;
-        return AffineTransform();
+        return Exception { SVGException::SVG_MATRIX_NOT_INVERTABLE };
     }
 
-    SVGMatrix rotateFromVector(double x, double y, ExceptionCode& ec)
+    ExceptionOr<SVGMatrix> rotateFromVector(double x, double y)
     {
         if (!x || !y)
-            ec = SVGException::SVG_INVALID_VALUE_ERR;
+            return Exception { SVGException::SVG_INVALID_VALUE_ERR };
 
-        AffineTransform copy = *this;
+        AffineTransform copy { *this };
         copy.rotateFromVector(x, y);
-        return static_cast<SVGMatrix>(copy);
+        return SVGMatrix { copy };
     }
 
@@ -127 +123 @@
 
 } // namespace WebCore
-
-#endif

trunk/Source/WebCore/svg/SVGMatrix.idl

@@ -32 +32 @@
 
     SVGMatrix multiply(SVGMatrix secondMatrix);
-    [MayThrowLegacyException] SVGMatrix inverse();
+    [MayThrowException] SVGMatrix inverse();
     [Immutable] SVGMatrix translate(unrestricted float x, unrestricted float y);
     [Immutable] SVGMatrix scale(unrestricted float scaleFactor);
     [Immutable] SVGMatrix scaleNonUniform(unrestricted float scaleFactorX, unrestricted float scaleFactorY);
     [Immutable] SVGMatrix rotate(unrestricted float angle);
-    [MayThrowLegacyException] SVGMatrix rotateFromVector(unrestricted float x, unrestricted float y);
+    [MayThrowException] SVGMatrix rotateFromVector(unrestricted float x, unrestricted float y);
     [Immutable] SVGMatrix flipX();
     [Immutable] SVGMatrix flipY();
@@ -43 +43 @@
     [Immutable] SVGMatrix skewY(unrestricted float angle);
 };
-

trunk/Source/WebCore/svg/SVGNumberList.h

@@ -19 +19 @@
  */
 
-#ifndef SVGNumberList_h
-#define SVGNumberList_h
+#pragma once
 
 #include "SVGPropertyTraits.h"
@@ -29 +28 @@
 class SVGNumberList final : public Vector<float> {
 public:
-    SVGNumberList() { }
-
     void parse(const String&);
     String valueAsString() const;
 };
 
-template<>
-struct SVGPropertyTraits<SVGNumberList> {
+template<> struct SVGPropertyTraits<SVGNumberList> {
     typedef float ListItemType;
 
@@ -44 +40 @@
 
 } // namespace WebCore
-
-#endif

trunk/Source/WebCore/svg/SVGNumberList.idl

@@ -28 +28 @@
     readonly attribute unsigned long numberOfItems;
 
-    [MayThrowLegacyException] void clear();
-    [MayThrowLegacyException] SVGNumber initialize(SVGNumber item);
-    [MayThrowLegacyException] SVGNumber getItem(unsigned long index);
-    [MayThrowLegacyException] SVGNumber insertItemBefore(SVGNumber item, unsigned long index);
-    [MayThrowLegacyException] SVGNumber replaceItem(SVGNumber item, unsigned long index);
-    [MayThrowLegacyException] SVGNumber removeItem(unsigned long index);
-    [MayThrowLegacyException] SVGNumber appendItem(SVGNumber item);
+    [MayThrowException] void clear();
+    [MayThrowException] SVGNumber initialize(SVGNumber item);
+    [MayThrowException] SVGNumber getItem(unsigned long index);
+    [MayThrowException] SVGNumber insertItemBefore(SVGNumber item, unsigned long index);
+    [MayThrowException] SVGNumber replaceItem(SVGNumber item, unsigned long index);
+    [MayThrowException] SVGNumber removeItem(unsigned long index);
+    [MayThrowException] SVGNumber appendItem(SVGNumber item);
 };

trunk/Source/WebCore/svg/SVGPaint.cpp

@@ -65 +65 @@
 }
 
-void SVGPaint::setPaint(unsigned short, const String&, const String&, const String&, ExceptionCode& ec)
+ExceptionOr<void> SVGPaint::setPaint(unsigned short, const String&, const String&, const String&)
 {
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 

trunk/Source/WebCore/svg/SVGPaint.h

@@ -21 +21 @@
  */
 
-#ifndef SVGPaint_h
-#define SVGPaint_h
+#pragma once
 
 #include "SVGColor.h"
-#include <wtf/text/WTFString.h>
 
 namespace WebCore {
@@ -82 +80 @@
 
     void setUri(const String&);
-    void setPaint(unsigned short paintType, const String& uri, const String& rgbColor, const String& iccColor, ExceptionCode&);
+    ExceptionOr<void> setPaint(unsigned short paintType, const String& uri, const String& rgbColor, const String& iccColor);
 
     String customCSSText() const;
@@ -111 +109 @@
 
 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(SVGPaint, isSVGPaint())
-
-#endif // SVGPaint_h

trunk/Source/WebCore/svg/SVGPaint.idl

@@ -42 +42 @@
 
     void setUri(DOMString uri);
-    [MayThrowLegacyException] void setPaint(unsigned short paintType, DOMString uri, DOMString rgbColor, DOMString iccColor);
+    [MayThrowException] void setPaint(unsigned short paintType, DOMString uri, DOMString rgbColor, DOMString iccColor);
 };
-

trunk/Source/WebCore/svg/SVGPathSegList.h

@@ -18 +18 @@
  */
 
-#ifndef SVGPathSegList_h
-#define SVGPathSegList_h
+#pragma once
 
 #include "SVGListProperty.h"
 #include "SVGPathSeg.h"
 #include "SVGPropertyTraits.h"
-
 #include <wtf/Vector.h>
 #include <wtf/text/WTFString.h>
@@ -34 +32 @@
 class SVGPathSegList : public Vector<RefPtr<SVGPathSeg>> {
 public:
-    SVGPathSegList(SVGPathSegRole role)
+    explicit SVGPathSegList(SVGPathSegRole role)
         : m_role(role)
     {
@@ -48 +46 @@
 };
 
-template<>
-struct SVGPropertyTraits<SVGPathSegList> {
+template<> struct SVGPropertyTraits<SVGPathSegList> {
     static SVGPathSegList initialValue() { return SVGPathSegList(PathSegUndefinedRole); }
     typedef RefPtr<SVGPathSeg> ListItemType;
@@ -55 +52 @@
 
 } // namespace WebCore
-
-#endif

trunk/Source/WebCore/svg/SVGPathSegList.idl

@@ -28 +28 @@
     readonly attribute unsigned long numberOfItems;
 
-    [MayThrowLegacyException] void clear();
-    [MayThrowLegacyException] SVGPathSeg initialize(SVGPathSeg? newItem); // FIXME: Should not be nullable.
-    [MayThrowLegacyException] SVGPathSeg getItem(unsigned long index);
-    [MayThrowLegacyException] SVGPathSeg insertItemBefore(SVGPathSeg? newItem, unsigned long index); // FIXME: Should not be nullable.
-    [MayThrowLegacyException] SVGPathSeg replaceItem(SVGPathSeg? newItem, unsigned long index); // FIXME: Should not be nullable.
-    [MayThrowLegacyException] SVGPathSeg removeItem(unsigned long index);
-    [MayThrowLegacyException] SVGPathSeg appendItem(SVGPathSeg? newItem); // FIXME: Should not be nullable.
+    [MayThrowException] void clear();
+    [MayThrowException] SVGPathSeg initialize(SVGPathSeg? newItem); // FIXME: Should not be nullable.
+    [MayThrowException] SVGPathSeg getItem(unsigned long index);
+    [MayThrowException] SVGPathSeg insertItemBefore(SVGPathSeg? newItem, unsigned long index); // FIXME: Should not be nullable.
+    [MayThrowException] SVGPathSeg replaceItem(SVGPathSeg? newItem, unsigned long index); // FIXME: Should not be nullable.
+    [MayThrowException] SVGPathSeg removeItem(unsigned long index);
+    [MayThrowException] SVGPathSeg appendItem(SVGPathSeg? newItem); // FIXME: Should not be nullable.
 };

trunk/Source/WebCore/svg/SVGPointList.h

@@ -19 +19 @@
  */
 
-#ifndef SVGPointList_h
-#define SVGPointList_h
+#pragma once
 
 #include "SVGPoint.h"
@@ -30 +29 @@
 class SVGPointList final : public Vector<SVGPoint> {
 public:
-    SVGPointList() { }
-
     String valueAsString() const;
 };
 
-template<>
-struct SVGPropertyTraits<SVGPointList> {
+template<> struct SVGPropertyTraits<SVGPointList> {
     static SVGPointList initialValue() { return SVGPointList(); }
     typedef SVGPoint ListItemType;
@@ -42 +38 @@
 
 } // namespace WebCore
-
-#endif

trunk/Source/WebCore/svg/SVGPointList.idl

@@ -27 +27 @@
     readonly attribute unsigned long numberOfItems;
 
-    [MayThrowLegacyException] void clear();
-    [MayThrowLegacyException] SVGPoint initialize(SVGPoint item);
-    [MayThrowLegacyException] SVGPoint getItem(unsigned long index);
-    [MayThrowLegacyException] SVGPoint insertItemBefore(SVGPoint item, unsigned long index);
-    [MayThrowLegacyException] SVGPoint replaceItem(SVGPoint item, unsigned long index);
-    [MayThrowLegacyException] SVGPoint removeItem(unsigned long index);
-    [MayThrowLegacyException] SVGPoint appendItem(SVGPoint item);
+    [MayThrowException] void clear();
+    [MayThrowException] SVGPoint initialize(SVGPoint item);
+    [MayThrowException] SVGPoint getItem(unsigned long index);
+    [MayThrowException] SVGPoint insertItemBefore(SVGPoint item, unsigned long index);
+    [MayThrowException] SVGPoint replaceItem(SVGPoint item, unsigned long index);
+    [MayThrowException] SVGPoint removeItem(unsigned long index);
+    [MayThrowException] SVGPoint appendItem(SVGPoint item);
 };

trunk/Source/WebCore/svg/SVGPreserveAspectRatio.cpp

@@ -37 +37 @@
 }
 
-void SVGPreserveAspectRatio::setAlign(unsigned short align, ExceptionCode& ec)
-{
-    if (align == SVG_PRESERVEASPECTRATIO_UNKNOWN || align > SVG_PRESERVEASPECTRATIO_XMAXYMAX) {
-        ec = NOT_SUPPORTED_ERR;
-        return;
-    }
+ExceptionOr<void> SVGPreserveAspectRatio::setAlign(unsigned short align)
+{
+    if (align == SVG_PRESERVEASPECTRATIO_UNKNOWN || align > SVG_PRESERVEASPECTRATIO_XMAXYMAX)
+        return Exception { NOT_SUPPORTED_ERR };
 
     m_align = static_cast<SVGPreserveAspectRatioType>(align);
-}
-
-void SVGPreserveAspectRatio::setMeetOrSlice(unsigned short meetOrSlice, ExceptionCode& ec)
-{
-    if (meetOrSlice == SVG_MEETORSLICE_UNKNOWN || meetOrSlice > SVG_MEETORSLICE_SLICE) {
-        ec = NOT_SUPPORTED_ERR;
-        return;
-    }
+    return { };
+}
+
+ExceptionOr<void> SVGPreserveAspectRatio::setMeetOrSlice(unsigned short meetOrSlice)
+{
+    if (meetOrSlice == SVG_MEETORSLICE_UNKNOWN || meetOrSlice > SVG_MEETORSLICE_SLICE)
+        return Exception { NOT_SUPPORTED_ERR };
 
     m_meetOrSlice = static_cast<SVGMeetOrSliceType>(meetOrSlice);
+    return { };
 }
 

trunk/Source/WebCore/svg/SVGPreserveAspectRatio.h

@@ -19 +19 @@
  */
 
-#ifndef SVGPreserveAspectRatio_h
-#define SVGPreserveAspectRatio_h
+#pragma once
 
+#include "ExceptionOr.h"
 #include "SVGPropertyTraits.h"
 
@@ -28 +28 @@
 class AffineTransform;
 class FloatRect;
-
-typedef int ExceptionCode;
 
 class SVGPreserveAspectRatio {
@@ -56 +54 @@
     SVGPreserveAspectRatio();
 
-    void setAlign(unsigned short align, ExceptionCode&);
+    ExceptionOr<void> setAlign(unsigned short);
     unsigned short align() const { return m_align; }
 
-    void setMeetOrSlice(unsigned short, ExceptionCode&);
+    ExceptionOr<void> setMeetOrSlice(unsigned short);
     unsigned short meetOrSlice() const { return m_meetOrSlice; }
 
     void transformRect(FloatRect& destRect, FloatRect& srcRect);
 
-    AffineTransform getCTM(float logicX, float logicY,
-                           float logicWidth, float logicHeight,
-                           float physWidth, float physHeight) const;
+    AffineTransform getCTM(float logicalX, float logicalY, float logicalWidth, float logicalHeight, float physicalWidth, float physicalHeight) const;
 
     void parse(const String&);
@@ -80 +76 @@
 };
 
-template<>
-struct SVGPropertyTraits<SVGPreserveAspectRatio> {
+template<> struct SVGPropertyTraits<SVGPreserveAspectRatio> {
     static SVGPreserveAspectRatio initialValue() { return SVGPreserveAspectRatio(); }
     static String toString(const SVGPreserveAspectRatio& type) { return type.valueAsString(); }
@@ -87 +82 @@
 
 } // namespace WebCore
-
-#endif // SVGPreserveAspectRatio_h

trunk/Source/WebCore/svg/SVGPreserveAspectRatio.idl

@@ -43 +43 @@
     const unsigned short SVG_MEETORSLICE_SLICE = 2;
 
-    [SetterMayThrowLegacyException] attribute unsigned short align;
-
-    [SetterMayThrowLegacyException] attribute unsigned short meetOrSlice;
+    [SetterMayThrowException] attribute unsigned short align;
+    [SetterMayThrowException] attribute unsigned short meetOrSlice;
 };
-

trunk/Source/WebCore/svg/SVGSVGElement.cpp

@@ -154 +154 @@
 {
     if (!m_viewSpec)
-        m_viewSpec = SVGViewSpec::create(this);
+        m_viewSpec = SVGViewSpec::create(*this);
     return *m_viewSpec;
 }

trunk/Source/WebCore/svg/SVGStringList.h

@@ -19 +19 @@
  */
 
-#ifndef SVGStringList_h
-#define SVGStringList_h
+#pragma once
 
 #include "QualifiedName.h"
@@ -49 +48 @@
 };
 
-template<>
-struct SVGPropertyTraits<SVGStringList> {
+template<> struct SVGPropertyTraits<SVGStringList> {
     typedef String ListItemType;
 };
 
 } // namespace WebCore
-
-#endif

trunk/Source/WebCore/svg/SVGStringList.idl

@@ -27 +27 @@
     readonly attribute unsigned long numberOfItems;
 
-    [MayThrowLegacyException] void clear();
-    [MayThrowLegacyException] DOMString initialize(DOMString item);
-    [MayThrowLegacyException] DOMString getItem(unsigned long index);
-    [MayThrowLegacyException] DOMString insertItemBefore(DOMString item, unsigned long index);
-    [MayThrowLegacyException] DOMString replaceItem(DOMString item, unsigned long index);
-    [MayThrowLegacyException] DOMString removeItem(unsigned long index);
-    [MayThrowLegacyException] DOMString appendItem(DOMString item);
+    [MayThrowException] void clear();
+    [MayThrowException] DOMString initialize(DOMString item);
+    [MayThrowException] DOMString getItem(unsigned long index);
+    [MayThrowException] DOMString insertItemBefore(DOMString item, unsigned long index);
+    [MayThrowException] DOMString replaceItem(DOMString item, unsigned long index);
+    [MayThrowException] DOMString removeItem(unsigned long index);
+    [MayThrowException] DOMString appendItem(DOMString item);
 };
-

trunk/Source/WebCore/svg/SVGStyleElement.cpp

@@ -68 +68 @@
 }
 
-void SVGStyleElement::setType(const AtomicString& type, ExceptionCode&)
+void SVGStyleElement::setType(const AtomicString& type)
 {
     setAttribute(SVGNames::typeAttr, type);
@@ -80 +80 @@
 }
 
-void SVGStyleElement::setMedia(const AtomicString& media, ExceptionCode&)
+void SVGStyleElement::setMedia(const AtomicString& media)
 {
     setAttributeWithoutSynchronization(SVGNames::mediaAttr, media);
@@ -88 +88 @@
 {
     return attributeWithoutSynchronization(SVGNames::titleAttr);
-}
-
-void SVGStyleElement::setTitle(const AtomicString& title, ExceptionCode&)
-{
-    setAttributeWithoutSynchronization(SVGNames::titleAttr, title);
 }
 

trunk/Source/WebCore/svg/SVGStyleElement.h

@@ -20 +20 @@
  */
 
-#ifndef SVGStyleElement_h
-#define SVGStyleElement_h
+#pragma once
 
 #include "InlineStyleSheetOwner.h"
@@ -39 +38 @@
                           
     const AtomicString& type() const;
-    void setType(const AtomicString&, ExceptionCode&);
+    void setType(const AtomicString&);
 
     const AtomicString& media() const;
-    void setMedia(const AtomicString&, ExceptionCode&);
-
-    String title() const final;
-    void setTitle(const AtomicString&, ExceptionCode&);
+    void setMedia(const AtomicString&);
 
 private:
@@ -64 +60 @@
     Timer* svgLoadEventTimer() final { return &m_svgLoadEventTimer; }
 
+    String title() const final;
+
     InlineStyleSheetOwner m_styleSheetOwner;
     Timer m_svgLoadEventTimer;
@@ -69 +67 @@
 
 } // namespace WebCore
-
-#endif // SVGStyleElement_h

trunk/Source/WebCore/svg/SVGStyleElement.idl

@@ -26 +26 @@
 
 interface SVGStyleElement : SVGElement {
-             attribute boolean disabled;
-             [SetterMayThrowLegacyException] attribute DOMString type;
-             [SetterMayThrowLegacyException] attribute DOMString media;
-             [SetterMayThrowLegacyException] attribute DOMString title;
+     attribute boolean disabled;
+     attribute DOMString type;
+     attribute DOMString media;
+     [Reflect] attribute DOMString title;
 };
-

trunk/Source/WebCore/svg/SVGTextContentElement.cpp

@@ -94 +94 @@
     static NeverDestroyed<SVGLength> defaultTextLength(LengthModeOther);
     if (m_specifiedTextLength == defaultTextLength)
-        m_textLength.value.newValueSpecifiedUnits(LengthTypeNumber, getComputedTextLength(), ASSERT_NO_EXCEPTION);
+        m_textLength.value.newValueSpecifiedUnits(LengthTypeNumber, getComputedTextLength());
 
     m_textLength.shouldSynchronize = true;
     return static_reference_cast<SVGAnimatedLength>(lookupOrCreateTextLengthWrapper(this));
-
 }
 
@@ -113 +112 @@
 }
 
-float SVGTextContentElement::getSubStringLength(unsigned charnum, unsigned nchars, ExceptionCode& ec)
-{
-    document().updateLayoutIgnorePendingStylesheets();
-
+ExceptionOr<float> SVGTextContentElement::getSubStringLength(unsigned charnum, unsigned nchars)
+{
     unsigned numberOfChars = getNumberOfChars();
-    if (charnum >= numberOfChars) {
-        ec = INDEX_SIZE_ERR;
-        return 0.0f;
-    }
+    if (charnum >= numberOfChars)
+        return Exception { INDEX_SIZE_ERR };
 
     nchars = std::min(nchars, numberOfChars - charnum);
@@ -127 +122 @@
 }
 
-SVGPoint SVGTextContentElement::getStartPositionOfChar(unsigned charnum, ExceptionCode& ec)
-{
-    document().updateLayoutIgnorePendingStylesheets();
-
-    if (charnum > getNumberOfChars()) {
-        ec = INDEX_SIZE_ERR;
-        return SVGPoint();
-    }
+ExceptionOr<SVGPoint> SVGTextContentElement::getStartPositionOfChar(unsigned charnum)
+{
+    if (charnum > getNumberOfChars())
+        return Exception { INDEX_SIZE_ERR };
 
     return SVGTextQuery(renderer()).startPositionOfCharacter(charnum);
 }
 
-SVGPoint SVGTextContentElement::getEndPositionOfChar(unsigned charnum, ExceptionCode& ec)
-{
-    document().updateLayoutIgnorePendingStylesheets();
-
-    if (charnum > getNumberOfChars()) {
-        ec = INDEX_SIZE_ERR;
-        return SVGPoint();
-    }
+ExceptionOr<SVGPoint> SVGTextContentElement::getEndPositionOfChar(unsigned charnum)
+{
+    if (charnum > getNumberOfChars())
+        return Exception { INDEX_SIZE_ERR };
 
     return SVGTextQuery(renderer()).endPositionOfCharacter(charnum);
 }
 
-FloatRect SVGTextContentElement::getExtentOfChar(unsigned charnum, ExceptionCode& ec)
-{
-    document().updateLayoutIgnorePendingStylesheets();
-
-    if (charnum > getNumberOfChars()) {
-        ec = INDEX_SIZE_ERR;
-        return FloatRect();
-    }
+ExceptionOr<FloatRect> SVGTextContentElement::getExtentOfChar(unsigned charnum)
+{
+    if (charnum > getNumberOfChars())
+        return Exception { INDEX_SIZE_ERR };
 
     return SVGTextQuery(renderer()).extentOfCharacter(charnum);
 }
 
-float SVGTextContentElement::getRotationOfChar(unsigned charnum, ExceptionCode& ec)
-{
-    document().updateLayoutIgnorePendingStylesheets();
-
-    if (charnum > getNumberOfChars()) {
-        ec = INDEX_SIZE_ERR;
-        return 0.0f;
-    }
+ExceptionOr<float> SVGTextContentElement::getRotationOfChar(unsigned charnum)
+{
+    if (charnum > getNumberOfChars())
+        return Exception { INDEX_SIZE_ERR };
 
     return SVGTextQuery(renderer()).rotationOfCharacter(charnum);
@@ -181 +160 @@
 }
 
-void SVGTextContentElement::selectSubString(unsigned charnum, unsigned nchars, ExceptionCode& ec)
+ExceptionOr<void> SVGTextContentElement::selectSubString(unsigned charnum, unsigned nchars)
 {
     unsigned numberOfChars = getNumberOfChars();
-    if (charnum >= numberOfChars) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
+    if (charnum >= numberOfChars)
+        return Exception { INDEX_SIZE_ERR };
 
     nchars = std::min(nchars, numberOfChars - charnum);
@@ -206 +183 @@
 
     selection.setSelection(VisibleSelection(start, end));
+
+    return { };
 }
 

trunk/Source/WebCore/svg/SVGTextContentElement.h

@@ -19 +19 @@
  */
 
-#ifndef SVGTextContentElement_h
-#define SVGTextContentElement_h
+#pragma once
 
 #include "SVGAnimatedBoolean.h"
@@ -36 +35 @@
 };
 
-template<>
-struct SVGPropertyTraits<SVGLengthAdjustType> {
+template<> struct SVGPropertyTraits<SVGLengthAdjustType> {
     static unsigned highestEnumValue() { return SVGLengthAdjustSpacingAndGlyphs; }
 
@@ -67 +65 @@
 class SVGTextContentElement : public SVGGraphicsElement, public SVGExternalResourcesRequired {
 public:
-    // Forward declare enumerations in the W3C naming scheme, for IDL generation.
     enum {
         LENGTHADJUST_UNKNOWN = SVGLengthAdjustUnknown,
@@ -76 +73 @@
     unsigned getNumberOfChars();
     float getComputedTextLength();
-    float getSubStringLength(unsigned charnum, unsigned nchars, ExceptionCode&);
-    SVGPoint getStartPositionOfChar(unsigned charnum, ExceptionCode&);
-    SVGPoint getEndPositionOfChar(unsigned charnum, ExceptionCode&);
-    FloatRect getExtentOfChar(unsigned charnum, ExceptionCode&);
-    float getRotationOfChar(unsigned charnum, ExceptionCode&);
+    ExceptionOr<float> getSubStringLength(unsigned charnum, unsigned nchars);
+    ExceptionOr<SVGPoint> getStartPositionOfChar(unsigned charnum);
+    ExceptionOr<SVGPoint> getEndPositionOfChar(unsigned charnum);
+    ExceptionOr<FloatRect> getExtentOfChar(unsigned charnum);
+    ExceptionOr<float> getRotationOfChar(unsigned charnum);
     int getCharNumAtPosition(const SVGPoint&);
-    void selectSubString(unsigned charnum, unsigned nchars, ExceptionCode&);
+    ExceptionOr<void> selectSubString(unsigned charnum, unsigned nchars);
 
     static SVGTextContentElement* elementFromRenderer(RenderObject*);
@@ -127 +124 @@
     static bool isType(const WebCore::Node& node) { return is<WebCore::SVGElement>(node) && isType(downcast<WebCore::SVGElement>(node)); }
 SPECIALIZE_TYPE_TRAITS_END()
-
-#endif

trunk/Source/WebCore/svg/SVGTextContentElement.idl

@@ -26 +26 @@
 interface SVGTextContentElement : SVGGraphicsElement {
     // lengthAdjust Types
-    const unsigned short LENGTHADJUST_UNKNOWN          = 0;
-    const unsigned short LENGTHADJUST_SPACING          = 1;
+    const unsigned short LENGTHADJUST_UNKNOWN = 0;
+    const unsigned short LENGTHADJUST_SPACING = 1;
     const unsigned short LENGTHADJUST_SPACINGANDGLYPHS = 2;
 
-    readonly attribute SVGAnimatedLength      textLength;
+    readonly attribute SVGAnimatedLength textLength;
     readonly attribute SVGAnimatedEnumeration lengthAdjust;
 
     long getNumberOfChars();
     unrestricted float getComputedTextLength();
-    [MayThrowLegacyException] unrestricted float getSubStringLength(optional unsigned long offset = 0,
-                             optional unsigned long length = 0);
-    [MayThrowLegacyException] SVGPoint getStartPositionOfChar(optional unsigned long offset = 0);
-    [MayThrowLegacyException] SVGPoint getEndPositionOfChar(optional unsigned long offset = 0);
-    [MayThrowLegacyException] SVGRect getExtentOfChar(optional unsigned long offset = 0);
-    [MayThrowLegacyException] unrestricted float getRotationOfChar(optional unsigned long offset = 0);
+    [MayThrowException] unrestricted float getSubStringLength(optional unsigned long offset = 0, optional unsigned long length = 0);
+    [MayThrowException] SVGPoint getStartPositionOfChar(optional unsigned long offset = 0);
+    [MayThrowException] SVGPoint getEndPositionOfChar(optional unsigned long offset = 0);
+    [MayThrowException] SVGRect getExtentOfChar(optional unsigned long offset = 0);
+    [MayThrowException] unrestricted float getRotationOfChar(optional unsigned long offset = 0);
     long getCharNumAtPosition(SVGPoint point);
-    [MayThrowLegacyException] void selectSubString(optional unsigned long offset = 0, optional unsigned long length = 0);
+    [MayThrowException] void selectSubString(optional unsigned long offset = 0, optional unsigned long length = 0);
 };
 

trunk/Source/WebCore/svg/SVGTransformList.h

@@ -19 +19 @@
  */
 
-#ifndef SVGTransformList_h
-#define SVGTransformList_h
+#pragma once
 
 #include "SVGPropertyTraits.h"
@@ -30 +29 @@
 class SVGTransformList final : public Vector<SVGTransform, 1> {
 public:
-    SVGTransformList() { }
-
     SVGTransform createSVGTransformFromMatrix(const SVGMatrix&) const;
     SVGTransform consolidate();
 
-    // Internal use only
     bool concatenate(AffineTransform& result) const;
  
@@ -42 +38 @@
 };
 
-template<>
-struct SVGPropertyTraits<SVGTransformList> {
+template<> struct SVGPropertyTraits<SVGTransformList> {
     static SVGTransformList initialValue() { return SVGTransformList(); }
     static String toString(const SVGTransformList& type) { return type.valueAsString(); }
@@ -50 +45 @@
 
 } // namespace WebCore
-
-#endif // SVGTransformList_h

trunk/Source/WebCore/svg/SVGTransformList.idl

@@ -28 +28 @@
     readonly attribute unsigned long numberOfItems;
 
-    [MayThrowLegacyException] void clear();
-    [MayThrowLegacyException] SVGTransform initialize(SVGTransform item);
-    [MayThrowLegacyException] SVGTransform getItem(unsigned long index);
-    [MayThrowLegacyException] SVGTransform insertItemBefore(SVGTransform item, unsigned long index);
-    [MayThrowLegacyException] SVGTransform replaceItem(SVGTransform item, unsigned long index);
-    [MayThrowLegacyException] SVGTransform removeItem(unsigned long index);
-    [MayThrowLegacyException] SVGTransform appendItem(SVGTransform item);
+    [MayThrowException] void clear();
+    [MayThrowException] SVGTransform initialize(SVGTransform item);
+    [MayThrowException] SVGTransform getItem(unsigned long index);
+    [MayThrowException] SVGTransform insertItemBefore(SVGTransform item, unsigned long index);
+    [MayThrowException] SVGTransform replaceItem(SVGTransform item, unsigned long index);
+    [MayThrowException] SVGTransform removeItem(unsigned long index);
+    [MayThrowException] SVGTransform appendItem(SVGTransform item);
 
-    [MayThrowLegacyException] SVGTransform createSVGTransformFromMatrix(SVGMatrix matrix);
+    [MayThrowException] SVGTransform createSVGTransformFromMatrix(SVGMatrix matrix);
 
-    [MayThrowLegacyException] SVGTransform consolidate();
+    [MayThrowException] SVGTransform consolidate();
 };

trunk/Source/WebCore/svg/SVGViewSpec.cpp

@@ -76 +76 @@
 }
 
-SVGViewSpec::SVGViewSpec(SVGElement* contextElement)
-    : m_contextElement(contextElement)
-    , m_zoomAndPan(SVGZoomAndPanMagnify)
-{
-    ASSERT(m_contextElement);
+SVGViewSpec::SVGViewSpec(SVGElement& contextElement)
+    : m_contextElement(&contextElement)
+{
 }
 
@@ -101 +99 @@
 }
 
-void SVGViewSpec::setZoomAndPan(unsigned short, ExceptionCode& ec)
+ExceptionOr<void> SVGViewSpec::setZoomAndPan(unsigned short)
 {
     // SVGViewSpec and all of its content is read-only.
-    ec = NO_MODIFICATION_ALLOWED_ERR;
-}
-
-void SVGViewSpec::setTransformString(const String& transform)
-{
-    if (!m_contextElement)
-        return;
-
-    SVGTransformList newList;
-    newList.parse(transform);
-
-    if (auto wrapper = SVGAnimatedProperty::lookupWrapper<SVGElement, SVGAnimatedTransformList>(m_contextElement, transformPropertyInfo()))
-        static_pointer_cast<SVGAnimatedTransformList>(wrapper)->detachListWrappers(newList.size());
-
-    m_transform = newList;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
@@ -128 +112 @@
 String SVGViewSpec::viewBoxString() const
 {
-    return SVGPropertyTraits<FloatRect>::toString(viewBoxBaseValue());
+    return SVGPropertyTraits<FloatRect>::toString(m_viewBox);
 }
 
 String SVGViewSpec::preserveAspectRatioString() const
 {
-    return SVGPropertyTraits<SVGPreserveAspectRatio>::toString(preserveAspectRatioBaseValue());
+    return SVGPropertyTraits<SVGPreserveAspectRatio>::toString(m_preserveAspectRatio);
 }
 
@@ -140 +124 @@
     if (!m_contextElement)
         return nullptr;
-    Element* element = m_contextElement->treeScope().getElementById(m_viewTargetString);
-    if (!element || !element->isSVGElement())
+    auto* element = m_contextElement->treeScope().getElementById(m_viewTargetString);
+    if (!is<SVGElement>(element))
         return nullptr;
     return downcast<SVGElement>(element);
@@ -171 +155 @@
 {
     ASSERT(ownerType);
-    ASSERT(ownerType->contextElement());
-    return SVGAnimatedProperty::lookupOrCreateWrapper<SVGElement, SVGAnimatedRect, FloatRect>(ownerType->contextElement(), viewBoxPropertyInfo(), ownerType->m_viewBox);
+    ASSERT(ownerType->m_contextElement);
+    return SVGAnimatedProperty::lookupOrCreateWrapper<SVGElement, SVGAnimatedRect, FloatRect>(ownerType->m_contextElement, viewBoxPropertyInfo(), ownerType->m_viewBox);
 }
 
@@ -178 +162 @@
 {
     ASSERT(ownerType);
-    ASSERT(ownerType->contextElement());
-    return SVGAnimatedProperty::lookupOrCreateWrapper<SVGElement, SVGAnimatedPreserveAspectRatio, SVGPreserveAspectRatio>(ownerType->contextElement(), preserveAspectRatioPropertyInfo(), ownerType->m_preserveAspectRatio);
+    ASSERT(ownerType->m_contextElement);
+    return SVGAnimatedProperty::lookupOrCreateWrapper<SVGElement, SVGAnimatedPreserveAspectRatio, SVGPreserveAspectRatio>(ownerType->m_contextElement, preserveAspectRatioPropertyInfo(), ownerType->m_preserveAspectRatio);
 }
 
@@ -185 +169 @@
 {
     ASSERT(ownerType);
-    ASSERT(ownerType->contextElement());
-    return SVGAnimatedProperty::lookupOrCreateWrapper<SVGElement, SVGAnimatedTransformList, SVGTransformList>(ownerType->contextElement(), transformPropertyInfo(), ownerType->m_transform);
+    ASSERT(ownerType->m_contextElement);
+    return SVGAnimatedProperty::lookupOrCreateWrapper<SVGElement, SVGAnimatedTransformList, SVGTransformList>(ownerType->m_contextElement, transformPropertyInfo(), ownerType->m_transform);
 }
 
@@ -242 +226 @@
                 if (currViewSpec >= end)
                     return false;
-                setViewTargetString(String(viewTargetStart, currViewSpec - viewTargetStart));
+                m_viewTargetString = String(viewTargetStart, currViewSpec - viewTargetStart);
                 currViewSpec++;
             } else

trunk/Source/WebCore/svg/SVGViewSpec.h

@@ -18 +18 @@
  */
 
-#ifndef SVGViewSpec_h
-#define SVGViewSpec_h
+#pragma once
 
 #include "SVGAnimatedPreserveAspectRatio.h"
@@ -32 +31 @@
 class SVGTransformListPropertyTearOff;
 
-class SVGViewSpec final : public RefCounted<SVGViewSpec>
-                  , public SVGZoomAndPan
-                  , public SVGFitToViewBox {
+class SVGViewSpec final : public RefCounted<SVGViewSpec>, public SVGZoomAndPan, public SVGFitToViewBox {
 public:
-    virtual ~SVGViewSpec() { }
-
-    using RefCounted<SVGViewSpec>::ref;
-    using RefCounted<SVGViewSpec>::deref;
-
-    static Ref<SVGViewSpec> create(SVGElement* contextElement)
+    static Ref<SVGViewSpec> create(SVGElement& contextElement)
     {
         return adoptRef(*new SVGViewSpec(contextElement));
@@ -50 +42 @@
 
     SVGElement* viewTarget() const;
+
+    String transformString() const;
     String viewBoxString() const;
-
     String preserveAspectRatioString() const;
-
-    void setTransformString(const String&);
-    String transformString() const;
-
-    void setViewTargetString(const String& string) { m_viewTargetString = string; }
-    String viewTargetString() const { return m_viewTargetString; }
+    const String& viewTargetString() const { return m_viewTargetString; }
 
     SVGZoomAndPanType zoomAndPan() const { return m_zoomAndPan; }
-    void setZoomAndPan(unsigned short zoomAndPan) { setZoomAndPanBaseValue(zoomAndPan); }
-    void setZoomAndPan(unsigned short, ExceptionCode&);
+    ExceptionOr<void> setZoomAndPan(unsigned short);
     void setZoomAndPanBaseValue(unsigned short zoomAndPan) { m_zoomAndPan = SVGZoomAndPan::parseFromNumber(zoomAndPan); }
 
-    SVGElement* contextElement() const { return m_contextElement; }
     void resetContextElement() { m_contextElement = nullptr; }
 
@@ -75 +61 @@
     RefPtr<SVGAnimatedRect> viewBoxAnimated();
     FloatRect& viewBox() { return m_viewBox; }
-    FloatRect viewBoxBaseValue() const { return m_viewBox; }
     void setViewBoxBaseValue(const FloatRect& viewBox) { m_viewBox = viewBox; }
 
@@ -81 +66 @@
     RefPtr<SVGAnimatedPreserveAspectRatio> preserveAspectRatioAnimated();
     SVGPreserveAspectRatio& preserveAspectRatio() { return m_preserveAspectRatio; }
-    SVGPreserveAspectRatio preserveAspectRatioBaseValue() const { return m_preserveAspectRatio; }
     void setPreserveAspectRatioBaseValue(const SVGPreserveAspectRatio& preserveAspectRatio) { m_preserveAspectRatio = preserveAspectRatio; }
 
 private:
-    SVGViewSpec(SVGElement*);
+    explicit SVGViewSpec(SVGElement&);
 
     static const SVGPropertyInfo* transformPropertyInfo();
@@ -100 +84 @@
 
     SVGElement* m_contextElement;
-    SVGZoomAndPanType m_zoomAndPan;
-
+    SVGZoomAndPanType m_zoomAndPan { SVGZoomAndPanMagnify };
     SVGTransformList m_transform;
     FloatRect m_viewBox;
@@ -109 +92 @@
 
 } // namespace WebCore
-
-#endif

trunk/Source/WebCore/svg/SVGViewSpec.idl

@@ -27 +27 @@
 // It would require that any of those classes would be RefCounted, and we want to avoid that.
 [
-    JSGenerateToJSObject
+    ImplementationLacksVTable,
+    JSGenerateToJSObject,
 ] interface SVGViewSpec {
-      readonly attribute SVGTransformList transform;
-      readonly attribute SVGElement viewTarget;
-      readonly attribute DOMString viewBoxString;
-      readonly attribute DOMString preserveAspectRatioString;
-      readonly attribute DOMString transformString;
-      readonly attribute DOMString viewTargetString;
+    readonly attribute SVGTransformList transform;
+    readonly attribute SVGElement viewTarget;
+    readonly attribute DOMString viewBoxString;
+    readonly attribute DOMString preserveAspectRatioString;
+    readonly attribute DOMString transformString;
+    readonly attribute DOMString viewTargetString;
 
-      // SVGZoomAndPan
-      [SetterMayThrowLegacyException] attribute unsigned short zoomAndPan;
+    // SVGZoomAndPan
+    [SetterMayThrowException] attribute unsigned short zoomAndPan;
 };
 

trunk/Source/WebCore/svg/properties/SVGAnimatedEnumerationPropertyTearOff.h

@@ -50 +50 @@
     }
 
-    void setBaseVal(const unsigned& property, ExceptionCode& ec) final
+    ExceptionOr<void> setBaseVal(const unsigned& property) final
     {
         // All SVG enumeration values, that are allowed to be set via SVG DOM start with 1, 0 corresponds to unknown and is not settable through SVG DOM.
-        if (!property || property > SVGIDLEnumLimits<EnumType>::highestExposedEnumValue()) {
-            ec = SVGException::SVG_INVALID_VALUE_ERR;
-            return;
-        }
-        SVGAnimatedStaticPropertyTearOff<unsigned>::setBaseVal(property, ec);
+        if (!property || property > SVGIDLEnumLimits<EnumType>::highestExposedEnumValue())
+            return Exception { SVGException::SVG_INVALID_VALUE_ERR };
+        return SVGAnimatedStaticPropertyTearOff<unsigned>::setBaseVal(property);
     }
 

trunk/Source/WebCore/svg/properties/SVGAnimatedStaticPropertyTearOff.h

@@ -19 +19 @@
  */
 
-#ifndef SVGAnimatedStaticPropertyTearOff_h
-#define SVGAnimatedStaticPropertyTearOff_h
+#pragma once
 
-#include "ExceptionCode.h"
+#include "ExceptionOr.h"
 #include "SVGAnimatedProperty.h"
 
@@ -44 +43 @@
     }
 
-    virtual void setBaseVal(const PropertyType& property, ExceptionCode&)
+    virtual ExceptionOr<void> setBaseVal(const PropertyType& property)
     {
         m_property = property;
         commitChange();
+        return { };
     }
 
@@ -108 +108 @@
 
 }
-
-#endif // SVGAnimatedStaticPropertyTearOff_h

trunk/Source/WebCore/svg/properties/SVGListProperty.h

@@ -18 +18 @@
  */
 
-#ifndef SVGListProperty_h
-#define SVGListProperty_h
+#pragma once
 
 #include "SVGException.h"
@@ -43 +42 @@
     typedef SVGListProperty<PropertyType> Self;
 
-    typedef typename SVGPropertyTraits<PropertyType>::ListItemType ListItemType;
-    typedef SVGPropertyTearOff<ListItemType> ListItemTearOff;
-    typedef RefPtr<ListItemTearOff> PtrListItemTearOff;
-    typedef SVGAnimatedListPropertyTearOff<PropertyType> AnimatedListPropertyTearOff;
-    typedef typename SVGAnimatedListPropertyTearOff<PropertyType>::ListWrapperCache ListWrapperCache;
-
-    bool canAlterList(ExceptionCode& ec) const
-    {
-        if (m_role == AnimValRole) {
-            ec = NO_MODIFICATION_ALLOWED_ERR;
-            return false;
-        }
+    using ListItemType = typename SVGPropertyTraits<PropertyType>::ListItemType;
+    using ListItemTearOff = SVGPropertyTearOff<ListItemType>;
+    using PtrListItemTearOff = RefPtr<ListItemTearOff>;
+    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<PropertyType>;
+    using ListWrapperCache = typename AnimatedListPropertyTearOff::ListWrapperCache;
+
+    ExceptionOr<bool> canAlterList() const
+    {
+        if (m_role == AnimValRole)
+            return Exception { NO_MODIFICATION_ALLOWED_ERR };
 
         return true;
@@ -96 +93 @@
 
     // SVGList::clear()
-    void clearValues(ExceptionCode& ec)
-    {
-        if (!canAlterList(ec))
-            return;
+    ExceptionOr<void> clearValues()
+    {
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
+            return { };
 
         m_values->clear();
         commitChange();
-    }
-
-    void clearValuesAndWrappers(ExceptionCode& ec)
-    {
-        if (!canAlterList(ec))
-            return;
+        return { };
+    }
+
+    ExceptionOr<void> clearValuesAndWrappers()
+    {
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
+            return { };
 
         detachListWrappers(0);
         m_values->clear();
         commitChange();
+        return { };
     }
 
@@ -122 +127 @@
 
     // SVGList::initialize()
-    ListItemType initializeValues(const ListItemType& newItem, ExceptionCode& ec)
-    {
-        if (!canAlterList(ec))
-            return ListItemType();
+    ExceptionOr<ListItemType> initializeValues(const ListItemType& newItem)
+    {
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
+            return ListItemType { };
 
         // Spec: If the inserted item is already in a list, it is removed from its previous list before it is inserted into this list.
@@ -135 +143 @@
 
         commitChange();
-        return newItem;
-    }
-
-    PtrListItemTearOff initializeValuesAndWrappers(PtrListItemTearOff newItem, ExceptionCode& ec)
-    {
-        ASSERT(m_wrappers);
-        if (!canAlterList(ec))
+        return ListItemType { newItem };
+    }
+
+    ExceptionOr<PtrListItemTearOff> initializeValuesAndWrappers(PtrListItemTearOff newItem)
+    {
+        ASSERT(m_wrappers);
+
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
             return nullptr;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
-        if (!newItem) {
-            ec = SVGException::SVG_WRONG_TYPE_ERR;
-            return nullptr;
-        }
+        if (!newItem)
+            return Exception { SVGException::SVG_WRONG_TYPE_ERR };
 
         ASSERT(m_values->size() == m_wrappers->size());
@@ -163 +173 @@
 
         commitChange();
-        return newItem;
+        return WTFMove(newItem);
     }
 
     // SVGList::getItem()
-    bool canGetItem(unsigned index, ExceptionCode& ec)
-    {
-        if (index >= m_values->size()) {
-            ec = INDEX_SIZE_ERR;
-            return false;
-        }
+    ExceptionOr<bool> canGetItem(unsigned index)
+    {
+        if (index >= m_values->size())
+            return Exception { INDEX_SIZE_ERR };
 
         return true;
     }
 
-    ListItemType getItemValues(unsigned index, ExceptionCode& ec)
-    {
-        if (!canGetItem(index, ec))
-            return ListItemType();
+    ExceptionOr<ListItemType> getItemValues(unsigned index)
+    {
+        auto result = canGetItem(index);
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
+            return ListItemType { };
 
         // Spec: Returns the specified item from the list. The returned item is the item itself and not a copy.
-        return m_values->at(index);
-    }
-
-    PtrListItemTearOff getItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index, ExceptionCode& ec)
-    {
-        ASSERT(m_wrappers);
-        if (!canGetItem(index, ec))
+        return ListItemType { m_values->at(index) };
+    }
+
+    ExceptionOr<PtrListItemTearOff> getItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index)
+    {
+        ASSERT(m_wrappers);
+
+        auto result = canGetItem(index);
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
             return nullptr;
 
@@ -208 +223 @@
 
     // SVGList::insertItemBefore()
-    ListItemType insertItemBeforeValues(const ListItemType& newItem, unsigned index, ExceptionCode& ec)
-    {
-        if (!canAlterList(ec))
-            return ListItemType();
+    ExceptionOr<ListItemType> insertItemBeforeValues(const ListItemType& newItem, unsigned index)
+    {
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
+            return ListItemType { };
 
         // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.
@@ -220 +238 @@
         if (!processIncomingListItemValue(newItem, &index)) {
             // Inserting the item before itself is a no-op.
-            return newItem;
+            return ListItemType { newItem };
         }
 
@@ -228 +246 @@
 
         commitChange();
-        return newItem;
-    }
-
-    PtrListItemTearOff insertItemBeforeValuesAndWrappers(PtrListItemTearOff newItem, unsigned index, ExceptionCode& ec)
-    {
-        ASSERT(m_wrappers);
-        if (!canAlterList(ec))
+        return ListItemType { newItem };
+    }
+
+    ExceptionOr<PtrListItemTearOff> insertItemBeforeValuesAndWrappers(PtrListItemTearOff newItem, unsigned index)
+    {
+        ASSERT(m_wrappers);
+
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
             return nullptr;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
-        if (!newItem) {
-            ec = SVGException::SVG_WRONG_TYPE_ERR;
-            return nullptr;
-        }
+        if (!newItem)
+            return Exception { SVGException::SVG_WRONG_TYPE_ERR };
 
         // 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 > m_values->size())
-             index = m_values->size();
+            index = m_values->size();
 
         ASSERT(m_values->size() == m_wrappers->size());
@@ -265 +285 @@
 
     // SVGList::replaceItem()
-    bool canReplaceItem(unsigned index, ExceptionCode& ec)
-    {
-        if (!canAlterList(ec))
+    ExceptionOr<bool> canReplaceItem(unsigned index)
+    {
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
             return false;
 
-        if (index >= m_values->size()) {
-            ec = INDEX_SIZE_ERR;
-            return false;
-        }
+        if (index >= m_values->size())
+            return Exception { INDEX_SIZE_ERR };
 
         return true;
     }
 
-    ListItemType replaceItemValues(const ListItemType& newItem, unsigned index, ExceptionCode& ec)
-    {
-        if (!canReplaceItem(index, ec))
-            return ListItemType();
+    ExceptionOr<ListItemType> replaceItemValues(const ListItemType& newItem, unsigned index)
+    {
+        auto result = canReplaceItem(index);
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
+            return ListItemType { };
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
@@ -287 +311 @@
         if (!processIncomingListItemValue(newItem, &index)) {
             // Replacing the item with itself is a no-op.
-            return newItem;
+            return ListItemType { newItem };
         }
 
         if (m_values->isEmpty()) {
             // 'newItem' already lived in our list, we removed it, and now we're empty, which means there's nothing to replace.
-            ec = INDEX_SIZE_ERR;
-            return ListItemType();
+            return Exception { INDEX_SIZE_ERR };
         }
 
@@ -300 +323 @@
 
         commitChange();
-        return newItem;
-    }
-
-    PtrListItemTearOff replaceItemValuesAndWrappers(PtrListItemTearOff newItem, unsigned index, ExceptionCode& ec)
-    {
-        ASSERT(m_wrappers);
-        if (!canReplaceItem(index, ec))
+        return ListItemType { newItem };
+    }
+
+    ExceptionOr<PtrListItemTearOff> replaceItemValuesAndWrappers(PtrListItemTearOff newItem, unsigned index)
+    {
+        ASSERT(m_wrappers);
+
+        auto result = canReplaceItem(index);
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
             return nullptr;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
-        if (!newItem) {
-            ec = SVGException::SVG_WRONG_TYPE_ERR;
-            return nullptr;
-        }
+        if (!newItem)
+            return Exception { SVGException::SVG_WRONG_TYPE_ERR };
 
         ASSERT(m_values->size() == m_wrappers->size());
@@ -320 +345 @@
         // Spec: If the item is already in this list, note that the index of the item to replace is before the removal of the item.
         if (!processIncomingListItemWrapper(newItem, &index))
-            return newItem;
+            return WTFMove(newItem);
 
         if (m_values->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.
-            ec = INDEX_SIZE_ERR;
-            return nullptr;
+            return Exception { INDEX_SIZE_ERR };
         }
 
@@ -339 +363 @@
 
         commitChange();
-        return newItem;
+        return WTFMove(newItem);
     }
 
     // SVGList::removeItem()
-    bool canRemoveItem(unsigned index, ExceptionCode& ec)
-    {
-        if (!canAlterList(ec))
+    ExceptionOr<bool> canRemoveItem(unsigned index)
+    {
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
             return false;
 
-        if (index >= m_values->size()) {
-            ec = INDEX_SIZE_ERR;
-            return false;
-        }
+        if (index >= m_values->size())
+            return Exception { INDEX_SIZE_ERR };
 
         return true;
     }
 
-    ListItemType removeItemValues(unsigned index, ExceptionCode& ec)
-    {
-        if (!canRemoveItem(index, ec))
-            return ListItemType();
+    ExceptionOr<ListItemType> removeItemValues(unsigned index)
+    {
+        auto result = canRemoveItem(index);
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
+            return ListItemType { };
 
         ListItemType oldItem = m_values->at(index);
@@ -365 +393 @@
 
         commitChange();
-        return oldItem;
-    }
-
-    PtrListItemTearOff removeItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index, ExceptionCode& ec)
-    {
-        ASSERT(m_wrappers);
-        if (!canRemoveItem(index, ec))
+        return WTFMove(oldItem);
+    }
+
+    ExceptionOr<PtrListItemTearOff> removeItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index)
+    {
+        ASSERT(m_wrappers);
+
+        auto result = canRemoveItem(index);
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
             return nullptr;
 
@@ -390 +422 @@
 
     // SVGList::appendItem()
-    ListItemType appendItemValues(const ListItemType& newItem, ExceptionCode& ec)
-    {
-        if (!canAlterList(ec))
-            return ListItemType();
+    ExceptionOr<ListItemType> appendItemValues(const ListItemType& newItem)
+    {
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
+            return ListItemType { };
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
@@ -402 +437 @@
 
         commitChange(ListModificationAppend);
-        return newItem;
-    }
-
-    PtrListItemTearOff appendItemValuesAndWrappers(PtrListItemTearOff newItem, ExceptionCode& ec)
-    {
-        ASSERT(m_wrappers);
-        if (!canAlterList(ec))
+        return ListItemType { newItem };
+    }
+
+    ExceptionOr<PtrListItemTearOff> appendItemValuesAndWrappers(PtrListItemTearOff newItem)
+    {
+        ASSERT(m_wrappers);
+
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
             return nullptr;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
-        if (!newItem) {
-            ec = SVGException::SVG_WRONG_TYPE_ERR;
-            return nullptr;
-        }
+        if (!newItem)
+            return Exception { SVGException::SVG_WRONG_TYPE_ERR };
 
         ASSERT(m_values->size() == m_wrappers->size());
@@ -427 +464 @@
 
         commitChange(ListModificationAppend);
-        return newItem;
+        return WTFMove(newItem);
     }
 
@@ -473 +510 @@
 
 }
-
-#endif // SVGListProperty_h

trunk/Source/WebCore/svg/properties/SVGListPropertyTearOff.h

@@ -18 +18 @@
  */
 
-#ifndef SVGListPropertyTearOff_h
-#define SVGListPropertyTearOff_h
+#pragma once
 
 #include "SVGListProperty.h"
@@ -79 +78 @@
 
     // SVGList API
-    void clear(ExceptionCode& ec)
-    {
-        Base::clearValuesAndWrappers(ec);
-    }
-
-    PtrListItemTearOff initialize(PtrListItemTearOff newItem, ExceptionCode& ec)
-    {
-        return Base::initializeValuesAndWrappers(newItem, ec);
-    }
-
-    PtrListItemTearOff getItem(unsigned index, ExceptionCode& ec)
-    {
-        return Base::getItemValuesAndWrappers(m_animatedProperty.get(), index, ec);
-    }
-
-    PtrListItemTearOff insertItemBefore(PtrListItemTearOff newItem, unsigned index, ExceptionCode& ec)
-    {
-        return Base::insertItemBeforeValuesAndWrappers(newItem, index, ec);
-    }
-
-    PtrListItemTearOff replaceItem(PtrListItemTearOff newItem, unsigned index, ExceptionCode& ec)
-    {
-        return Base::replaceItemValuesAndWrappers(newItem, index, ec);
-    }
-
-    PtrListItemTearOff removeItem(unsigned index, ExceptionCode& ec)
-    {
-        return Base::removeItemValuesAndWrappers(m_animatedProperty.get(), index, ec);
-    }
-
-    PtrListItemTearOff appendItem(PtrListItemTearOff newItem, ExceptionCode& ec)
-    {
-        return Base::appendItemValuesAndWrappers(newItem, ec);
+    ExceptionOr<void> clear()
+    {
+        return Base::clearValuesAndWrappers();
+    }
+
+    ExceptionOr<PtrListItemTearOff> initialize(PtrListItemTearOff newItem)
+    {
+        return Base::initializeValuesAndWrappers(newItem);
+    }
+
+    ExceptionOr<PtrListItemTearOff> getItem(unsigned index)
+    {
+        return Base::getItemValuesAndWrappers(m_animatedProperty.get(), index);
+    }
+
+    ExceptionOr<PtrListItemTearOff> insertItemBefore(PtrListItemTearOff newItem, unsigned index)
+    {
+        return Base::insertItemBeforeValuesAndWrappers(newItem, index);
+    }
+
+    ExceptionOr<PtrListItemTearOff> replaceItem(PtrListItemTearOff newItem, unsigned index)
+    {
+        return Base::replaceItemValuesAndWrappers(newItem, index);
+    }
+
+    ExceptionOr<PtrListItemTearOff> removeItem(unsigned index)
+    {
+        return Base::removeItemValuesAndWrappers(m_animatedProperty.get(), index);
+    }
+
+    ExceptionOr<PtrListItemTearOff> appendItem(PtrListItemTearOff newItem)
+    {
+        return Base::appendItemValuesAndWrappers(newItem);
     }
 
@@ -215 +214 @@
 
 }
-
-#endif // SVGListPropertyTearOff_h

trunk/Source/WebCore/svg/properties/SVGPathSegListPropertyTearOff.cpp

@@ -36 +36 @@
 }
 
-void SVGPathSegListPropertyTearOff::clear(ExceptionCode& ec)
+ExceptionOr<void> SVGPathSegListPropertyTearOff::clear()
 {
     ASSERT(m_values);
     if (m_values->isEmpty())
-        return;
+        return { };
 
     clearContextAndRoles();
-    SVGPathSegListPropertyTearOff::Base::clearValues(ec);
+    return SVGPathSegListPropertyTearOff::Base::clearValues();
 }
 
-SVGPathSegListPropertyTearOff::PtrListItemType SVGPathSegListPropertyTearOff::getItem(unsigned index, ExceptionCode& ec)
+ExceptionOr<SVGPathSegListPropertyTearOff::PtrListItemType> SVGPathSegListPropertyTearOff::getItem(unsigned index)
 {
-    ListItemType returnedItem = Base::getItemValues(index, ec);
-    if (returnedItem) {
-        ASSERT(static_cast<SVGPathSegWithContext*>(returnedItem.get())->contextElement() == contextElement());
-        ASSERT(static_cast<SVGPathSegWithContext*>(returnedItem.get())->role() == m_pathSegRole);
-    }
-    return returnedItem;
+    return Base::getItemValues(index);
 }
 
-SVGPathSegListPropertyTearOff::PtrListItemType SVGPathSegListPropertyTearOff::replaceItem(PtrListItemType newItem, unsigned index, ExceptionCode& ec)
+ExceptionOr<SVGPathSegListPropertyTearOff::PtrListItemType> SVGPathSegListPropertyTearOff::replaceItem(PtrListItemType newItem, unsigned index)
 {
     // Not specified, but FF/Opera do it this way, and it's just sane.
-    if (!newItem) {
-        ec = SVGException::SVG_WRONG_TYPE_ERR;
-        return 0;
-    }
+    if (!newItem)
+        return Exception { SVGException::SVG_WRONG_TYPE_ERR };
 
     if (index < m_values->size()) {
@@ -70 +63 @@
     }
 
-    return Base::replaceItemValues(newItem, index, ec);
+    return Base::replaceItemValues(newItem, index);
 }
 
-SVGPathSegListPropertyTearOff::PtrListItemType SVGPathSegListPropertyTearOff::removeItem(unsigned index, ExceptionCode& ec)
+ExceptionOr<SVGPathSegListPropertyTearOff::PtrListItemType> SVGPathSegListPropertyTearOff::removeItem(unsigned index)
 {
-    SVGPathSegListPropertyTearOff::ListItemType removedItem = SVGPathSegListPropertyTearOff::Base::removeItemValues(index, ec);
+    auto result = SVGPathSegListPropertyTearOff::Base::removeItemValues(index);
+    if (result.hasException())
+        return result;
+    auto removedItem = result.releaseReturnValue();
     if (removedItem)
-        static_cast<SVGPathSegWithContext*>(removedItem.get())->setContextAndRole(nullptr, PathSegUndefinedRole);
-    return removedItem;
+        static_cast<SVGPathSegWithContext&>(*removedItem).setContextAndRole(nullptr, PathSegUndefinedRole);
+    return WTFMove(removedItem);
 }
 

trunk/Source/WebCore/svg/properties/SVGPathSegListPropertyTearOff.h

@@ -18 +18 @@
  */
 
-#ifndef SVGPathSegListPropertyTearOff_h
-#define SVGPathSegListPropertyTearOff_h
+#pragma once
 
 #include "SVGAnimatedListPropertyTearOff.h"
@@ -30 +29 @@
 class SVGPathSegListPropertyTearOff final : public SVGListProperty<SVGPathSegList> {
 public:
-    typedef SVGListProperty<SVGPathSegList> Base;
-    typedef SVGAnimatedListPropertyTearOff<SVGPathSegList> AnimatedListPropertyTearOff;
-    typedef SVGPropertyTraits<SVGPathSegList>::ListItemType ListItemType;
-    typedef RefPtr<SVGPathSeg> PtrListItemType;
+    using Base = SVGListProperty<SVGPathSegList>;
+    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<SVGPathSegList>;
+    using ListItemType = SVGPropertyTraits<SVGPathSegList>::ListItemType;
+    using PtrListItemType = RefPtr<SVGPathSeg>;
 
     static Ref<SVGPathSegListPropertyTearOff> create(AnimatedListPropertyTearOff* animatedProperty, SVGPropertyRole role, SVGPathSegRole pathSegRole, SVGPathSegList& values, ListWrapperCache& wrappers)
@@ -66 +65 @@
 
     // SVGList API
-    void clear(ExceptionCode&);
+    ExceptionOr<void> clear();
 
-    PtrListItemType initialize(PtrListItemType newItem, ExceptionCode& ec)
+    ExceptionOr<PtrListItemType> initialize(PtrListItemType newItem)
     {
         // Not specified, but FF/Opera do it this way, and it's just sane.
-        if (!newItem) {
-            ec = SVGException::SVG_WRONG_TYPE_ERR;
-            return nullptr;
-        }
+        if (!newItem)
+            return Exception { SVGException::SVG_WRONG_TYPE_ERR };
 
         clearContextAndRoles();
-        return Base::initializeValues(newItem, ec);
+        return Base::initializeValues(newItem);
     }
 
-    PtrListItemType getItem(unsigned index, ExceptionCode&);
+    ExceptionOr<PtrListItemType> getItem(unsigned index);
 
-    PtrListItemType insertItemBefore(PtrListItemType newItem, unsigned index, ExceptionCode& ec)
+    ExceptionOr<PtrListItemType> insertItemBefore(PtrListItemType newItem, unsigned index)
     {
         // Not specified, but FF/Opera do it this way, and it's just sane.
-        if (!newItem) {
-            ec = SVGException::SVG_WRONG_TYPE_ERR;
-            return 0;
-        }
+        if (!newItem)
+            return Exception { SVGException::SVG_WRONG_TYPE_ERR };
 
-        return Base::insertItemBeforeValues(newItem, index, ec);
+        return Base::insertItemBeforeValues(newItem, index);
     }
 
-    PtrListItemType replaceItem(PtrListItemType, unsigned index, ExceptionCode&);
+    ExceptionOr<PtrListItemType> replaceItem(PtrListItemType, unsigned index);
 
-    PtrListItemType removeItem(unsigned index, ExceptionCode&);
+    ExceptionOr<PtrListItemType> removeItem(unsigned index);
 
-    PtrListItemType appendItem(PtrListItemType newItem, ExceptionCode& ec)
+    ExceptionOr<PtrListItemType> appendItem(PtrListItemType newItem)
     {
         // Not specified, but FF/Opera do it this way, and it's just sane.
-        if (!newItem) {
-            ec = SVGException::SVG_WRONG_TYPE_ERR;
-            return nullptr;
-        }
+        if (!newItem)
+            return Exception { SVGException::SVG_WRONG_TYPE_ERR };
 
-        return Base::appendItemValues(newItem, ec);
+        return Base::appendItemValues(newItem);
     }
 
@@ -162 +155 @@
 
 }
-
-#endif // SVGListPropertyTearOff_h

trunk/Source/WebCore/svg/properties/SVGPropertyTearOff.h

@@ -19 +19 @@
  */
 
-#ifndef SVGPropertyTearOff_h
-#define SVGPropertyTearOff_h
+#pragma once
 
 #include "SVGAnimatedProperty.h"
@@ -56 +55 @@
     {
         return adoptRef(*new Self(initialValue));
+    }
+
+    template<typename T> static ExceptionOr<Ref<Self>> create(ExceptionOr<T>&& initialValue)
+    {
+        if (initialValue.hasException())
+            return initialValue.releaseException();
+        return create(initialValue.releaseReturnValue());
     }
 
@@ -173 +179 @@
 
 }
-
-#endif // SVGPropertyTearOff_h

trunk/Source/WebCore/svg/properties/SVGStaticListPropertyTearOff.h

@@ -18 +18 @@
  */
 
-#ifndef SVGStaticListPropertyTearOff_h
-#define SVGStaticListPropertyTearOff_h
+#pragma once
 
 #include "SVGListProperty.h"
@@ -25 +24 @@
 namespace WebCore {
 
-template<typename PropertyType>
-class SVGStaticListPropertyTearOff final : public SVGListProperty<PropertyType> {
+template<typename PropertyType> class SVGStaticListPropertyTearOff final : public SVGListProperty<PropertyType> {
 public:
-    typedef SVGListProperty<PropertyType> Base;
-
-    typedef typename SVGPropertyTraits<PropertyType>::ListItemType ListItemType;
-    typedef SVGPropertyTearOff<ListItemType> ListItemTearOff;
+    using Base = SVGListProperty<PropertyType>;
+    using ListItemType = typename SVGPropertyTraits<PropertyType>::ListItemType;
+    using ListItemTearOff = SVGPropertyTearOff<ListItemType>;
 
     using Base::m_role;
@@ -38 +35 @@
     static Ref<SVGStaticListPropertyTearOff<PropertyType>> create(SVGElement& contextElement, PropertyType& values)
     {
-        return adoptRef(*new SVGStaticListPropertyTearOff<PropertyType>(&contextElement, values));
+        return adoptRef(*new SVGStaticListPropertyTearOff(contextElement, values));
     }
 
-    // SVGList API
-    void clear(ExceptionCode& ec)
+    ExceptionOr<void> clear()
     {
-        Base::clearValues(ec);
+        return Base::clearValues();
     }
 
-    ListItemType initialize(const ListItemType& newItem, ExceptionCode& ec)
+    ExceptionOr<ListItemType> initialize(const ListItemType& newItem)
     {
-        return Base::initializeValues(newItem, ec);
+        return Base::initializeValues(newItem);
     }
 
-    ListItemType getItem(unsigned index, ExceptionCode& ec)
+    ExceptionOr<ListItemType> getItem(unsigned index)
     {
-        return Base::getItemValues(index, ec);
+        return Base::getItemValues(index);
     }
 
-    ListItemType insertItemBefore(const ListItemType& newItem, unsigned index, ExceptionCode& ec)
+    ExceptionOr<ListItemType> insertItemBefore(const ListItemType& newItem, unsigned index)
     {
-        return Base::insertItemBeforeValues(newItem, index, ec);
+        return Base::insertItemBeforeValues(newItem, index);
     }
 
-    ListItemType replaceItem(const ListItemType& newItem, unsigned index, ExceptionCode& ec)
+    ExceptionOr<ListItemType> replaceItem(const ListItemType& newItem, unsigned index)
     {
-        return Base::replaceItemValues(newItem, index, ec);
+        return Base::replaceItemValues(newItem, index);
     }
 
-    ListItemType removeItem(unsigned index, ExceptionCode& ec)
+    ExceptionOr<ListItemType> removeItem(unsigned index)
     {
-        return Base::removeItemValues(index, ec);
+        return Base::removeItemValues(index);
     }
 
-    ListItemType appendItem(const ListItemType& newItem, ExceptionCode& ec)
+    ExceptionOr<ListItemType> appendItem(const ListItemType& newItem)
     {
-        return Base::appendItemValues(newItem, ec);
+        return Base::appendItemValues(newItem);
     }
 
 private:
-    SVGStaticListPropertyTearOff(SVGElement* contextElement, PropertyType& values)
-        : SVGListProperty<PropertyType>(UndefinedRole, values, 0)
+    SVGStaticListPropertyTearOff(SVGElement& contextElement, PropertyType& values)
+        : SVGListProperty<PropertyType>(UndefinedRole, values, nullptr)
         , m_contextElement(contextElement)
     {
@@ -92 +88 @@
     {
         ASSERT(m_values);
-        m_values->commitChange(m_contextElement.get());
+        m_values->commitChange(m_contextElement.ptr());
     }
 
@@ -107 +103 @@
     }
 
-private:
-    RefPtr<SVGElement> m_contextElement;
+    Ref<SVGElement> m_contextElement;
 };
 
 }
-
-#endif // SVGStaticListPropertyTearOff_h

trunk/Source/WebCore/svg/properties/SVGTransformListPropertyTearOff.h

@@ -18 +18 @@
  */
 
-#ifndef SVGTransformListPropertyTearOff_h
-#define SVGTransformListPropertyTearOff_h
+#pragma once
 
 #include "SVGListPropertyTearOff.h"
@@ -26 +25 @@
 namespace WebCore {
 
-// SVGTransformList contains two additional methods, that can be exposed to the bindings.
 class SVGTransformListPropertyTearOff final : public SVGListPropertyTearOff<SVGTransformList> {
 public:
-    typedef SVGAnimatedListPropertyTearOff<SVGTransformList> AnimatedListPropertyTearOff;
-    typedef SVGAnimatedListPropertyTearOff<SVGTransformList>::ListWrapperCache ListWrapperCache;
+    using AnimatedListPropertyTearOff = SVGAnimatedListPropertyTearOff<SVGTransformList>;
+    using ListWrapperCache = AnimatedListPropertyTearOff::ListWrapperCache;
 
     static Ref<SVGListPropertyTearOff<SVGTransformList>> create(AnimatedListPropertyTearOff* animatedProperty, SVGPropertyRole role, SVGTransformList& values, ListWrapperCache& wrappers)
@@ -38 +36 @@
     }
 
-    RefPtr<SVGPropertyTearOff<SVGTransform>> createSVGTransformFromMatrix(SVGPropertyTearOff<SVGMatrix>* matrix, ExceptionCode& ec)
+    ExceptionOr<Ref<SVGPropertyTearOff<SVGTransform>>> createSVGTransformFromMatrix(SVGPropertyTearOff<SVGMatrix>* matrix)
     {
         ASSERT(m_values);
-        if (!matrix) {
-            ec = TYPE_MISMATCH_ERR;
-            return nullptr;
-        }
+        if (!matrix)
+            return Exception { TYPE_MISMATCH_ERR };
         return SVGPropertyTearOff<SVGTransform>::create(m_values->createSVGTransformFromMatrix(matrix->propertyReference()));
     }
 
-    RefPtr<SVGPropertyTearOff<SVGTransform>> consolidate(ExceptionCode& ec)
+    ExceptionOr<RefPtr<SVGPropertyTearOff<SVGTransform>>> consolidate()
     {
         ASSERT(m_values);
         ASSERT(m_wrappers);
-        if (!canAlterList(ec))
+
+        auto result = canAlterList();
+        if (result.hasException())
+            return result.releaseException();
+        if (!result.releaseReturnValue())
             return nullptr;
 
@@ -66 +66 @@
 
         ASSERT(m_values->size() == m_wrappers->size());
-        return wrapper;
+        return WTFMove(wrapper);
     }
 
@@ -77 +77 @@
 
 }
-
-#endif // SVGListPropertyTearOff_h