Move CSS classes from ExceptionCode to Exception
authordarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 17 Oct 2016 00:16:05 +0000 (00:16 +0000)
committerdarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 17 Oct 2016 00:16:05 +0000 (00:16 +0000)
https://bugs.webkit.org/show_bug.cgi?id=163494

Reviewed by Sam Weinig.

Source/WebCore:

Removed the "get" prefix from the names of many CSSPrimitiveValue
functions to match WebKit coding style and to disambiguate them
from the public CSS DOM functions that raise exceptions.

* bindings/js/JSCSSStyleDeclarationCustom.cpp:
(WebCore::propertyNamePrefix): Use enum class.
(WebCore::parseJavaScriptCSSPropertyName): Tweak style a bit.
(WebCore::stylePropertyGetter): Refactor to simplify structure.
(WebCore::stylePropertyGetterPixelOrPosPrefix): Ditto. Also use floatValue.
(WebCore::JSCSSStyleDeclaration::putDelegate): Use findIgnoringASCIICase,
and use propagateException to handle ExcpetionOr.
(WebCore::JSCSSStyleDeclaration::getPropertyCSSValue): Tweak style a bit.
(WebCore::JSCSSStyleDeclaration::getOwnPropertyNames): Use a lambda to
initialize a global here.

* bindings/js/JSDOMBinding.h: Added toJSString to support bindings for
functions returning ExceptionOr<String>.

* bindings/scripts/gobject-generate-headers.pl: Deleted.

* css/BasicShapeFunctions.cpp:
(WebCore::convertToLengthSize): Use pairValue.
(WebCore::convertToCenterCoordinate): Use valueID and pairValue.
(WebCore::cssValueToBasicShapeRadius): Ditto.
* css/CSSBasicShapes.cpp:
(WebCore::serializePositionOffset): Ditto.
(WebCore::buildSerializablePositionOffset): Ditto.
(WebCore::CSSBasicShapeCircle::cssText): Ditto.
(WebCore::CSSBasicShapeEllipse::cssText): Ditto.
(WebCore::updateCornerRadiusWidthAndHeight): Ditto.
* css/CSSBorderImageSliceValue.h: Use quadValue.
* css/CSSCalculationValue.cpp:
(WebCore::determineCategory): Use floatValue and doubleValue.

* css/CSSCharsetRule.h: Use ExceptionOr. Also made more things private.
* css/CSSCharsetRule.idl: Use non-legacy exceptions.

* css/CSSComputedStyleDeclaration.cpp:
(WebCore::CSSComputedStyleDeclaration::setCssText): Use ExceptionOr.
(WebCore::ComputedStyleExtractor::propertyMatches): Use valueID.
(WebCore::CSSComputedStyleDeclaration::setProperty): Use ExceptionOr.
(WebCore::CSSComputedStyleDeclaration::removeProperty): Ditto.
(WebCore::CSSComputedStyleDeclaration::setPropertyInternal): Ditto.
(WebCore::ComputedStyleExtractor::getBackgroundShorthandValue): Return
a Ref instead of a RefPtr.
* css/CSSComputedStyleDeclaration.h: Updated for above changes.

* css/CSSCrossfadeValue.cpp:
(WebCore::CSSCrossfadeValue::fixedSize): Use floatValue.
(WebCore::CSSCrossfadeValue::image): Ditto.
(WebCore::CSSCrossfadeValue::blend): Use doubleValue.

* css/CSSFontFace.cpp:
(WebCore::CSSFontFace::calculateStyleMask): Use valueID.
(WebCore::CSSFontFace::calculateWeightMask): Ditto.
* css/CSSFontFaceSet.cpp:
(WebCore::CSSFontFaceSet::familyNameFromPrimitive): Ditto.
(WebCore::CSSFontFaceSet::matchingFaces): Use ExceptoinOr.
(WebCore::CSSFontFaceSet::check): Ditto.
* css/CSSFontFaceSet.h: Updated for above changes.

* css/CSSGradientValue.cpp:
(WebCore::compareStops): Use doubleValue.
(WebCore::CSSGradientValue::addStops): Use floatValue.
(WebCore::positionFromValue): Use floatValue and valudID.
(WebCore::CSSLinearGradientValue::customCSSText): Use doubleValue and valueID.
(WebCore::CSSLinearGradientValue::createGradient): Use floatValue and valueID.
(WebCore::CSSRadialGradientValue::customCSSText): Use doubleValue and valueID.
(WebCore::CSSRadialGradientValue::resolveRadius): Use floatValue.
(WebCore::CSSRadialGradientValue::createGradient): Use valueID.

* css/CSSGroupingRule.cpp:
(WebCore::CSSGroupingRule::insertRule): Use ExceptionOr.
(WebCore::CSSGroupingRule::deleteRule): Ditto.
* css/CSSGroupingRule.h: Updated for above changes.

* css/CSSImageGeneratorValue.cpp:
(WebCore::CSSImageGeneratorValue::subimageIsPending): Use valueID.
(WebCore::CSSImageGeneratorValue::cachedImageForCSSValue): Ditto.

* css/CSSImageSetValue.cpp:
(WebCore::CSSImageSetValue::fillImageSet): Use floatValue.

* css/CSSMediaRule.idl: Use non-legacy exceptions.

* css/CSSPrimitiveValue.cpp:
(WebCore::CSSPrimitiveValue::computeDegrees): Use doubleValue.
(WebCore::CSSPrimitiveValue::setFloatValue): Use ExceptionOr.
(WebCore::CSSPrimitiveValue::getFloatValue): Replaced getDoubleValue with this,
since getDoubleValue is unused, moving the call to clampTo into this function.
Also changed this to use ExceptionOr.
(WebCore::CSSPrimitiveValue::doubleValue): Renamed from getDoubleValue.
(WebCore::CSSPrimitiveValue::doubleValueInternal): Use Optional instead of a bool
and an out argument to return the value and check for type failure.
(WebCore::CSSPrimitiveValue::setStringValue): Use ExceptionOr.
(WebCore::CSSPrimitiveValue::getStringValue): Ditto.
(WebCore::CSSPrimitiveValue::stringValue): Renamed from getStringValue.
(WebCore::CSSPrimitiveValue::getCounterValue): Use ExceptionOr.
(WebCore::CSSPrimitiveValue::getRectValue): Use ExceptionOr.
(WebCore::CSSPrimitiveValue::getQuadValue): Deleted.
(WebCore::CSSPrimitiveValue::getLengthRepeatValue): Deleted.
(WebCore::CSSPrimitiveValue::getRGBColorValue): Use ExceptionOr.
(WebCore::CSSPrimitiveValue::getPairValue): Deleted.
(WebCore::CSSPrimitiveValue::formatNumberForCustomCSSText): Use new names for functions.
* css/CSSPrimitiveValue.h: Reorganized the class, moved large inline function bodies
out of the class definition. Updated for the above changes.
* css/CSSPrimitiveValue.idl: Use non-legacy exceptions.

* css/CSSPrimitiveValueMappings.h: Use value instead of getValue, etc.

* css/CSSRule.cpp:
(WebCore::CSSRule::setCssText): Use ExceptionOr.
* css/CSSRule.h: Updated for above change.
* css/CSSRule.idl: Use non-legacy exceptions.

* css/CSSStyleDeclaration.h: Use ExceptionOr.
* css/CSSStyleDeclaration.idl: Use non-legacy exceptions.

* css/CSSStyleSheet.cpp:
(WebCore::CSSStyleSheet::deprecatedInsertRule): Use ExceptionOr.
(WebCore::CSSStyleSheet::insertRule): Ditto.
(WebCore::CSSStyleSheet::deleteRule): Ditto.
(WebCore::CSSStyleSheet::addRule): Ditto.
* css/CSSStyleSheet.h: Updated for the above changes.
* css/CSSStyleSheet.idl: Use non-legacy exceptions.

* css/CSSSupportsRule.idl: Use non-legacy exceptions.

* css/CSSToStyleMap.cpp:
(WebCore::CSSToStyleMap::mapFillAttachment): Use valueID instead of getValueID, etc.
(WebCore::convertToLengthSize): Ditto.
(WebCore::CSSToStyleMap::mapFillSize): Ditto.
(WebCore::CSSToStyleMap::mapFillXPosition): Ditto.
(WebCore::CSSToStyleMap::mapFillYPosition): Ditto.
(WebCore::CSSToStyleMap::mapFillMaskSourceType): Ditto.
(WebCore::CSSToStyleMap::mapAnimationDirection): Ditto.
(WebCore::CSSToStyleMap::mapAnimationFillMode): Ditto.
(WebCore::CSSToStyleMap::mapAnimationIterationCount): Ditto.
(WebCore::CSSToStyleMap::mapAnimationName): Ditto.
(WebCore::CSSToStyleMap::mapAnimationPlayState): Ditto.
(WebCore::CSSToStyleMap::mapAnimationProperty): Ditto.
(WebCore::CSSToStyleMap::mapAnimationTimingFunction): Ditto.
(WebCore::CSSToStyleMap::mapAnimationTrigger): Ditto.
(WebCore::CSSToStyleMap::mapNinePieceImageSlice): Ditto.
(WebCore::CSSToStyleMap::mapNinePieceImageQuad): Ditto.
(WebCore::CSSToStyleMap::mapNinePieceImageRepeat): Ditto.

* css/CSSValue.h: Use ExceptionOr.
* css/CSSValue.idl: Use non-legacy exceptions.

* css/Counter.h: Use stringValue instead of getStringValue, etc.

* css/FontFace.cpp:
(WebCore::FontFace::create): Use ExceptionOr.
(WebCore::FontFace::setFamily): Ditto.
(WebCore::FontFace::setStyle): Ditto.
(WebCore::FontFace::setWeight): Ditto.
(WebCore::FontFace::setStretch): Ditto.
(WebCore::FontFace::setUnicodeRange): Ditto.
(WebCore::FontFace::setVariant): Ditto.
(WebCore::FontFace::setFeatureSettings): Ditto.
* css/FontFace.h: Updated for above changes.
* css/FontFace.idl: Use non-legacy exceptions.

* css/FontFaceSet.cpp:
(WebCore::FontFaceSet::load): Use ExceptionOr.
(WebCore::FontFaceSet::check): Ditto.
* css/FontFaceSet.h: Updated for above changes.
* css/FontFaceSet.idl: Use non-legacy exceptions.

* css/FontVariantBuilder.cpp:
(WebCore::extractFontVariantLigatures): Use valueID instead of getValueID, etc.
(WebCore::extractFontVariantNumeric): Ditto.
(WebCore::extractFontVariantEastAsian): Ditto.

* css/MediaList.cpp:
(WebCore::MediaList::setMediaText): Use ExceptionOr.
(WebCore::MediaList::deleteMedium): Ditto.
(WebCore::MediaList::appendMedium): Ditto.
* css/MediaList.h: Updated for above changes.
* css/MediaList.idl: Use non-legacy exceptions.

* css/MediaQueryEvaluator.cpp:
(WebCore::doubleValue): Use valueID instead of getValueID, etc.
(WebCore::colorGamutEvaluate): Ditto.
(WebCore::invertedColorsEvaluate): Ditto.
(WebCore::orientationEvaluate): Ditto.
(WebCore::evaluateResolution): Ditto.
(WebCore::computeLength): Ditto.
(WebCore::viewModeEvaluate): Ditto.
(WebCore::hoverEvaluate): Ditto.
(WebCore::pointerEvaluate): Ditto.
(WebCore::prefersReducedMotionEvaluate): Ditto.

* css/PropertySetCSSStyleDeclaration.cpp:
(WebCore::PropertySetCSSStyleDeclaration::setCssText): Use ExceptionOr.
(WebCore::PropertySetCSSStyleDeclaration::setProperty): Ditto.
(WebCore::PropertySetCSSStyleDeclaration::removeProperty): Ditto.
(WebCore::PropertySetCSSStyleDeclaration::getPropertyCSSValueInternal): Ditto.
(WebCore::PropertySetCSSStyleDeclaration::setPropertyInternal): Ditto.
* css/PropertySetCSSStyleDeclaration.h: Updated for above changes.
Also marked a couple additional functions private.

* css/StyleBuilderConverter.h: Use doubleValue instead of getDoubleValue, etc.
* css/StyleBuilderCustom.h: Ditto.
* css/StyleProperties.cpp:
(WebCore::StyleProperties::getLayeredShorthandValue): Ditto.
* css/StyleResolver.cpp:
(WebCore::StyleResolver::MatchResult::addMatchedProperties): Ditto.
(WebCore::StyleResolver::colorFromPrimitiveValueIsDerivedFromElement): Ditto.
(WebCore::StyleResolver::colorFromPrimitiveValue): Ditto.
(WebCore::StyleResolver::createFilterOperations): Ditto.
* css/TransformFunctions.cpp:
(WebCore::transformsForValue): Ditto.
* css/ViewportStyleResolver.cpp:
(WebCore::ViewportStyleResolver::getViewportArgumentValue): Ditto.

* css/WebKitCSSMatrix.cpp:
(WebCore::WebKitCSSMatrix::WebKitCSSMatrix): Tweaked constructors a bit,
getting rid of the one that uses an ExceptionCode.
(WebCore::WebKitCSSMatrix::create): Moved in here, and use ExceptionOr.
(WebCore::WebKitCSSMatrix::setMatrixValue): Use ExceptionOr.
(WebCore::WebKitCSSMatrix::multiply): Tweak coding style a bit.
(WebCore::WebKitCSSMatrix::inverse): Use ExceptionOr.
(WebCore::WebKitCSSMatrix::translate): Return a Ref instead of RefPtr.
(WebCore::WebKitCSSMatrix::scale): Ditto.
(WebCore::WebKitCSSMatrix::rotate): Ditto.
(WebCore::WebKitCSSMatrix::rotateAxisAngle): Ditto.
(WebCore::WebKitCSSMatrix::skewX): Ditto.
(WebCore::WebKitCSSMatrix::skewY): Ditto.
(WebCore::WebKitCSSMatrix::toString): Tweaked formatting a bit.
* css/WebKitCSSMatrix.h: Updated for above changes.
* css/WebKitCSSMatrix.idl: Use non-legacy extensions.

* css/makeprop.pl:
(handleCurrentColorValue): Use valueID instead of getValueID.
(generateValueSetter): Ditto.

* css/parser/CSSParser.cpp:
(WebCore::CSSParser::parse4ValuesFillPosition): Use valueID instead of getValueID, etc.
(WebCore::CSSParser::parse3ValuesFillPosition): Ditto.
(WebCore::CSSParser::parseFillPosition): Ditto.
(WebCore::CSSParser::parseFillRepeat): Ditto.
(WebCore::CSSParser::parseGridPosition): Ditto.
(WebCore::CSSParser::parseGridTemplateRowsAndAreasAndColumns): Ditto.
(WebCore::isGridTrackFixedSized): Ditto.
(WebCore::CSSParser::parseRadialGradient): Ditto.
(WebCore::CSSParser::parseBuiltinFilterArguments): Ditto.

* css/parser/CSSParserValues.cpp:
(WebCore::CSSParserValue::createCSSValue): Removed the unneeded call to
setPrimitiveType here. The createParserOperator returns an object that
already has the correct primitive type.

* css/parser/CSSPropertyParser.cpp: Updated most cases of calling the old
getXXXValue functions, but not sure if it's right since it is commented out
code that I did not compile.

* css/parser/CSSPropertyParserHelpers.cpp:
(WebCore::CSSPropertyParserHelpers::clampRGBComponent): Use intValue instead of getIntValue, etc.
(WebCore::CSSPropertyParserHelpers::parseHSLParameters): Ditto.
(WebCore::CSSPropertyParserHelpers::isHorizontalPositionKeywordOnly): Ditto.
(WebCore::CSSPropertyParserHelpers::isVerticalPositionKeywordOnly): Ditto.
(WebCore::CSSPropertyParserHelpers::positionFromThreeOrFourValues): Ditto.
(WebCore::CSSPropertyParserHelpers::consumeRadialGradient): Ditto.

* dom/Range.cpp: Added now-needed include of ExceptionCode.h.
* dom/SelectorQuery.cpp: Ditto.

* editing/ApplyStyleCommand.cpp:
(WebCore::toIdentifier): Use valueID instead of getValueID, etc.
(WebCore::ApplyStyleCommand::computedFontSize): Ditto.
* editing/EditingStyle.cpp:
(WebCore::identifierForStyleProperty): Ditto.
(WebCore::HTMLElementEquivalent::valueIsPresentInStyle): Ditto.
(WebCore::EditingStyle::extractFontSizeDelta): Ditto.
(WebCore::EditingStyle::textDirection): Ditto.
(WebCore::EditingStyle::prepareToApplyAt): Ditto.
(WebCore::EditingStyle::textDirectionForSelection): Ditto.
(WebCore::fontWeightIsBold): Ditto.
(WebCore::legacyFontSizeFromCSSValue): Ditto.
(WebCore::isTransparentColorValue): Ditto.
(WebCore::hasTransparentBackgroundColor): Ditto.
(WebCore::backgroundColorInEffect): Ditto.

* editing/Editor.cpp:
(WebCore::Editor::applyEditingStyleToElement): Removed IGNORE_EXCEPTION; that is
what we do by default for things returning ExceptionOr.
* editing/RemoveCSSPropertyCommand.cpp:
(WebCore::RemoveCSSPropertyCommand::doApply): Ditto.
(WebCore::RemoveCSSPropertyCommand::doUnapply): Ditto.
* editing/ReplaceSelectionCommand.cpp:
(WebCore::ReplaceSelectionCommand::removeRedundantStylesAndKeepStyleSpanInline): Ditto.

* editing/cocoa/HTMLConverter.mm:
(floatValueFromPrimitiveValue): Use floatValue instead of getFloatValue, etc.
* editing/markup.cpp:
(WebCore::propertyMissingOrEqualToNone): Ditto.

* inspector/InspectorStyleSheet.cpp:
(WebCore::InspectorStyleSheet::addRule): Updated to call ExceptionOr-returning functions.
(WebCore::InspectorStyleSheet::deleteRule): Ditto.
(WebCore::InspectorStyleSheet::setStyleText): Ditto.

* svg/SVGLength.cpp:
(WebCore::SVGLength::fromCSSPrimitiveValue): Use floatValue instead of getFloatValue.

Source/WebKit/mac:

* DOM/DOMCSSMediaRule.mm:
(-[DOMCSSMediaRule insertRule:index:]): Use raiseOnDOMError
the new way to handle ExceptionOr instead of ExceptionCode.
(-[DOMCSSMediaRule deleteRule:]): Ditto.
* DOM/DOMCSSPrimitiveValue.mm:
(-[DOMCSSPrimitiveValue setFloatValue:floatValue:]): Ditto.
(-[DOMCSSPrimitiveValue getFloatValue:]): Ditto.
(-[DOMCSSPrimitiveValue setStringValue:stringValue:]): Ditto.
(-[DOMCSSPrimitiveValue getStringValue]): Ditto.
(-[DOMCSSPrimitiveValue getCounterValue]): Ditto.
(-[DOMCSSPrimitiveValue getRectValue]): Ditto.
(-[DOMCSSPrimitiveValue getRGBColorValue]): Ditto.
* DOM/DOMCSSRule.mm:
(-[DOMCSSRule setCssText:]): Ditto.
* DOM/DOMCSSStyleDeclaration.mm:
(-[DOMCSSStyleDeclaration setCssText:]): Ditto.
(-[DOMCSSStyleDeclaration removeProperty:]): Ditto.
(-[DOMCSSStyleDeclaration setProperty:value:priority:]): Ditto.
* DOM/DOMCSSStyleSheet.mm:
(-[DOMCSSStyleSheet insertRule:index:]): Ditto.
(-[DOMCSSStyleSheet deleteRule:]): Ditto.
(-[DOMCSSStyleSheet addRule:style:index:]): Ditto.
(-[DOMCSSStyleSheet removeRule:]): Ditto.
* DOM/DOMCSSValue.mm:
(-[DOMCSSValue setCssText:]): Ditto.
* DOM/DOMMediaList.mm:
(-[DOMMediaList setMediaText:]): Ditto.
(-[DOMMediaList deleteMedium:]): Ditto.
(-[DOMMediaList appendMedium:]): Ditto.

* DOM/ExceptionHandlers.h: Added an overload of raiseDOMException
that works with a WebCore::Exception&& and overloads of
raiseOnDOMError that work with WebCore::ExceptionOr&&.
* DOM/ExceptionHandlers.mm:
(raiseDOMException): Implemented the new version.

Source/WebKit/win:

* DOMCSSClasses.cpp:
(DOMCSSStyleDeclaration::setCssText): Remove ExceptionCode handling.
(DOMCSSStyleDeclaration::setProperty): Ditto.

Source/WebKit2:

* WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMCSSRule.cpp:
(webkit_dom_css_rule_set_css_text): Updated for ExceptionOr.
* WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMCSSStyleDeclaration.cpp:
(webkit_dom_css_style_declaration_remove_property): Ditto.
(webkit_dom_css_style_declaration_set_property): Ditto.
(webkit_dom_css_style_declaration_set_css_text): Ditto.
* WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMCSSStyleSheet.cpp:
(webkit_dom_css_style_sheet_insert_rule): Ditto.
(webkit_dom_css_style_sheet_delete_rule): Ditto.
(webkit_dom_css_style_sheet_add_rule): Ditto.
(webkit_dom_css_style_sheet_remove_rule): Ditto.
* WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMCSSValue.cpp:
(webkit_dom_css_value_set_css_text): Ditto.
* WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMMediaList.cpp:
(webkit_dom_media_list_delete_medium): Ditto.
(webkit_dom_media_list_append_medium): Ditto.
(webkit_dom_media_list_set_media_text): Ditto.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@207396 268f45cc-cd09-0410-ab3c-d52691b4dbfc

98 files changed:
Source/WebCore/ChangeLog
Source/WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp
Source/WebCore/bindings/js/JSDOMBinding.h
Source/WebCore/bindings/scripts/gobject-generate-headers.pl [deleted file]
Source/WebCore/css/BasicShapeFunctions.cpp
Source/WebCore/css/CSSBasicShapes.cpp
Source/WebCore/css/CSSBorderImageSliceValue.h
Source/WebCore/css/CSSCalculationValue.cpp
Source/WebCore/css/CSSCharsetRule.h
Source/WebCore/css/CSSCharsetRule.idl
Source/WebCore/css/CSSComputedStyleDeclaration.cpp
Source/WebCore/css/CSSComputedStyleDeclaration.h
Source/WebCore/css/CSSCrossfadeValue.cpp
Source/WebCore/css/CSSFontFace.cpp
Source/WebCore/css/CSSFontFaceSet.cpp
Source/WebCore/css/CSSFontFaceSet.h
Source/WebCore/css/CSSFontSelector.cpp
Source/WebCore/css/CSSGradientValue.cpp
Source/WebCore/css/CSSGroupingRule.cpp
Source/WebCore/css/CSSGroupingRule.h
Source/WebCore/css/CSSImageGeneratorValue.cpp
Source/WebCore/css/CSSImageSetValue.cpp
Source/WebCore/css/CSSMediaRule.h
Source/WebCore/css/CSSMediaRule.idl
Source/WebCore/css/CSSPrimitiveValue.cpp
Source/WebCore/css/CSSPrimitiveValue.h
Source/WebCore/css/CSSPrimitiveValue.idl
Source/WebCore/css/CSSPrimitiveValueMappings.h
Source/WebCore/css/CSSRule.cpp
Source/WebCore/css/CSSRule.h
Source/WebCore/css/CSSRule.idl
Source/WebCore/css/CSSStyleDeclaration.h
Source/WebCore/css/CSSStyleDeclaration.idl
Source/WebCore/css/CSSStyleSheet.cpp
Source/WebCore/css/CSSStyleSheet.h
Source/WebCore/css/CSSStyleSheet.idl
Source/WebCore/css/CSSSupportsRule.idl
Source/WebCore/css/CSSToStyleMap.cpp
Source/WebCore/css/CSSValue.h
Source/WebCore/css/CSSValue.idl
Source/WebCore/css/Counter.h
Source/WebCore/css/FontFace.cpp
Source/WebCore/css/FontFace.h
Source/WebCore/css/FontFace.idl
Source/WebCore/css/FontFaceSet.cpp
Source/WebCore/css/FontFaceSet.h
Source/WebCore/css/FontFaceSet.idl
Source/WebCore/css/FontVariantBuilder.cpp
Source/WebCore/css/MediaList.cpp
Source/WebCore/css/MediaList.h
Source/WebCore/css/MediaList.idl
Source/WebCore/css/MediaQueryEvaluator.cpp
Source/WebCore/css/MediaQueryExp.cpp
Source/WebCore/css/PropertySetCSSStyleDeclaration.cpp
Source/WebCore/css/PropertySetCSSStyleDeclaration.h
Source/WebCore/css/StyleBuilderConverter.h
Source/WebCore/css/StyleBuilderCustom.h
Source/WebCore/css/StyleProperties.cpp
Source/WebCore/css/StyleResolver.cpp
Source/WebCore/css/TransformFunctions.cpp
Source/WebCore/css/ViewportStyleResolver.cpp
Source/WebCore/css/WebKitCSSMatrix.cpp
Source/WebCore/css/WebKitCSSMatrix.h
Source/WebCore/css/WebKitCSSMatrix.idl
Source/WebCore/css/makeprop.pl
Source/WebCore/css/parser/CSSParser.cpp
Source/WebCore/css/parser/CSSParserValues.cpp
Source/WebCore/css/parser/CSSPropertyParser.cpp
Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp
Source/WebCore/dom/Range.cpp
Source/WebCore/dom/SelectorQuery.cpp
Source/WebCore/editing/ApplyStyleCommand.cpp
Source/WebCore/editing/EditingStyle.cpp
Source/WebCore/editing/Editor.cpp
Source/WebCore/editing/RemoveCSSPropertyCommand.cpp
Source/WebCore/editing/ReplaceSelectionCommand.cpp
Source/WebCore/editing/cocoa/HTMLConverter.mm
Source/WebCore/editing/markup.cpp
Source/WebCore/inspector/InspectorStyleSheet.cpp
Source/WebCore/svg/SVGLength.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/DOM/DOMCSSMediaRule.mm
Source/WebKit/mac/DOM/DOMCSSPrimitiveValue.mm
Source/WebKit/mac/DOM/DOMCSSRule.mm
Source/WebKit/mac/DOM/DOMCSSStyleDeclaration.mm
Source/WebKit/mac/DOM/DOMCSSStyleSheet.mm
Source/WebKit/mac/DOM/DOMCSSValue.mm
Source/WebKit/mac/DOM/DOMMediaList.mm
Source/WebKit/mac/DOM/ExceptionHandlers.h
Source/WebKit/mac/DOM/ExceptionHandlers.mm
Source/WebKit/win/ChangeLog
Source/WebKit/win/DOMCSSClasses.cpp
Source/WebKit2/ChangeLog
Source/WebKit2/WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMCSSRule.cpp
Source/WebKit2/WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMCSSStyleDeclaration.cpp
Source/WebKit2/WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMCSSStyleSheet.cpp
Source/WebKit2/WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMCSSValue.cpp
Source/WebKit2/WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMMediaList.cpp

index 8757619..d276f15 100644 (file)
@@ -1,3 +1,317 @@
+2016-10-16  Darin Adler  <darin@apple.com>
+
+        Move CSS classes from ExceptionCode to Exception
+        https://bugs.webkit.org/show_bug.cgi?id=163494
+
+        Reviewed by Sam Weinig.
+
+        Removed the "get" prefix from the names of many CSSPrimitiveValue
+        functions to match WebKit coding style and to disambiguate them
+        from the public CSS DOM functions that raise exceptions.
+
+        * bindings/js/JSCSSStyleDeclarationCustom.cpp:
+        (WebCore::propertyNamePrefix): Use enum class.
+        (WebCore::parseJavaScriptCSSPropertyName): Tweak style a bit.
+        (WebCore::stylePropertyGetter): Refactor to simplify structure.
+        (WebCore::stylePropertyGetterPixelOrPosPrefix): Ditto. Also use floatValue.
+        (WebCore::JSCSSStyleDeclaration::putDelegate): Use findIgnoringASCIICase,
+        and use propagateException to handle ExcpetionOr.
+        (WebCore::JSCSSStyleDeclaration::getPropertyCSSValue): Tweak style a bit.
+        (WebCore::JSCSSStyleDeclaration::getOwnPropertyNames): Use a lambda to
+        initialize a global here.
+
+        * bindings/js/JSDOMBinding.h: Added toJSString to support bindings for
+        functions returning ExceptionOr<String>.
+
+        * bindings/scripts/gobject-generate-headers.pl: Deleted.
+
+        * css/BasicShapeFunctions.cpp:
+        (WebCore::convertToLengthSize): Use pairValue.
+        (WebCore::convertToCenterCoordinate): Use valueID and pairValue.
+        (WebCore::cssValueToBasicShapeRadius): Ditto.
+        * css/CSSBasicShapes.cpp:
+        (WebCore::serializePositionOffset): Ditto.
+        (WebCore::buildSerializablePositionOffset): Ditto.
+        (WebCore::CSSBasicShapeCircle::cssText): Ditto.
+        (WebCore::CSSBasicShapeEllipse::cssText): Ditto.
+        (WebCore::updateCornerRadiusWidthAndHeight): Ditto.
+        * css/CSSBorderImageSliceValue.h: Use quadValue.
+        * css/CSSCalculationValue.cpp:
+        (WebCore::determineCategory): Use floatValue and doubleValue.
+
+        * css/CSSCharsetRule.h: Use ExceptionOr. Also made more things private.
+        * css/CSSCharsetRule.idl: Use non-legacy exceptions.
+
+        * css/CSSComputedStyleDeclaration.cpp:
+        (WebCore::CSSComputedStyleDeclaration::setCssText): Use ExceptionOr.
+        (WebCore::ComputedStyleExtractor::propertyMatches): Use valueID.
+        (WebCore::CSSComputedStyleDeclaration::setProperty): Use ExceptionOr.
+        (WebCore::CSSComputedStyleDeclaration::removeProperty): Ditto.
+        (WebCore::CSSComputedStyleDeclaration::setPropertyInternal): Ditto.
+        (WebCore::ComputedStyleExtractor::getBackgroundShorthandValue): Return
+        a Ref instead of a RefPtr.
+        * css/CSSComputedStyleDeclaration.h: Updated for above changes.
+
+        * css/CSSCrossfadeValue.cpp:
+        (WebCore::CSSCrossfadeValue::fixedSize): Use floatValue.
+        (WebCore::CSSCrossfadeValue::image): Ditto.
+        (WebCore::CSSCrossfadeValue::blend): Use doubleValue.
+
+        * css/CSSFontFace.cpp:
+        (WebCore::CSSFontFace::calculateStyleMask): Use valueID.
+        (WebCore::CSSFontFace::calculateWeightMask): Ditto.
+        * css/CSSFontFaceSet.cpp:
+        (WebCore::CSSFontFaceSet::familyNameFromPrimitive): Ditto.
+        (WebCore::CSSFontFaceSet::matchingFaces): Use ExceptoinOr.
+        (WebCore::CSSFontFaceSet::check): Ditto.
+        * css/CSSFontFaceSet.h: Updated for above changes.
+
+        * css/CSSGradientValue.cpp:
+        (WebCore::compareStops): Use doubleValue.
+        (WebCore::CSSGradientValue::addStops): Use floatValue.
+        (WebCore::positionFromValue): Use floatValue and valudID.
+        (WebCore::CSSLinearGradientValue::customCSSText): Use doubleValue and valueID.
+        (WebCore::CSSLinearGradientValue::createGradient): Use floatValue and valueID.
+        (WebCore::CSSRadialGradientValue::customCSSText): Use doubleValue and valueID.
+        (WebCore::CSSRadialGradientValue::resolveRadius): Use floatValue.
+        (WebCore::CSSRadialGradientValue::createGradient): Use valueID.
+
+        * css/CSSGroupingRule.cpp:
+        (WebCore::CSSGroupingRule::insertRule): Use ExceptionOr.
+        (WebCore::CSSGroupingRule::deleteRule): Ditto.
+        * css/CSSGroupingRule.h: Updated for above changes.
+
+        * css/CSSImageGeneratorValue.cpp:
+        (WebCore::CSSImageGeneratorValue::subimageIsPending): Use valueID.
+        (WebCore::CSSImageGeneratorValue::cachedImageForCSSValue): Ditto.
+
+        * css/CSSImageSetValue.cpp:
+        (WebCore::CSSImageSetValue::fillImageSet): Use floatValue.
+
+        * css/CSSMediaRule.idl: Use non-legacy exceptions.
+
+        * css/CSSPrimitiveValue.cpp:
+        (WebCore::CSSPrimitiveValue::computeDegrees): Use doubleValue.
+        (WebCore::CSSPrimitiveValue::setFloatValue): Use ExceptionOr.
+        (WebCore::CSSPrimitiveValue::getFloatValue): Replaced getDoubleValue with this,
+        since getDoubleValue is unused, moving the call to clampTo into this function.
+        Also changed this to use ExceptionOr.
+        (WebCore::CSSPrimitiveValue::doubleValue): Renamed from getDoubleValue.
+        (WebCore::CSSPrimitiveValue::doubleValueInternal): Use Optional instead of a bool
+        and an out argument to return the value and check for type failure.
+        (WebCore::CSSPrimitiveValue::setStringValue): Use ExceptionOr.
+        (WebCore::CSSPrimitiveValue::getStringValue): Ditto.
+        (WebCore::CSSPrimitiveValue::stringValue): Renamed from getStringValue.
+        (WebCore::CSSPrimitiveValue::getCounterValue): Use ExceptionOr.
+        (WebCore::CSSPrimitiveValue::getRectValue): Use ExceptionOr.
+        (WebCore::CSSPrimitiveValue::getQuadValue): Deleted.
+        (WebCore::CSSPrimitiveValue::getLengthRepeatValue): Deleted.
+        (WebCore::CSSPrimitiveValue::getRGBColorValue): Use ExceptionOr.
+        (WebCore::CSSPrimitiveValue::getPairValue): Deleted.
+        (WebCore::CSSPrimitiveValue::formatNumberForCustomCSSText): Use new names for functions.
+        * css/CSSPrimitiveValue.h: Reorganized the class, moved large inline function bodies
+        out of the class definition. Updated for the above changes.
+        * css/CSSPrimitiveValue.idl: Use non-legacy exceptions.
+
+        * css/CSSPrimitiveValueMappings.h: Use value instead of getValue, etc.
+
+        * css/CSSRule.cpp:
+        (WebCore::CSSRule::setCssText): Use ExceptionOr.
+        * css/CSSRule.h: Updated for above change.
+        * css/CSSRule.idl: Use non-legacy exceptions.
+
+        * css/CSSStyleDeclaration.h: Use ExceptionOr.
+        * css/CSSStyleDeclaration.idl: Use non-legacy exceptions.
+
+        * css/CSSStyleSheet.cpp:
+        (WebCore::CSSStyleSheet::deprecatedInsertRule): Use ExceptionOr.
+        (WebCore::CSSStyleSheet::insertRule): Ditto.
+        (WebCore::CSSStyleSheet::deleteRule): Ditto.
+        (WebCore::CSSStyleSheet::addRule): Ditto.
+        * css/CSSStyleSheet.h: Updated for the above changes.
+        * css/CSSStyleSheet.idl: Use non-legacy exceptions.
+
+        * css/CSSSupportsRule.idl: Use non-legacy exceptions.
+
+        * css/CSSToStyleMap.cpp:
+        (WebCore::CSSToStyleMap::mapFillAttachment): Use valueID instead of getValueID, etc.
+        (WebCore::convertToLengthSize): Ditto.
+        (WebCore::CSSToStyleMap::mapFillSize): Ditto.
+        (WebCore::CSSToStyleMap::mapFillXPosition): Ditto.
+        (WebCore::CSSToStyleMap::mapFillYPosition): Ditto.
+        (WebCore::CSSToStyleMap::mapFillMaskSourceType): Ditto.
+        (WebCore::CSSToStyleMap::mapAnimationDirection): Ditto.
+        (WebCore::CSSToStyleMap::mapAnimationFillMode): Ditto.
+        (WebCore::CSSToStyleMap::mapAnimationIterationCount): Ditto.
+        (WebCore::CSSToStyleMap::mapAnimationName): Ditto.
+        (WebCore::CSSToStyleMap::mapAnimationPlayState): Ditto.
+        (WebCore::CSSToStyleMap::mapAnimationProperty): Ditto.
+        (WebCore::CSSToStyleMap::mapAnimationTimingFunction): Ditto.
+        (WebCore::CSSToStyleMap::mapAnimationTrigger): Ditto.
+        (WebCore::CSSToStyleMap::mapNinePieceImageSlice): Ditto.
+        (WebCore::CSSToStyleMap::mapNinePieceImageQuad): Ditto.
+        (WebCore::CSSToStyleMap::mapNinePieceImageRepeat): Ditto.
+
+        * css/CSSValue.h: Use ExceptionOr.
+        * css/CSSValue.idl: Use non-legacy exceptions.
+
+        * css/Counter.h: Use stringValue instead of getStringValue, etc.
+
+        * css/FontFace.cpp:
+        (WebCore::FontFace::create): Use ExceptionOr.
+        (WebCore::FontFace::setFamily): Ditto.
+        (WebCore::FontFace::setStyle): Ditto.
+        (WebCore::FontFace::setWeight): Ditto.
+        (WebCore::FontFace::setStretch): Ditto.
+        (WebCore::FontFace::setUnicodeRange): Ditto.
+        (WebCore::FontFace::setVariant): Ditto.
+        (WebCore::FontFace::setFeatureSettings): Ditto.
+        * css/FontFace.h: Updated for above changes.
+        * css/FontFace.idl: Use non-legacy exceptions.
+
+        * css/FontFaceSet.cpp:
+        (WebCore::FontFaceSet::load): Use ExceptionOr.
+        (WebCore::FontFaceSet::check): Ditto.
+        * css/FontFaceSet.h: Updated for above changes.
+        * css/FontFaceSet.idl: Use non-legacy exceptions.
+
+        * css/FontVariantBuilder.cpp:
+        (WebCore::extractFontVariantLigatures): Use valueID instead of getValueID, etc.
+        (WebCore::extractFontVariantNumeric): Ditto.
+        (WebCore::extractFontVariantEastAsian): Ditto.
+
+        * css/MediaList.cpp:
+        (WebCore::MediaList::setMediaText): Use ExceptionOr.
+        (WebCore::MediaList::deleteMedium): Ditto.
+        (WebCore::MediaList::appendMedium): Ditto.
+        * css/MediaList.h: Updated for above changes.
+        * css/MediaList.idl: Use non-legacy exceptions.
+
+        * css/MediaQueryEvaluator.cpp:
+        (WebCore::doubleValue): Use valueID instead of getValueID, etc.
+        (WebCore::colorGamutEvaluate): Ditto.
+        (WebCore::invertedColorsEvaluate): Ditto.
+        (WebCore::orientationEvaluate): Ditto.
+        (WebCore::evaluateResolution): Ditto.
+        (WebCore::computeLength): Ditto.
+        (WebCore::viewModeEvaluate): Ditto.
+        (WebCore::hoverEvaluate): Ditto.
+        (WebCore::pointerEvaluate): Ditto.
+        (WebCore::prefersReducedMotionEvaluate): Ditto.
+
+        * css/PropertySetCSSStyleDeclaration.cpp:
+        (WebCore::PropertySetCSSStyleDeclaration::setCssText): Use ExceptionOr.
+        (WebCore::PropertySetCSSStyleDeclaration::setProperty): Ditto.
+        (WebCore::PropertySetCSSStyleDeclaration::removeProperty): Ditto.
+        (WebCore::PropertySetCSSStyleDeclaration::getPropertyCSSValueInternal): Ditto.
+        (WebCore::PropertySetCSSStyleDeclaration::setPropertyInternal): Ditto.
+        * css/PropertySetCSSStyleDeclaration.h: Updated for above changes.
+        Also marked a couple additional functions private.
+
+        * css/StyleBuilderConverter.h: Use doubleValue instead of getDoubleValue, etc.
+        * css/StyleBuilderCustom.h: Ditto.
+        * css/StyleProperties.cpp:
+        (WebCore::StyleProperties::getLayeredShorthandValue): Ditto.
+        * css/StyleResolver.cpp:
+        (WebCore::StyleResolver::MatchResult::addMatchedProperties): Ditto.
+        (WebCore::StyleResolver::colorFromPrimitiveValueIsDerivedFromElement): Ditto.
+        (WebCore::StyleResolver::colorFromPrimitiveValue): Ditto.
+        (WebCore::StyleResolver::createFilterOperations): Ditto.
+        * css/TransformFunctions.cpp:
+        (WebCore::transformsForValue): Ditto.
+        * css/ViewportStyleResolver.cpp:
+        (WebCore::ViewportStyleResolver::getViewportArgumentValue): Ditto.
+
+        * css/WebKitCSSMatrix.cpp:
+        (WebCore::WebKitCSSMatrix::WebKitCSSMatrix): Tweaked constructors a bit,
+        getting rid of the one that uses an ExceptionCode.
+        (WebCore::WebKitCSSMatrix::create): Moved in here, and use ExceptionOr.
+        (WebCore::WebKitCSSMatrix::setMatrixValue): Use ExceptionOr.
+        (WebCore::WebKitCSSMatrix::multiply): Tweak coding style a bit.
+        (WebCore::WebKitCSSMatrix::inverse): Use ExceptionOr.
+        (WebCore::WebKitCSSMatrix::translate): Return a Ref instead of RefPtr.
+        (WebCore::WebKitCSSMatrix::scale): Ditto.
+        (WebCore::WebKitCSSMatrix::rotate): Ditto.
+        (WebCore::WebKitCSSMatrix::rotateAxisAngle): Ditto.
+        (WebCore::WebKitCSSMatrix::skewX): Ditto.
+        (WebCore::WebKitCSSMatrix::skewY): Ditto.
+        (WebCore::WebKitCSSMatrix::toString): Tweaked formatting a bit.
+        * css/WebKitCSSMatrix.h: Updated for above changes.
+        * css/WebKitCSSMatrix.idl: Use non-legacy extensions.
+
+        * css/makeprop.pl:
+        (handleCurrentColorValue): Use valueID instead of getValueID.
+        (generateValueSetter): Ditto.
+
+        * css/parser/CSSParser.cpp:
+        (WebCore::CSSParser::parse4ValuesFillPosition): Use valueID instead of getValueID, etc.
+        (WebCore::CSSParser::parse3ValuesFillPosition): Ditto.
+        (WebCore::CSSParser::parseFillPosition): Ditto.
+        (WebCore::CSSParser::parseFillRepeat): Ditto.
+        (WebCore::CSSParser::parseGridPosition): Ditto.
+        (WebCore::CSSParser::parseGridTemplateRowsAndAreasAndColumns): Ditto.
+        (WebCore::isGridTrackFixedSized): Ditto.
+        (WebCore::CSSParser::parseRadialGradient): Ditto.
+        (WebCore::CSSParser::parseBuiltinFilterArguments): Ditto.
+
+        * css/parser/CSSParserValues.cpp:
+        (WebCore::CSSParserValue::createCSSValue): Removed the unneeded call to
+        setPrimitiveType here. The createParserOperator returns an object that
+        already has the correct primitive type.
+
+        * css/parser/CSSPropertyParser.cpp: Updated most cases of calling the old
+        getXXXValue functions, but not sure if it's right since it is commented out
+        code that I did not compile.
+
+        * css/parser/CSSPropertyParserHelpers.cpp:
+        (WebCore::CSSPropertyParserHelpers::clampRGBComponent): Use intValue instead of getIntValue, etc.
+        (WebCore::CSSPropertyParserHelpers::parseHSLParameters): Ditto.
+        (WebCore::CSSPropertyParserHelpers::isHorizontalPositionKeywordOnly): Ditto.
+        (WebCore::CSSPropertyParserHelpers::isVerticalPositionKeywordOnly): Ditto.
+        (WebCore::CSSPropertyParserHelpers::positionFromThreeOrFourValues): Ditto.
+        (WebCore::CSSPropertyParserHelpers::consumeRadialGradient): Ditto.
+
+        * dom/Range.cpp: Added now-needed include of ExceptionCode.h.
+        * dom/SelectorQuery.cpp: Ditto.
+
+        * editing/ApplyStyleCommand.cpp:
+        (WebCore::toIdentifier): Use valueID instead of getValueID, etc.
+        (WebCore::ApplyStyleCommand::computedFontSize): Ditto.
+        * editing/EditingStyle.cpp:
+        (WebCore::identifierForStyleProperty): Ditto.
+        (WebCore::HTMLElementEquivalent::valueIsPresentInStyle): Ditto.
+        (WebCore::EditingStyle::extractFontSizeDelta): Ditto.
+        (WebCore::EditingStyle::textDirection): Ditto.
+        (WebCore::EditingStyle::prepareToApplyAt): Ditto.
+        (WebCore::EditingStyle::textDirectionForSelection): Ditto.
+        (WebCore::fontWeightIsBold): Ditto.
+        (WebCore::legacyFontSizeFromCSSValue): Ditto.
+        (WebCore::isTransparentColorValue): Ditto.
+        (WebCore::hasTransparentBackgroundColor): Ditto.
+        (WebCore::backgroundColorInEffect): Ditto.
+
+        * editing/Editor.cpp:
+        (WebCore::Editor::applyEditingStyleToElement): Removed IGNORE_EXCEPTION; that is
+        what we do by default for things returning ExceptionOr.
+        * editing/RemoveCSSPropertyCommand.cpp:
+        (WebCore::RemoveCSSPropertyCommand::doApply): Ditto.
+        (WebCore::RemoveCSSPropertyCommand::doUnapply): Ditto.
+        * editing/ReplaceSelectionCommand.cpp:
+        (WebCore::ReplaceSelectionCommand::removeRedundantStylesAndKeepStyleSpanInline): Ditto.
+
+        * editing/cocoa/HTMLConverter.mm:
+        (floatValueFromPrimitiveValue): Use floatValue instead of getFloatValue, etc.
+        * editing/markup.cpp:
+        (WebCore::propertyMissingOrEqualToNone): Ditto.
+
+        * inspector/InspectorStyleSheet.cpp:
+        (WebCore::InspectorStyleSheet::addRule): Updated to call ExceptionOr-returning functions.
+        (WebCore::InspectorStyleSheet::deleteRule): Ditto.
+        (WebCore::InspectorStyleSheet::setStyleText): Ditto.
+
+        * svg/SVGLength.cpp:
+        (WebCore::SVGLength::fromCSSPrimitiveValue): Use floatValue instead of getFloatValue.
+
 2016-10-16  Antoine Quint  <graouts@apple.com>
 
         [Modern Media Controls] Styles for StartButton are missing
index 4b7e32b..35e4a22 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2009, 2013, 2016 Apple Inc. All rights reserved.
+ * Copyright (C) 2007-2016 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -47,7 +47,6 @@
 #include <wtf/ASCIICType.h>
 #include <wtf/text/AtomicString.h>
 #include <wtf/text/StringConcatenate.h>
-#include <wtf/text/WTFString.h>
 
 using namespace JSC;
 
@@ -55,6 +54,7 @@ namespace WebCore {
 
 void* root(CSSStyleDeclaration* style)
 {
+    ASSERT(style);
     if (auto* parentRule = style->parentRule())
         return root(parentRule);
     if (auto* styleSheet = style->parentStyleSheet())
@@ -69,25 +69,11 @@ void JSCSSStyleDeclaration::visitAdditionalChildren(SlotVisitor& visitor)
     visitor.addOpaqueRoot(root(&wrapped()));
 }
 
-class CSSPropertyInfo {
-public:
-    CSSPropertyID propertyID;
-    bool hadPixelOrPosPrefix;
-};
-
-enum PropertyNamePrefix {
-    PropertyNamePrefixNone,
-    PropertyNamePrefixCSS,
-    PropertyNamePrefixPixel,
-    PropertyNamePrefixPos,
+enum class PropertyNamePrefix {
+    None, Epub, CSS, Pixel, Pos, WebKit,
 #if ENABLE(LEGACY_CSS_VENDOR_PREFIXES)
-    PropertyNamePrefixApple,
+    Apple, KHTML,
 #endif
-    PropertyNamePrefixEpub,
-#if ENABLE(LEGACY_CSS_VENDOR_PREFIXES)
-    PropertyNamePrefixKHTML,
-#endif
-    PropertyNamePrefixWebKit
 };
 
 template<size_t prefixCStringLength>
@@ -107,7 +93,7 @@ static inline bool matchesCSSPropertyNamePrefix(const StringImpl& propertyName,
 
     // The prefix within the property name must be followed by a capital letter.
     // Other characters in the prefix within the property name must be lowercase.
-    if (propertyName.length() < (prefixLength + 1))
+    if (propertyName.length() < prefixLength + 1)
         return false;
 
     for (size_t i = offset; i < prefixLength; ++i) {
@@ -117,10 +103,11 @@ static inline bool matchesCSSPropertyNamePrefix(const StringImpl& propertyName,
 
     if (!isASCIIUpper(propertyName[prefixLength]))
         return false;
+
     return true;
 }
 
-static PropertyNamePrefix getCSSPropertyNamePrefix(const StringImpl& propertyName)
+static PropertyNamePrefix propertyNamePrefix(const StringImpl& propertyName)
 {
     ASSERT(propertyName.length());
 
@@ -130,37 +117,37 @@ static PropertyNamePrefix getCSSPropertyNamePrefix(const StringImpl& propertyNam
 #if ENABLE(LEGACY_CSS_VENDOR_PREFIXES)
     case 'a':
         if (RuntimeEnabledFeatures::sharedFeatures().legacyCSSVendorPrefixesEnabled() && matchesCSSPropertyNamePrefix(propertyName, "apple"))
-            return PropertyNamePrefixApple;
+            return PropertyNamePrefix::Apple;
         break;
 #endif
     case 'c':
         if (matchesCSSPropertyNamePrefix(propertyName, "css"))
-            return PropertyNamePrefixCSS;
+            return PropertyNamePrefix::CSS;
         break;
 #if ENABLE(LEGACY_CSS_VENDOR_PREFIXES)
     case 'k':
         if (RuntimeEnabledFeatures::sharedFeatures().legacyCSSVendorPrefixesEnabled() && matchesCSSPropertyNamePrefix(propertyName, "khtml"))
-            return PropertyNamePrefixKHTML;
+            return PropertyNamePrefix::KHTML;
         break;
 #endif
     case 'e':
         if (matchesCSSPropertyNamePrefix(propertyName, "epub"))
-            return PropertyNamePrefixEpub;
+            return PropertyNamePrefix::Epub;
         break;
     case 'p':
         if (matchesCSSPropertyNamePrefix(propertyName, "pos"))
-            return PropertyNamePrefixPos;
+            return PropertyNamePrefix::Pos;
         if (matchesCSSPropertyNamePrefix(propertyName, "pixel"))
-            return PropertyNamePrefixPixel;
+            return PropertyNamePrefix::Pixel;
         break;
     case 'w':
         if (matchesCSSPropertyNamePrefix(propertyName, "webkit"))
-            return PropertyNamePrefixWebKit;
+            return PropertyNamePrefix::WebKit;
         break;
     default:
         break;
     }
-    return PropertyNamePrefixNone;
+    return PropertyNamePrefix::None;
 }
 
 static inline void writeWebKitPrefix(char*& buffer)
@@ -185,7 +172,12 @@ static inline void writeEpubPrefix(char*& buffer)
     *buffer++ = '-';
 }
 
-static CSSPropertyInfo cssPropertyIDForJSCSSPropertyName(PropertyName propertyName)
+struct CSSPropertyInfo {
+    CSSPropertyID propertyID;
+    bool hadPixelOrPosPrefix;
+};
+
+static CSSPropertyInfo parseJavaScriptCSSPropertyName(PropertyName propertyName)
 {
     CSSPropertyInfo propertyInfo = {CSSPropertyInvalid, false};
     bool hadPixelOrPosPrefix = false;
@@ -198,7 +190,7 @@ static CSSPropertyInfo cssPropertyIDForJSCSSPropertyName(PropertyName propertyNa
         return propertyInfo;
 
     String stringForCache = String(propertyNameString);
-    typedef HashMap<String, CSSPropertyInfo> CSSPropertyInfoMap;
+    using CSSPropertyInfoMap = HashMap<String, CSSPropertyInfo>;
     static NeverDestroyed<CSSPropertyInfoMap> propertyInfoCache;
     propertyInfo = propertyInfoCache.get().get(stringForCache);
     if (propertyInfo.propertyID)
@@ -213,35 +205,35 @@ static CSSPropertyInfo cssPropertyIDForJSCSSPropertyName(PropertyName propertyNa
     // Prefixes CSS, Pixel, Pos are ignored.
     // Prefixes Apple, KHTML and Webkit are transposed to "-webkit-".
     // The prefix "Epub" becomes "-epub-".
-    switch (getCSSPropertyNamePrefix(*propertyNameString)) {
-    case PropertyNamePrefixNone:
+    switch (propertyNamePrefix(*propertyNameString)) {
+    case PropertyNamePrefix::None:
         if (isASCIIUpper((*propertyNameString)[0]))
             return propertyInfo;
         break;
-    case PropertyNamePrefixCSS:
+    case PropertyNamePrefix::CSS:
         i += 3;
         break;
-    case PropertyNamePrefixPixel:
+    case PropertyNamePrefix::Pixel:
         i += 5;
         hadPixelOrPosPrefix = true;
         break;
-    case PropertyNamePrefixPos:
+    case PropertyNamePrefix::Pos:
         i += 3;
         hadPixelOrPosPrefix = true;
         break;
 #if ENABLE(LEGACY_CSS_VENDOR_PREFIXES)
-    case PropertyNamePrefixApple:
-    case PropertyNamePrefixKHTML:
+    case PropertyNamePrefix::Apple:
+    case PropertyNamePrefix::KHTML:
         ASSERT(RuntimeEnabledFeatures::sharedFeatures().legacyCSSVendorPrefixesEnabled());
         writeWebKitPrefix(bufferPtr);
         i += 5;
         break;
 #endif
-    case PropertyNamePrefixEpub:
+    case PropertyNamePrefix::Epub:
         writeEpubPrefix(bufferPtr);
         i += 4;
         break;
-    case PropertyNamePrefixWebKit:
+    case PropertyNamePrefix::WebKit:
         writeWebKitPrefix(bufferPtr);
         i += 6;
         break;
@@ -258,7 +250,7 @@ static CSSPropertyInfo cssPropertyIDForJSCSSPropertyName(PropertyName propertyNa
 
     for (; i < length; ++i) {
         UChar c = (*propertyNameString)[i];
-        if (!c || c >= 0x7F)
+        if (!c || !isASCII(c))
             return propertyInfo; // illegal character
         if (isASCIIUpper(c)) {
             size_t bufferSizeLeft = stringEnd - bufferPtr;
@@ -266,7 +258,7 @@ static CSSPropertyInfo cssPropertyIDForJSCSSPropertyName(PropertyName propertyNa
             if (propertySizeLeft > bufferSizeLeft)
                 return propertyInfo;
             *bufferPtr++ = '-';
-            *bufferPtr++ = toASCIILower(c);
+            *bufferPtr++ = toASCIILowerUnchecked(c);
         } else
             *bufferPtr++ = c;
         ASSERT_WITH_SECURITY_IMPLICATION(bufferPtr < bufferEnd);
@@ -279,9 +271,8 @@ static CSSPropertyInfo cssPropertyIDForJSCSSPropertyName(PropertyName propertyNa
     cssPropertyNameIOSAliasing(buffer, name, outputLength);
 #endif
 
-    const Property* hashTableEntry = findProperty(name, outputLength);
-    int propertyID = hashTableEntry ? hashTableEntry->id : 0;
-    if (propertyID) {
+    auto* hashTableEntry = findProperty(name, outputLength);
+    if (auto propertyID = hashTableEntry ? hashTableEntry->id : 0) {
         propertyInfo.hadPixelOrPosPrefix = hadPixelOrPosPrefix;
         propertyInfo.propertyID = static_cast<CSSPropertyID>(propertyID);
         propertyInfoCache.get().add(stringForCache, propertyInfo);
@@ -289,76 +280,71 @@ static CSSPropertyInfo cssPropertyIDForJSCSSPropertyName(PropertyName propertyNa
     return propertyInfo;
 }
 
-static inline JSValue getPropertyValueFallback(ExecState* exec, JSCSSStyleDeclaration* thisObj, unsigned index)
+static inline JSValue stylePropertyGetter(ExecState& state, JSCSSStyleDeclaration& thisObject, CSSPropertyID propertyID, const RefPtr<CSSValue>& value)
 {
-    // If the property is a shorthand property (such as "padding"),
-    // it can only be accessed using getPropertyValue.
-    return jsStringWithCache(exec, thisObj->wrapped().getPropertyValueInternal(static_cast<CSSPropertyID>(index)));
+    if (value)
+        return jsStringOrNull(&state, value->cssText());
+    // If the property is a shorthand property (such as "padding"), it can only be accessed using getPropertyValue.
+    return jsStringWithCache(&state, thisObject.wrapped().getPropertyValueInternal(propertyID));
 }
 
-static inline JSValue cssPropertyGetterPixelOrPosPrefix(ExecState* exec, JSCSSStyleDeclaration* thisObj, unsigned propertyID)
+static inline JSValue stylePropertyGetter(ExecState& state, JSCSSStyleDeclaration& thisObject, CSSPropertyID propertyID)
 {
-    // Set up pixelOrPos boolean to handle the fact that
-    // pixelTop returns "CSS Top" as number value in unit pixels
-    // posTop returns "CSS top" as number value in unit pixels _if_ its a
-    // positioned element. if it is not a positioned element, return 0
-    // from MSIE documentation FIXME: IMPLEMENT THAT (Dirk)
-    RefPtr<CSSValue> v = thisObj->wrapped().getPropertyCSSValueInternal(static_cast<CSSPropertyID>(propertyID));
-    if (v) {
-        if (v->isPrimitiveValue())
-            return jsNumber(static_pointer_cast<CSSPrimitiveValue>(v)->getFloatValue(CSSPrimitiveValue::CSS_PX));
-        return jsStringOrNull(exec, v->cssText());
-    }
-
-    return getPropertyValueFallback(exec, thisObj, propertyID);
+    return stylePropertyGetter(state, thisObject, propertyID, thisObject.wrapped().getPropertyCSSValueInternal(propertyID));
 }
 
-static inline JSValue cssPropertyGetter(ExecState* exec, JSCSSStyleDeclaration* thisObj, unsigned propertyID)
+static inline JSValue stylePropertyGetterPixelOrPosPrefix(ExecState& state, JSCSSStyleDeclaration& thisObject, CSSPropertyID propertyID)
 {
-    RefPtr<CSSValue> v = thisObj->wrapped().getPropertyCSSValueInternal(static_cast<CSSPropertyID>(propertyID));
-    if (v)
-        return jsStringOrNull(exec, v->cssText());
+    // Call this version of the getter so that, e.g., pixelTop returns top as a number
+    // in pixel units and posTop should does the same _if_ this is a positioned element.
+    // FIXME: If not a positioned element, MSIE documentation says posTop should return 0; this rule is not implemented.
+    auto value = thisObject.wrapped().getPropertyCSSValueInternal(propertyID);
+    if (is<CSSPrimitiveValue>(value.get()))
+        return jsNumber(downcast<CSSPrimitiveValue>(*value).floatValue(CSSPrimitiveValue::CSS_PX));
+    return stylePropertyGetter(state, thisObject, propertyID, value);
+}
 
-    return getPropertyValueFallback(exec, thisObj, propertyID);
+static inline JSValue stylePropertyGetter(ExecState& state, JSCSSStyleDeclaration& thisObject, const CSSPropertyInfo& propertyInfo)
+{
+    if (propertyInfo.hadPixelOrPosPrefix)
+        return stylePropertyGetterPixelOrPosPrefix(state, thisObject, propertyInfo.propertyID);
+    return stylePropertyGetter(state, thisObject, propertyInfo.propertyID);
 }
 
-bool JSCSSStyleDeclaration::getOwnPropertySlotDelegate(ExecState* exec, PropertyName propertyIdentifier, PropertySlot& slot)
+bool JSCSSStyleDeclaration::getOwnPropertySlotDelegate(ExecState* state, PropertyName propertyName, PropertySlot& slot)
 {
-    CSSPropertyInfo propertyInfo = cssPropertyIDForJSCSSPropertyName(propertyIdentifier);
+    auto propertyInfo = parseJavaScriptCSSPropertyName(propertyName);
     if (!propertyInfo.propertyID)
         return false;
-
-    if (propertyInfo.hadPixelOrPosPrefix)
-        slot.setValue(this, DontDelete, cssPropertyGetterPixelOrPosPrefix(exec, this, propertyInfo.propertyID));
-    else
-        slot.setValue(this, DontDelete, cssPropertyGetter(exec, this, propertyInfo.propertyID));
+    slot.setValue(this, DontDelete, stylePropertyGetter(*state, *this, propertyInfo));
     return true;
 }
 
-bool JSCSSStyleDeclaration::putDelegate(ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot&, bool& putResult)
+bool JSCSSStyleDeclaration::putDelegate(ExecState* state, PropertyName propertyName, JSValue value, PutPropertySlot&, bool& putResult)
 {
-    CSSPropertyInfo propertyInfo = cssPropertyIDForJSCSSPropertyName(propertyName);
+    auto propertyInfo = parseJavaScriptCSSPropertyName(propertyName);
     if (!propertyInfo.propertyID)
         return false;
 
-    String propValue = valueToStringTreatingNullAsEmptyString(exec, value);
+    auto propertyValue = valueToStringTreatingNullAsEmptyString(state, value);
     if (propertyInfo.hadPixelOrPosPrefix)
-        propValue.append("px");
+        propertyValue.append("px");
 
     bool important = false;
     if (Settings::shouldRespectPriorityInCSSAttributeSetters()) {
-        size_t importantIndex = propValue.find("!important", 0, false);
-        if (importantIndex != notFound) {
+        auto importantIndex = propertyValue.findIgnoringASCIICase("!important");
+        if (importantIndex && importantIndex != notFound) {
             important = true;
-            propValue = propValue.left(importantIndex - 1);
+            propertyValue = propertyValue.left(importantIndex - 1);
         }
     }
 
-    ExceptionCode ec = 0;
-    CSSPropertyID propertyID = static_cast<CSSPropertyID>(propertyInfo.propertyID);
-    putResult = wrapped().setPropertyInternal(propertyID, propValue, important, ec);
-    setDOMException(exec, ec);
-
+    auto setPropertyInternalResult = wrapped().setPropertyInternal(propertyInfo.propertyID, propertyValue, important);
+    if (setPropertyInternalResult.hasException()) {
+        propagateException(*state, setPropertyInternalResult.releaseException());
+        return false;
+    }
+    putResult = setPropertyInternalResult.releaseReturnValue();
     return true;
 }
 
@@ -370,42 +356,37 @@ JSValue JSCSSStyleDeclaration::getPropertyCSSValue(ExecState& state)
     if (UNLIKELY(state.argumentCount() < 1))
         return throwException(&state, scope, createNotEnoughArgumentsError(&state));
 
-    String propertyName = state.uncheckedArgument(0).toWTFString(&state);
+    auto propertyName = state.uncheckedArgument(0).toWTFString(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
 
-    RefPtr<CSSValue> cssValue = wrapped().getPropertyCSSValue(propertyName);
-    if (!cssValue)
+    auto value = wrapped().getPropertyCSSValue(propertyName);
+    if (!value)
         return jsNull();
 
-    globalObject()->world().m_cssValueRoots.add(cssValue.get(), root(&wrapped())); // Balanced by JSCSSValueOwner::finalize().
-    return toJS(&state, globalObject(), *cssValue);
+    globalObject()->world().m_cssValueRoots.add(value.get(), root(&wrapped())); // Balanced by JSCSSValueOwner::finalize().
+    return toJS(&state, globalObject(), *value);
 }
 
-void JSCSSStyleDeclaration::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
+void JSCSSStyleDeclaration::getOwnPropertyNames(JSObject* object, ExecState* state, PropertyNameArray& propertyNames, EnumerationMode mode)
 {
-    JSCSSStyleDeclaration* thisObject = jsCast<JSCSSStyleDeclaration*>(object);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    unsigned length = thisObject->wrapped().length();
-    for (unsigned i = 0; i < length; ++i)
-        propertyNames.add(Identifier::from(exec, i));
-
-    static Identifier* propertyIdentifiers = 0;
-    if (!propertyIdentifiers) {
-        Vector<String, numCSSProperties> jsPropertyNames;
-        for (int id = firstCSSProperty; id < firstCSSProperty + numCSSProperties; ++id)
-            jsPropertyNames.append(getJSPropertyName(static_cast<CSSPropertyID>(id)));
-        std::sort(jsPropertyNames.begin(), jsPropertyNames.end(), WTF::codePointCompareLessThan);
-
-        propertyIdentifiers = new Identifier[numCSSProperties];
+    static const Identifier* const cssPropertyNames = [state] {
+        String names[numCSSProperties];
         for (int i = 0; i < numCSSProperties; ++i)
-            propertyIdentifiers[i] = Identifier::fromString(exec, jsPropertyNames[i]);
-    }
+            names[i] = getJSPropertyName(static_cast<CSSPropertyID>(firstCSSProperty + i));
+        std::sort(&names[0], &names[numCSSProperties], WTF::codePointCompareLessThan);
+        auto* identifiers = new Identifier[numCSSProperties];
+        for (int i = 0; i < numCSSProperties; ++i)
+            identifiers[i] = Identifier::fromString(state, names[i]);
+        return identifiers;
+    }();
 
+    unsigned length = jsCast<JSCSSStyleDeclaration*>(object)->wrapped().length();
+    for (unsigned i = 0; i < length; ++i)
+        propertyNames.add(Identifier::from(state, i));
     for (int i = 0; i < numCSSProperties; ++i)
-        propertyNames.add(propertyIdentifiers[i]);
+        propertyNames.add(cssPropertyNames[i]);
 
-    Base::getOwnPropertyNames(thisObject, exec, propertyNames, mode);
+    Base::getOwnPropertyNames(object, state, propertyNames, mode);
 }
 
 } // namespace WebCore
index 83d3061..fe3ca56 100644 (file)
@@ -965,4 +965,13 @@ template<typename T> inline JSC::JSValue toJSNumber(JSC::ExecState& state, JSC::
     return JSC::jsNumber(value.releaseReturnValue());
 }
 
+inline JSC::JSValue toJSString(JSC::ExecState& state, JSC::ThrowScope& throwScope, ExceptionOr<String>&& value)
+{
+    if (UNLIKELY(value.hasException())) {
+        propagateException(state, throwScope, value.releaseException());
+        return { };
+    }
+    return JSC::jsStringWithCache(&state, value.releaseReturnValue());
+}
+
 } // namespace WebCore
diff --git a/Source/WebCore/bindings/scripts/gobject-generate-headers.pl b/Source/WebCore/bindings/scripts/gobject-generate-headers.pl
deleted file mode 100644 (file)
index 9f2c69a..0000000
+++ /dev/null
@@ -1,131 +0,0 @@
-#!/usr/bin/perl -w
-#
-# Copyright (C) 2009 Adam Dingle <adam@yorba.org>
-# Copyright (C) 2015 Igalia S.L.
-#
-# This file is part of WebKit
-# 
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Library General Public
-# License as published by the Free Software Foundation; either
-# version 2 of the License, or (at your option) any later version.
-# 
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Library General Public License for more details.
-# 
-# You should have received a copy of the GNU Library General Public License
-# aint with this library; see the file COPYING.LIB.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-# Boston, MA 02110-1301, USA.
-# 
-
-my $classlist = <STDIN>;
-chomp($classlist);
-my @classes = split / /, $classlist;
-@classes = sort @classes;
-
-print <<EOF;
-/* This file is part of the WebKit open source project.
-   This file has been generated by gobject-generate-headers.pl.  DO NOT MODIFY!
-   
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
-*/
-
-EOF
-
-my $outType = $ARGV[0];
-my $header;
-if ($outType eq "defines") {
-    $header = "webkitdomdefines_h";
-} elsif ($outType eq "defines-unstable") {
-    $header = "webkitdomdefines_unstable_h";
-} elsif ($outType eq "gdom") {
-    $header = "webkitdom_h";
-} elsif ($outType eq "autocleanups") {
-    $header = "webkitdomautocleanups_h";
-} else {
-    die "unknown output type";
-}
-
-print "#ifndef ${header}\n";
-print "#define ${header}\n";
-print "\n";
-
-if ($outType eq "defines") {
-    print "#include <glib.h>\n\n";
-    print "#ifdef G_OS_WIN32\n";
-    print "    #ifdef BUILDING_WEBKIT\n";
-    print "        #define WEBKIT_API __declspec(dllexport)\n";
-    print "    #else\n";
-    print "        #define WEBKIT_API __declspec(dllimport)\n";
-    print "    #endif\n";
-    print "#else\n";
-    print "    #define WEBKIT_API __attribute__((visibility(\"default\")))\n";
-    print "#endif\n\n";
-    print "#define WEBKIT_DEPRECATED WEBKIT_API G_DEPRECATED\n";
-    print "#define WEBKIT_DEPRECATED_FOR(f) WEBKIT_API G_DEPRECATED_FOR(f)\n";
-    print "\n";
-    print "#ifndef WEBKIT_API\n";
-    print "    #define WEBKIT_API\n";
-    print "#endif\n";
-
-    foreach my $class (@classes) {
-        if ($class eq "EventTarget" || $class eq "NodeFilter" || $class eq "XPathNSResolver") {
-            print "typedef struct _WebKitDOM${class} WebKitDOM${class};\n";
-            print "typedef struct _WebKitDOM${class}Iface WebKitDOM${class}Iface;\n";
-            print "\n";
-        } elsif ($class ne "Deprecated" && $class ne "Custom") {
-            print "typedef struct _WebKitDOM${class} WebKitDOM${class};\n";
-            print "typedef struct _WebKitDOM${class}Class WebKitDOM${class}Class;\n";
-            print "\n";
-        }
-    }
-    print "#include <webkitdom/webkitdomautocleanups.h>\n";
-} elsif ($outType eq "defines-unstable") {
-    print "#include <webkitdom/webkitdomdefines.h>\n\n";
-    print "#ifdef WEBKIT_DOM_USE_UNSTABLE_API\n\n";
-
-    foreach my $class (@classes) {
-        print "typedef struct _WebKitDOM${class} WebKitDOM${class};\n";
-        print "typedef struct _WebKitDOM${class}Class WebKitDOM${class}Class;\n";
-        print "\n";
-    }
-
-    print "#include <webkitdom/webkitdomautocleanups-unstable.h>\n\n";
-    print "#endif /* WEBKIT_DOM_USE_UNSTABLE_API */\n\n";
-} elsif ($outType eq "gdom") {
-    print "#define __WEBKITDOM_H_INSIDE__\n\n";
-    foreach my $class (@classes) {
-        print "#include <webkitdom/WebKitDOM${class}.h>\n";
-    }
-    print "\n#undef __WEBKITDOM_H_INSIDE__\n";
-} elsif ($outType eq "autocleanups") {
-    print "#include <glib-object.h>\n\n";
-    print "#ifdef G_DEFINE_AUTOPTR_CLEANUP_FUNC\n";
-    print "#ifndef __GI_SCANNER__\n\n";
-    foreach my $class (@classes) {
-        if ($class ne "Deprecated" && $class ne "Custom") {
-            print "G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitDOM${class}, g_object_unref)\n";
-        }
-    }
-    print "\n#endif\n";
-    print "#endif\n";
-}
-
-print "\n";
-print "#endif\n";
index 4c47e13..08864fa 100644 (file)
@@ -146,7 +146,7 @@ static LengthSize convertToLengthSize(const CSSToLengthConversionData& conversio
     if (!value)
         return LengthSize(Length(0, Fixed), Length(0, Fixed));
 
-    Pair* pair = value->getPairValue();
+    Pair* pair = value->pairValue();
     return LengthSize(convertToLength(conversionData, pair->first()), convertToLength(conversionData, pair->second()));
 }
 
@@ -159,9 +159,9 @@ static BasicShapeCenterCoordinate convertToCenterCoordinate(const CSSToLengthCon
     if (!value)
         keyword = CSSValueCenter;
     else if (value->isValueID())
-        keyword = value->getValueID();
-    else if (Pair* pair = value->getPairValue()) {
-        keyword = pair->first()->getValueID();
+        keyword = value->valueID();
+    else if (Pair* pair = value->pairValue()) {
+        keyword = pair->first()->valueID();
         offset = convertToLength(conversionData, pair->second());
     } else
         offset = convertToLength(conversionData, value);
@@ -194,7 +194,7 @@ static BasicShapeRadius cssValueToBasicShapeRadius(const CSSToLengthConversionDa
         return BasicShapeRadius(BasicShapeRadius::ClosestSide);
 
     if (radius->isValueID()) {
-        switch (radius->getValueID()) {
+        switch (radius->valueID()) {
         case CSSValueClosestSide:
             return BasicShapeRadius(BasicShapeRadius::ClosestSide);
         case CSSValueFarthestSide:
index 7e9ce72..e412595 100644 (file)
@@ -45,8 +45,8 @@ namespace WebCore {
 
 static String serializePositionOffset(const Pair& offset, const Pair& other)
 {
-    if ((offset.first()->getValueID() == CSSValueLeft && other.first()->getValueID() == CSSValueTop)
-        || (offset.first()->getValueID() == CSSValueTop && other.first()->getValueID() == CSSValueLeft))
+    if ((offset.first()->valueID() == CSSValueLeft && other.first()->valueID() == CSSValueTop)
+        || (offset.first()->valueID() == CSSValueTop && other.first()->valueID() == CSSValueLeft))
         return offset.second()->cssText();
     return offset.cssText();
 }
@@ -59,9 +59,9 @@ static Ref<CSSPrimitiveValue> buildSerializablePositionOffset(CSSPrimitiveValue*
     if (!offset)
         side = CSSValueCenter;
     else if (offset->isValueID())
-        side = offset->getValueID();
-    else if (Pair* pair = offset->getPairValue()) {
-        side = pair->first()->getValueID();
+        side = offset->valueID();
+    else if (Pair* pair = offset->pairValue()) {
+        side = pair->first()->valueID();
         amount = pair->second();
     } else
         amount = offset;
@@ -73,8 +73,8 @@ static Ref<CSSPrimitiveValue> buildSerializablePositionOffset(CSSPrimitiveValue*
     } else if ((side == CSSValueRight || side == CSSValueBottom)
         && amount->isPercentage()) {
         side = defaultSide;
-        amount = cssValuePool.createValue(Length(100 - amount->getFloatValue(), Percent));
-    } else if (amount->isLength() && !amount->getFloatValue()) {
+        amount = cssValuePool.createValue(Length(100 - amount->floatValue(), Percent));
+    } else if (amount->isLength() && !amount->floatValue()) {
         if (side == CSSValueRight || side == CSSValueBottom)
             amount = cssValuePool.createValue(Length(100, Percent));
         else
@@ -114,12 +114,12 @@ String CSSBasicShapeCircle::cssText() const
     Ref<CSSPrimitiveValue> normalizedCY = buildSerializablePositionOffset(m_centerY.get(), CSSValueTop);
 
     String radius;
-    if (m_radius && m_radius->getValueID() != CSSValueClosestSide)
+    if (m_radius && m_radius->valueID() != CSSValueClosestSide)
         radius = m_radius->cssText();
 
     return buildCircleString(radius,
-        serializePositionOffset(*normalizedCX->getPairValue(), *normalizedCY->getPairValue()),
-        serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()));
+        serializePositionOffset(*normalizedCX->pairValue(), *normalizedCY->pairValue()),
+        serializePositionOffset(*normalizedCY->pairValue(), *normalizedCX->pairValue()));
 }
 
 bool CSSBasicShapeCircle::equals(const CSSBasicShape& shape) const
@@ -173,11 +173,11 @@ String CSSBasicShapeEllipse::cssText() const
     String radiusX;
     String radiusY;
     if (m_radiusX) {
-        bool shouldSerializeRadiusXValue = m_radiusX->getValueID() != CSSValueClosestSide;
+        bool shouldSerializeRadiusXValue = m_radiusX->valueID() != CSSValueClosestSide;
         bool shouldSerializeRadiusYValue = false;
 
         if (m_radiusY) {
-            shouldSerializeRadiusYValue = m_radiusY->getValueID() != CSSValueClosestSide;
+            shouldSerializeRadiusYValue = m_radiusY->valueID() != CSSValueClosestSide;
             if (shouldSerializeRadiusYValue)
                 radiusY = m_radiusY->cssText();
         }
@@ -185,8 +185,8 @@ String CSSBasicShapeEllipse::cssText() const
             radiusX = m_radiusX->cssText();
     }
     return buildEllipseString(radiusX, radiusY,
-        serializePositionOffset(*normalizedCX->getPairValue(), *normalizedCY->getPairValue()),
-        serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()));
+        serializePositionOffset(*normalizedCX->pairValue(), *normalizedCY->pairValue()),
+        serializePositionOffset(*normalizedCY->pairValue(), *normalizedCX->pairValue()));
 }
 
 bool CSSBasicShapeEllipse::equals(const CSSBasicShape& shape) const
@@ -383,7 +383,7 @@ static inline void updateCornerRadiusWidthAndHeight(CSSPrimitiveValue* corner, S
     if (!corner)
         return;
 
-    Pair* radius = corner->getPairValue();
+    Pair* radius = corner->pairValue();
     width = radius->first() ? radius->first()->cssText() : String("0");
     if (radius->second())
         height = radius->second()->cssText();
index 0872bde..2402f2c 100644 (file)
@@ -41,7 +41,7 @@ public:
 
     String customCSSText() const;
 
-    Quad* slices() const { return m_slices ? m_slices->getQuadValue() : nullptr; }
+    Quad* slices() const { return m_slices ? m_slices->quadValue() : nullptr; }
 
     bool equals(const CSSBorderImageSliceValue&) const;
 
index 2f32167..54e34b5 100644 (file)
@@ -217,7 +217,7 @@ public:
 private:
     bool isZero() const final
     {
-        return !m_value->getDoubleValue();
+        return !m_value->doubleValue();
     }
 
     String customCSSText() const final
@@ -229,7 +229,7 @@ private:
     {
         switch (category()) {
         case CalcNumber:
-            return std::make_unique<CalcExpressionNumber>(m_value->getFloatValue());
+            return std::make_unique<CalcExpressionNumber>(m_value->floatValue());
         case CalcLength:
             return std::make_unique<CalcExpressionLength>(Length(m_value->computeLength<float>(conversionData), WebCore::Fixed));
         case CalcPercent:
@@ -252,7 +252,7 @@ private:
     double doubleValue() const final
     {
         if (hasDoubleValue(primitiveType()))
-            return m_value->getDoubleValue();
+            return m_value->doubleValue();
         ASSERT_NOT_REACHED();
         return 0;
     }
@@ -264,7 +264,7 @@ private:
             return m_value->computeLength<double>(conversionData);
         case CalcPercent:
         case CalcNumber:
-            return m_value->getDoubleValue();
+            return m_value->doubleValue();
         case CalcPercentLength:
         case CalcPercentNumber:
         case CalcAngle:
index 5b68019..7a4140c 100644 (file)
@@ -19,8 +19,7 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef CSSCharsetRule_h
-#define CSSCharsetRule_h
+#pragma once
 
 #include "CSSRule.h"
 
@@ -33,22 +32,17 @@ public:
         return adoptRef(*new CSSCharsetRule(parent, encoding));
     }
 
-    virtual ~CSSCharsetRule() { }
-
-    String cssText() const final;
-    void reattach(StyleRuleBase&) final { }
-
     const String& encoding() const { return m_encoding; }
-    void setEncoding(const String& encoding, ExceptionCode&) { m_encoding = encoding; }
+    ExceptionOr<void> setEncoding(const String& encoding) { m_encoding = encoding; return { }; }
 
 private:
-    CSSRule::Type type() const final { return CHARSET_RULE; }
-
     CSSCharsetRule(CSSStyleSheet* parent, const String& encoding);
 
+    CSSRule::Type type() const final { return CHARSET_RULE; }
+    String cssText() const final;
+    void reattach(StyleRuleBase&) final { }
+
     String m_encoding;
 };
 
 } // namespace WebCore
-
-#endif // CSSCharsetRule_h
index f995817..de4140b 100644 (file)
@@ -18,8 +18,6 @@
  * Boston, MA 02110-1301, USA.
  */
 
-// Introduced in DOM Level 2:
 interface CSSCharsetRule : CSSRule {
-    [SetterMayThrowLegacyException] attribute DOMString? encoding;
+    [SetterMayThrowException] attribute DOMString? encoding;
 };
-
index 6859131..6801352 100644 (file)
@@ -1636,9 +1636,9 @@ String CSSComputedStyleDeclaration::cssText() const
     return result.toString();
 }
 
-void CSSComputedStyleDeclaration::setCssText(const String&, ExceptionCode& ec)
+ExceptionOr<void> CSSComputedStyleDeclaration::setCssText(const String&)
 {
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
 RefPtr<CSSPrimitiveValue> ComputedStyleExtractor::getFontSizeCSSValuePreferringKeyword() const
@@ -4001,7 +4001,7 @@ bool ComputedStyleExtractor::propertyMatches(CSSPropertyID propertyID, const CSS
         if (auto* style = m_node->computedStyle(m_pseudoElementSpecifier)) {
             if (CSSValueID sizeIdentifier = style->fontDescription().keywordSizeAsIdentifier()) {
                 auto& primitiveValue = downcast<CSSPrimitiveValue>(*value);
-                if (primitiveValue.isValueID() && primitiveValue.getValueID() == sizeIdentifier)
+                if (primitiveValue.isValueID() && primitiveValue.valueID() == sizeIdentifier)
                     return true;
             }
         }
@@ -4119,15 +4119,14 @@ bool CSSComputedStyleDeclaration::isPropertyImplicit(const String&)
     return false;
 }
 
-void CSSComputedStyleDeclaration::setProperty(const String&, const String&, const String&, ExceptionCode& ec)
+ExceptionOr<void> CSSComputedStyleDeclaration::setProperty(const String&, const String&, const String&)
 {
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
-String CSSComputedStyleDeclaration::removeProperty(const String&, ExceptionCode& ec)
+ExceptionOr<String> CSSComputedStyleDeclaration::removeProperty(const String&)
 {
-    ec = NO_MODIFICATION_ALLOWED_ERR;
-    return String();
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
     
 RefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValueInternal(CSSPropertyID propertyID)
@@ -4140,21 +4139,17 @@ String CSSComputedStyleDeclaration::getPropertyValueInternal(CSSPropertyID prope
     return getPropertyValue(propertyID);
 }
 
-bool CSSComputedStyleDeclaration::setPropertyInternal(CSSPropertyID, const String&, bool, ExceptionCode& ec)
+ExceptionOr<bool> CSSComputedStyleDeclaration::setPropertyInternal(CSSPropertyID, const String&, bool)
 {
-    ec = NO_MODIFICATION_ALLOWED_ERR;
-    return false;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
-RefPtr<CSSValueList> ComputedStyleExtractor::getBackgroundShorthandValue() const
+Ref<CSSValueList> ComputedStyleExtractor::getBackgroundShorthandValue() const
 {
-    static const CSSPropertyID propertiesBeforeSlashSeperator[5] = { CSSPropertyBackgroundColor, CSSPropertyBackgroundImage,
-                                                                     CSSPropertyBackgroundRepeat, CSSPropertyBackgroundAttachment,  
-                                                                     CSSPropertyBackgroundPosition };
-    static const CSSPropertyID propertiesAfterSlashSeperator[3] = { CSSPropertyBackgroundSize, CSSPropertyBackgroundOrigin, 
-                                                                    CSSPropertyBackgroundClip };
+    static const CSSPropertyID propertiesBeforeSlashSeperator[5] = { CSSPropertyBackgroundColor, CSSPropertyBackgroundImage, CSSPropertyBackgroundRepeat, CSSPropertyBackgroundAttachment, CSSPropertyBackgroundPosition };
+    static const CSSPropertyID propertiesAfterSlashSeperator[3] = { CSSPropertyBackgroundSize, CSSPropertyBackgroundOrigin, CSSPropertyBackgroundClip };
 
-    RefPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
+    auto list = CSSValueList::createSlashSeparated();
     list->append(*getCSSPropertyValuesForShorthandProperties(StylePropertyShorthand(CSSPropertyBackground, propertiesBeforeSlashSeperator)));
     list->append(*getCSSPropertyValuesForShorthandProperties(StylePropertyShorthand(CSSPropertyBackground, propertiesAfterSlashSeperator)));
     return list;
index a891705..55422ee 100644 (file)
@@ -18,8 +18,7 @@
  * 02110-1301  USA
  */
 
-#ifndef CSSComputedStyleDeclaration_h
-#define CSSComputedStyleDeclaration_h
+#pragma once
 
 #include "CSSStyleDeclaration.h"
 #include "RenderStyleConstants.h"
@@ -78,7 +77,7 @@ private:
 
     RefPtr<CSSValueList> getCSSPropertyValuesForShorthandProperties(const StylePropertyShorthand&) const;
     RefPtr<CSSValueList> getCSSPropertyValuesForSidesShorthand(const StylePropertyShorthand&) const;
-    RefPtr<CSSValueList> getBackgroundShorthandValue() const;
+    Ref<CSSValueList> getBackgroundShorthandValue() const;
     RefPtr<CSSValueList> getCSSPropertyValuesForGridShorthand(const StylePropertyShorthand&) const;
 
     RefPtr<Node> m_node;
@@ -111,13 +110,13 @@ private:
     String getPropertyPriority(const String& propertyName) final;
     String getPropertyShorthand(const String& propertyName) final;
     bool isPropertyImplicit(const String& propertyName) final;
-    void setProperty(const String& propertyName, const String& value, const String& priority, ExceptionCode&) final;
-    String removeProperty(const String& propertyName, ExceptionCode&) final;
+    ExceptionOr<void> setProperty(const String& propertyName, const String& value, const String& priority) final;
+    ExceptionOr<String> removeProperty(const String& propertyName) final;
     String cssText() const final;
-    void setCssText(const String&, ExceptionCode&) final;
+    ExceptionOr<void> setCssText(const String&) final;
     RefPtr<CSSValue> getPropertyCSSValueInternal(CSSPropertyID) final;
     String getPropertyValueInternal(CSSPropertyID) final;
-    bool setPropertyInternal(CSSPropertyID, const String& value, bool important, ExceptionCode&) final;
+    ExceptionOr<bool> setPropertyInternal(CSSPropertyID, const String& value, bool important) final;
     Ref<MutableStyleProperties> copyProperties() const final;
 
     RefPtr<CSSValue> getPropertyCSSValue(CSSPropertyID, EUpdateLayout = UpdateLayout) const;
@@ -129,5 +128,3 @@ private:
 };
 
 } // namespace WebCore
-
-#endif // CSSComputedStyleDeclaration_h
index 0cf79bc..31473d2 100644 (file)
@@ -84,7 +84,7 @@ String CSSCrossfadeValue::customCSSText() const
 
 FloatSize CSSCrossfadeValue::fixedSize(const RenderElement* renderer)
 {
-    float percentage = m_percentageValue->getFloatValue();
+    float percentage = m_percentageValue->floatValue();
     float inversePercentage = 1 - percentage;
 
     // FIXME: Skip Content Security Policy check when cross fade is applied to an element in a user agent shadow tree.
@@ -168,7 +168,7 @@ RefPtr<Image> CSSCrossfadeValue::image(RenderElement* renderer, const FloatSize&
     if (!fromImage || !toImage)
         return Image::nullImage();
 
-    m_generatedImage = CrossfadeGeneratedImage::create(*fromImage, *toImage, m_percentageValue->getFloatValue(), fixedSize(renderer), size);
+    m_generatedImage = CrossfadeGeneratedImage::create(*fromImage, *toImage, m_percentageValue->floatValue(), fixedSize(renderer), size);
 
     return m_generatedImage;
 }
@@ -202,10 +202,10 @@ RefPtr<CSSCrossfadeValue> CSSCrossfadeValue::blend(const CSSCrossfadeValue& from
     auto fromImageValue = CSSImageValue::create(*m_cachedFromImage);
     auto toImageValue = CSSImageValue::create(*m_cachedToImage);
 
-    double fromPercentage = from.m_percentageValue->getDoubleValue();
+    double fromPercentage = from.m_percentageValue->doubleValue();
     if (from.m_percentageValue->isPercentage())
         fromPercentage /= 100.0;
-    double toPercentage = m_percentageValue->getDoubleValue();
+    double toPercentage = m_percentageValue->doubleValue();
     if (m_percentageValue->isPercentage())
         toPercentage /= 100.0;
     auto percentageValue = CSSPrimitiveValue::create(blendFunc(fromPercentage, toPercentage, progress), CSSPrimitiveValue::CSS_NUMBER);
index 5182af7..a75401b 100644 (file)
@@ -129,7 +129,7 @@ Optional<FontTraitsMask> CSSFontFace::calculateStyleMask(CSSValue& style)
     if (!is<CSSPrimitiveValue>(style))
         return Nullopt;
 
-    switch (downcast<CSSPrimitiveValue>(style).getValueID()) {
+    switch (downcast<CSSPrimitiveValue>(style).valueID()) {
     case CSSValueNormal:
         return FontStyleNormalMask;
     case CSSValueItalic:
@@ -164,7 +164,7 @@ Optional<FontTraitsMask> CSSFontFace::calculateWeightMask(CSSValue& weight)
     if (!is<CSSPrimitiveValue>(weight))
         return Nullopt;
 
-    switch (downcast<CSSPrimitiveValue>(weight).getValueID()) {
+    switch (downcast<CSSPrimitiveValue>(weight).valueID()) {
     case CSSValueBold:
     case CSSValueBolder:
     case CSSValue700:
index 9e9d177..522ac86 100644 (file)
@@ -34,6 +34,7 @@
 #include "CSSSegmentedFontFace.h"
 #include "CSSValueList.h"
 #include "CSSValuePool.h"
+#include "ExceptionCode.h"
 #include "FontCache.h"
 #include "StyleProperties.h"
 
@@ -128,7 +129,7 @@ String CSSFontFaceSet::familyNameFromPrimitive(const CSSPrimitiveValue& value)
 
     // We need to use the raw text for all the generic family types, since @font-face is a way of actually
     // defining what font to use for those types.
-    switch (value.getValueID()) {
+    switch (value.valueID()) {
     case CSSValueSerif:
         return serifFamily;
     case CSSValueSansSerif:
@@ -247,7 +248,7 @@ void CSSFontFaceSet::remove(const CSSFontFace& face)
     ASSERT_NOT_REACHED();
 }
 
-CSSFontFace* CSSFontFaceSet::lookupByCSSConnection(StyleRuleFontFace& target)
+CSSFontFace* CSSFontFaceSet::lookUpByCSSConnection(StyleRuleFontFace& target)
 {
     return m_constituentCSSConnections.get(&target);
 }
@@ -324,35 +325,28 @@ static HashSet<UChar32> codePointsFromString(StringView stringView)
     return result;
 }
 
-Vector<std::reference_wrapper<CSSFontFace>> CSSFontFaceSet::matchingFaces(const String& font, const String& string, ExceptionCode& ec)
+ExceptionOr<Vector<std::reference_wrapper<CSSFontFace>>> CSSFontFaceSet::matchingFaces(const String& font, const String& string)
 {
-    Vector<std::reference_wrapper<CSSFontFace>> result;
     auto style = MutableStyleProperties::create();
     auto parseResult = CSSParser::parseValue(style, CSSPropertyFont, font, true, HTMLStandardMode, nullptr);
-    if (parseResult == CSSParser::ParseResult::Error) {
-        ec = SYNTAX_ERR;
-        return result;
-    }
+    if (parseResult == CSSParser::ParseResult::Error)
+        return Exception { SYNTAX_ERR };
 
     FontTraitsMask fontTraitsMask;
     if (auto maskOptional = computeFontTraitsMask(style.get()))
         fontTraitsMask = maskOptional.value();
-    else {
-        ec = SYNTAX_ERR;
-        return result;
-    }
+    else
+        return Exception { SYNTAX_ERR };
 
-    RefPtr<CSSValue> family = style->getPropertyCSSValue(CSSPropertyFontFamily);
-    if (!is<CSSValueList>(family.get())) {
-        ec = SYNTAX_ERR;
-        return result;
-    }
+    auto family = style->getPropertyCSSValue(CSSPropertyFontFamily);
+    if (!is<CSSValueList>(family.get()))
+        return Exception { SYNTAX_ERR };
     CSSValueList& familyList = downcast<CSSValueList>(*family);
 
     HashSet<AtomicString> uniqueFamilies;
     Vector<AtomicString> familyOrder;
     for (auto& family : familyList) {
-        const CSSPrimitiveValue& primitive = downcast<CSSPrimitiveValue>(family.get());
+        auto& primitive = downcast<CSSPrimitiveValue>(family.get());
         if (!primitive.isFontFamily())
             continue;
         if (uniqueFamilies.add(primitive.fontFamily().familyName).isNewEntry)
@@ -363,7 +357,7 @@ Vector<std::reference_wrapper<CSSFontFace>> CSSFontFaceSet::matchingFaces(const
     for (auto codePoint : codePointsFromString(string)) {
         bool found = false;
         for (auto& family : familyOrder) {
-            CSSSegmentedFontFace* faces = getFontFace(fontTraitsMask, family);
+            auto* faces = fontFace(fontTraitsMask, family);
             if (!faces)
                 continue;
             for (auto& constituentFace : faces->constituentFaces()) {
@@ -378,19 +372,20 @@ Vector<std::reference_wrapper<CSSFontFace>> CSSFontFaceSet::matchingFaces(const
         }
     }
 
+    Vector<std::reference_wrapper<CSSFontFace>> result;
+    result.reserveInitialCapacity(resultConstituents.size());
     for (auto* constituent : resultConstituents)
-        result.append(*constituent);
-
-    return result;
+        result.uncheckedAppend(*constituent);
+    return WTFMove(result);
 }
 
-bool CSSFontFaceSet::check(const String& font, const String& text, ExceptionCode& ec)
+ExceptionOr<bool> CSSFontFaceSet::check(const String& font, const String& text)
 {
-    auto matchingFaces = this->matchingFaces(font, text, ec);
-    if (ec)
-        return false;
+    auto matchingFaces = this->matchingFaces(font, text);
+    if (matchingFaces.hasException())
+        return matchingFaces.releaseException();
 
-    for (auto& face : matchingFaces) {
+    for (auto& face : matchingFaces.releaseReturnValue()) {
         if (face.get().status() == CSSFontFace::Status::Pending)
             return false;
     }
@@ -456,7 +451,7 @@ static bool fontFaceComparator(FontTraitsMask desiredTraitsMaskForComparison, co
     return false;
 }
 
-CSSSegmentedFontFace* CSSFontFaceSet::getFontFace(FontTraitsMask traitsMask, const AtomicString& family)
+CSSSegmentedFontFace* CSSFontFaceSet::fontFace(FontTraitsMask traitsMask, const AtomicString& family)
 {
     auto iterator = m_facesLookupTable.find(family);
     if (iterator == m_facesLookupTable.end())
index cdf88ba..7913402 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef CSSFontFaceSet_h
-#define CSSFontFaceSet_h
+#pragma once
 
 #include "CSSFontFace.h"
 #include <wtf/HashMap.h>
@@ -64,23 +63,20 @@ public:
     void clear();
     CSSFontFace& operator[](size_t i);
 
-    CSSFontFace* lookupByCSSConnection(StyleRuleFontFace&);
+    CSSFontFace* lookUpByCSSConnection(StyleRuleFontFace&);
 
-    bool check(const String& font, const String& text, ExceptionCode&);
+    ExceptionOr<bool> check(const String& font, const String& text);
 
-    CSSSegmentedFontFace* getFontFace(FontTraitsMask, const AtomicString& family);
+    CSSSegmentedFontFace* fontFace(FontTraitsMask, const AtomicString& family);
 
-    enum class Status {
-        Loading,
-        Loaded
-    };
+    enum class Status { Loading, Loaded };
     Status status() const { return m_status; }
 
-    Vector<std::reference_wrapper<CSSFontFace>> matchingFaces(const String& font, const String& text, ExceptionCode&);
+    ExceptionOr<Vector<std::reference_wrapper<CSSFontFace>>> matchingFaces(const String& font, const String& text);
 
     // CSSFontFace::Client needs to be able to be held in a RefPtr.
-    void ref() override { RefCounted<CSSFontFaceSet>::ref(); }
-    void deref() override { RefCounted<CSSFontFaceSet>::deref(); }
+    void ref() final { RefCounted::ref(); }
+    void deref() final { RefCounted::deref(); }
 
 private:
     CSSFontFaceSet();
@@ -91,8 +87,8 @@ private:
     void incrementActiveCount();
     void decrementActiveCount();
 
-    void fontStateChanged(CSSFontFace&, CSSFontFace::Status oldState, CSSFontFace::Status newState) override;
-    void fontPropertyChanged(CSSFontFace&, CSSValueList* oldFamilies = nullptr) override;
+    void fontStateChanged(CSSFontFace&, CSSFontFace::Status oldState, CSSFontFace::Status newState) final;
+    void fontPropertyChanged(CSSFontFace&, CSSValueList* oldFamilies = nullptr) final;
 
     void ensureLocalFontFacesForFamilyRegistered(const String&);
 
@@ -111,5 +107,3 @@ private:
 };
 
 }
-
-#endif
index 5ee0872..b4ec44d 100644 (file)
@@ -205,7 +205,7 @@ void CSSFontSelector::addFontFaceRule(StyleRuleFontFace& fontFaceRule, bool isIn
     if (fontFace->allSourcesFailed())
         return;
 
-    if (RefPtr<CSSFontFace> existingFace = m_cssFontFaceSet->lookupByCSSConnection(fontFaceRule)) {
+    if (RefPtr<CSSFontFace> existingFace = m_cssFontFaceSet->lookUpByCSSConnection(fontFaceRule)) {
         m_cssFontFaceSet->remove(*existingFace);
         if (auto* existingWrapper = existingFace->existingWrapper())
             existingWrapper->adopt(fontFace.get());
@@ -286,7 +286,7 @@ FontRanges CSSFontSelector::fontRangesForFamily(const FontDescription& fontDescr
     bool resolveGenericFamilyFirst = familyName == standardFamily;
 
     AtomicString familyForLookup = resolveGenericFamilyFirst ? resolveGenericFamily(m_document, fontDescription, familyName) : familyName;
-    CSSSegmentedFontFace* face = m_cssFontFaceSet->getFontFace(fontDescription.traitsMask(), familyForLookup);
+    auto* face = m_cssFontFaceSet->fontFace(fontDescription.traitsMask(), familyForLookup);
     if (!face) {
         if (!resolveGenericFamilyFirst)
             familyForLookup = resolveGenericFamily(m_document, fontDescription, familyName);
index 5caa241..5951cab 100644 (file)
@@ -75,8 +75,8 @@ RefPtr<Image> CSSGradientValue::image(RenderElement* renderer, const FloatSize&
 // Should only ever be called for deprecated gradients.
 static inline bool compareStops(const CSSGradientColorStop& a, const CSSGradientColorStop& b)
 {
-    double aVal = a.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER);
-    double bVal = b.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER);
+    double aVal = a.m_position->doubleValue(CSSPrimitiveValue::CSS_NUMBER);
+    double bVal = b.m_position->doubleValue(CSSPrimitiveValue::CSS_NUMBER);
 
     return aVal < bVal;
 }
@@ -160,9 +160,9 @@ void CSSGradientValue::addStops(Gradient& gradient, const CSSToLengthConversionD
 
             float offset;
             if (stop.m_position->isPercentage())
-                offset = stop.m_position->getFloatValue(CSSPrimitiveValue::CSS_PERCENTAGE) / 100;
+                offset = stop.m_position->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE) / 100;
             else
-                offset = stop.m_position->getFloatValue(CSSPrimitiveValue::CSS_NUMBER);
+                offset = stop.m_position->floatValue(CSSPrimitiveValue::CSS_NUMBER);
 
             gradient.addColorStop(offset, stop.m_resolvedColor);
         }
@@ -195,7 +195,7 @@ void CSSGradientValue::addStops(Gradient& gradient, const CSSToLengthConversionD
         if (stop.m_position) {
             const CSSPrimitiveValue& positionValue = *stop.m_position;
             if (positionValue.isPercentage())
-                stops[i].offset = positionValue.getFloatValue(CSSPrimitiveValue::CSS_PERCENTAGE) / 100;
+                stops[i].offset = positionValue.floatValue(CSSPrimitiveValue::CSS_PERCENTAGE) / 100;
             else if (positionValue.isLength() || positionValue.isViewportPercentageLength() || positionValue.isCalculatedPercentageWithLength()) {
                 if (!computedGradientLength) {
                     FloatSize gradientSize(gradientStart - gradientEnd);
@@ -497,18 +497,18 @@ void CSSGradientValue::addStops(Gradient& gradient, const CSSToLengthConversionD
 static float positionFromValue(CSSPrimitiveValue& value, const CSSToLengthConversionData& conversionData, const FloatSize& size, bool isHorizontal)
 {
     if (value.isNumber())
-        return value.getFloatValue() * conversionData.zoom();
+        return value.floatValue() * conversionData.zoom();
 
     int edgeDistance = isHorizontal ? size.width() : size.height();
     if (value.isPercentage())
-        return value.getFloatValue() / 100.f * edgeDistance;
+        return value.floatValue() / 100.f * edgeDistance;
 
     if (value.isCalculatedPercentageWithLength()) {
         Ref<CalculationValue> calculationValue { value.cssCalcValue()->createCalculationValue(conversionData) };
         return calculationValue->evaluate(edgeDistance);
     }
 
-    switch (value.getValueID()) {
+    switch (value.valueID()) {
     case CSSValueTop:
         ASSERT(!isHorizontal);
         return 0;
@@ -581,20 +581,20 @@ String CSSLinearGradientValue::customCSSText() const
         result.append(' ');
         result.append(m_secondY->cssText());
 
-        for (unsigned i = 0; i < m_stops.size(); i++) {
-            const CSSGradientColorStop& stop = m_stops[i];
+        for (auto& stop : m_stops) {
             result.appendLiteral(", ");
-            if (stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER) == 0) {
+            auto position = stop.m_position->doubleValue(CSSPrimitiveValue::CSS_NUMBER);
+            if (!position) {
                 result.appendLiteral("from(");
                 result.append(stop.m_color->cssText());
                 result.append(')');
-            } else if (stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER) == 1) {
+            } else if (position == 1) {
                 result.appendLiteral("to(");
                 result.append(stop.m_color->cssText());
                 result.append(')');
             } else {
                 result.appendLiteral("color-stop(");
-                result.appendNumber(stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER));
+                result.appendNumber(position);
                 result.appendLiteral(", ");
                 result.append(stop.m_color->cssText());
                 result.append(')');
@@ -642,7 +642,7 @@ String CSSLinearGradientValue::customCSSText() const
         if (m_angle && m_angle->computeDegrees() != 180) {
             result.append(m_angle->cssText());
             wroteSomething = true;
-        } else if ((m_firstX || m_firstY) && !(!m_firstX && m_firstY && m_firstY->getValueID() == CSSValueBottom)) {
+        } else if ((m_firstX || m_firstY) && !(!m_firstX && m_firstY && m_firstY->valueID() == CSSValueBottom)) {
             result.appendLiteral("to ");
             if (m_firstX && m_firstY) {
                 result.append(m_firstX->cssText());
@@ -754,7 +754,7 @@ Ref<Gradient> CSSLinearGradientValue::createGradient(RenderElement& renderer, co
     FloatPoint firstPoint;
     FloatPoint secondPoint;
     if (m_angle) {
-        float angle = m_angle->getFloatValue(CSSPrimitiveValue::CSS_DEG);
+        float angle = m_angle->floatValue(CSSPrimitiveValue::CSS_DEG);
         endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
     } else {
         switch (m_gradientType) {
@@ -781,9 +781,9 @@ Ref<Gradient> CSSLinearGradientValue::createGradient(RenderElement& renderer, co
                 // "Magic" corners, so the 50% line touches two corners.
                 float rise = size.width();
                 float run = size.height();
-                if (m_firstX && m_firstX->getValueID() == CSSValueLeft)
+                if (m_firstX && m_firstX->valueID() == CSSValueLeft)
                     run *= -1;
-                if (m_firstY && m_firstY->getValueID() == CSSValueBottom)
+                if (m_firstY && m_firstY->valueID() == CSSValueBottom)
                     rise *= -1;
                 // Compute angle, and flip it back to "bearing angle" degrees.
                 float angle = 90 - rad2deg(atan2(rise, run));
@@ -862,20 +862,20 @@ String CSSRadialGradientValue::customCSSText() const
         result.append(m_secondRadius->cssText());
 
         // FIXME: share?
-        for (unsigned i = 0; i < m_stops.size(); i++) {
-            const CSSGradientColorStop& stop = m_stops[i];
+        for (auto& stop : m_stops) {
             result.appendLiteral(", ");
-            if (stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER) == 0) {
+            auto position = stop.m_position->doubleValue(CSSPrimitiveValue::CSS_NUMBER);
+            if (!position) {
                 result.appendLiteral("from(");
                 result.append(stop.m_color->cssText());
                 result.append(')');
-            } else if (stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER) == 1) {
+            } else if (position == 1) {
                 result.appendLiteral("to(");
                 result.append(stop.m_color->cssText());
                 result.append(')');
             } else {
                 result.appendLiteral("color-stop(");
-                result.appendNumber(stop.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER));
+                result.appendNumber(position);
                 result.appendLiteral(", ");
                 result.append(stop.m_color->cssText());
                 result.append(')');
@@ -937,12 +937,12 @@ String CSSRadialGradientValue::customCSSText() const
 
         // The only ambiguous case that needs an explicit shape to be provided
         // is when a sizing keyword is used (or all sizing is omitted).
-        if (m_shape && m_shape->getValueID() != CSSValueEllipse && (m_sizingBehavior || (!m_sizingBehavior && !m_endHorizontalSize))) {
+        if (m_shape && m_shape->valueID() != CSSValueEllipse && (m_sizingBehavior || (!m_sizingBehavior && !m_endHorizontalSize))) {
             result.appendLiteral("circle");
             wroteSomething = true;
         }
 
-        if (m_sizingBehavior && m_sizingBehavior->getValueID() != CSSValueFarthestCorner) {
+        if (m_sizingBehavior && m_sizingBehavior->valueID() != CSSValueFarthestCorner) {
             if (wroteSomething)
                 result.append(' ');
             result.append(m_sizingBehavior->cssText());
@@ -999,9 +999,9 @@ float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue& radius, const CSS
 {
     float result = 0;
     if (radius.isNumber()) // Can the radius be a percentage?
-        result = radius.getFloatValue() * conversionData.zoom();
+        result = radius.floatValue() * conversionData.zoom();
     else if (widthOrHeight && radius.isPercentage())
-        result = *widthOrHeight * radius.getFloatValue() / 100;
+        result = *widthOrHeight * radius.floatValue() / 100;
     else
         result = radius.computeLength<float>(conversionData);
 
@@ -1122,14 +1122,14 @@ Ref<Gradient> CSSRadialGradientValue::createGradient(RenderElement& renderer, co
     } else {
         enum GradientShape { Circle, Ellipse };
         GradientShape shape = Ellipse;
-        if ((m_shape && m_shape->getValueID() == CSSValueCircle)
+        if ((m_shape && m_shape->valueID() == CSSValueCircle)
             || (!m_shape && !m_sizingBehavior && m_endHorizontalSize && !m_endVerticalSize))
             shape = Circle;
 
         enum GradientFill { ClosestSide, ClosestCorner, FarthestSide, FarthestCorner };
         GradientFill fill = FarthestCorner;
 
-        switch (m_sizingBehavior ? m_sizingBehavior->getValueID() : 0) {
+        switch (m_sizingBehavior ? m_sizingBehavior->valueID() : 0) {
         case CSSValueContain:
         case CSSValueClosestSide:
             fill = ClosestSide;
index 5a6d5f0..b4ff607 100644 (file)
@@ -57,14 +57,13 @@ CSSGroupingRule::~CSSGroupingRule()
     }
 }
 
-unsigned CSSGroupingRule::insertRule(const String& ruleString, unsigned index, ExceptionCode& ec)
+ExceptionOr<unsigned> CSSGroupingRule::insertRule(const String& ruleString, unsigned index)
 {
     ASSERT(m_childRuleCSSOMWrappers.size() == m_groupRule->childRules().size());
 
     if (index > m_groupRule->childRules().size()) {
         // INDEX_SIZE_ERR: Raised if the specified index is not a valid insertion point.
-        ec = INDEX_SIZE_ERR;
-        return 0;
+        return Exception { INDEX_SIZE_ERR };
     }
 
     CSSParser parser(parserContext());
@@ -72,8 +71,7 @@ unsigned CSSGroupingRule::insertRule(const String& ruleString, unsigned index, E
     RefPtr<StyleRuleBase> newRule = parser.parseRule(styleSheet ? &styleSheet->contents() : nullptr, ruleString);
     if (!newRule) {
         // SYNTAX_ERR: Raised if the specified rule has a syntax error and is unparsable.
-        ec = SYNTAX_ERR;
-        return 0;
+        return Exception { SYNTAX_ERR };
     }
 
     if (newRule->isImportRule()) {
@@ -84,8 +82,7 @@ unsigned CSSGroupingRule::insertRule(const String& ruleString, unsigned index, E
         // HIERARCHY_REQUEST_ERR: Raised if the rule cannot be inserted at the specified
         // index, e.g., if an @import rule is inserted after a standard rule set or other
         // at-rule.
-        ec = HIERARCHY_REQUEST_ERR;
-        return 0;
+        return Exception { HIERARCHY_REQUEST_ERR };
     }
     CSSStyleSheet::RuleMutationScope mutationScope(this);
 
@@ -95,15 +92,14 @@ unsigned CSSGroupingRule::insertRule(const String& ruleString, unsigned index, E
     return index;
 }
 
-void CSSGroupingRule::deleteRule(unsigned index, ExceptionCode& ec)
+ExceptionOr<void> CSSGroupingRule::deleteRule(unsigned index)
 {
     ASSERT(m_childRuleCSSOMWrappers.size() == m_groupRule->childRules().size());
 
     if (index >= m_groupRule->childRules().size()) {
         // INDEX_SIZE_ERR: Raised if the specified index does not correspond to a
         // rule in the media rule list.
-        ec = INDEX_SIZE_ERR;
-        return;
+        return Exception { INDEX_SIZE_ERR };
     }
 
     CSSStyleSheet::RuleMutationScope mutationScope(this);
@@ -113,6 +109,8 @@ void CSSGroupingRule::deleteRule(unsigned index, ExceptionCode& ec)
     if (m_childRuleCSSOMWrappers[index])
         m_childRuleCSSOMWrappers[index]->setParentRule(0);
     m_childRuleCSSOMWrappers.remove(index);
+
+    return { };
 }
 
 void CSSGroupingRule::appendCssTextForItems(StringBuilder& result) const
index 4ff1600..f54a397 100644 (file)
 #pragma once
 
 #include "CSSRule.h"
-#include "StyleRule.h"
 #include <memory>
 #include <wtf/Vector.h>
 
 namespace WebCore {
 
 class CSSRuleList;
+class StyleRuleGroup;
 
 class CSSGroupingRule : public CSSRule {
 public:
     virtual ~CSSGroupingRule();
 
-    void reattach(StyleRuleBase&) override;
-
     WEBCORE_EXPORT CSSRuleList& cssRules() const;
 
-    WEBCORE_EXPORT unsigned insertRule(const String& rule, unsigned index, ExceptionCode&);
-    WEBCORE_EXPORT void deleteRule(unsigned index, ExceptionCode&);
+    WEBCORE_EXPORT ExceptionOr<unsigned> insertRule(const String& rule, unsigned index);
+    WEBCORE_EXPORT ExceptionOr<void> deleteRule(unsigned index);
         
     // For CSSRuleList
     unsigned length() const;
@@ -49,9 +47,13 @@ public:
 protected:
     CSSGroupingRule(StyleRuleGroup& groupRule, CSSStyleSheet* parent);
     
+    void reattach(StyleRuleBase&) override;
+
     void appendCssTextForItems(StringBuilder&) const;
 
     Ref<StyleRuleGroup> m_groupRule;
+
+private:
     mutable Vector<RefPtr<CSSRule>> m_childRuleCSSOMWrappers;
     mutable std::unique_ptr<CSSRuleList> m_ruleListCSSOMWrapper;
 };
index e3b6d32..a75283a 100644 (file)
@@ -240,7 +240,7 @@ bool CSSImageGeneratorValue::subimageIsPending(const CSSValue& value)
     if (is<CSSImageGeneratorValue>(value))
         return downcast<CSSImageGeneratorValue>(value).isPending();
 
-    if (is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone)
+    if (is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone)
         return false;
 
     ASSERT_NOT_REACHED();
@@ -261,7 +261,7 @@ CachedImage* CSSImageGeneratorValue::cachedImageForCSSValue(CSSValue& value, Cac
         return nullptr;
     }
 
-    if (is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone)
+    if (is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone)
         return nullptr;
 
     ASSERT_NOT_REACHED();
index 5a9c222..5e11b2c 100644 (file)
@@ -59,7 +59,7 @@ void CSSImageSetValue::fillImageSet()
         ++i;
         ASSERT_WITH_SECURITY_IMPLICATION(i < length);
         CSSValue* scaleFactorValue = item(i);
-        float scaleFactor = downcast<CSSPrimitiveValue>(*scaleFactorValue).getFloatValue();
+        float scaleFactor = downcast<CSSPrimitiveValue>(*scaleFactorValue).floatValue();
 
         ImageWithScale image;
         image.imageURL = imageURL;
index fb1bc4e..2160fac 100644 (file)
@@ -27,6 +27,7 @@
 namespace WebCore {
 
 class MediaList;
+class MediaQuerySet;
 class StyleRuleMedia;
 
 class CSSMediaRule final : public CSSGroupingRule {
index 4eda897..cf21555 100644 (file)
@@ -22,6 +22,6 @@ interface CSSMediaRule : CSSRule {
     readonly attribute MediaList media;
     readonly attribute CSSRuleList cssRules;
 
-    [MayThrowLegacyException] unsigned long insertRule(optional DOMString rule = "undefined", optional unsigned long index = 0);
-    [MayThrowLegacyException] void deleteRule(optional unsigned long index = 0);
+    [MayThrowException] unsigned long insertRule(optional DOMString rule = "undefined", optional unsigned long index = 0);
+    [MayThrowException] void deleteRule(optional unsigned long index = 0);
 };
index 987713c..f4b32d4 100644 (file)
@@ -629,13 +629,13 @@ double CSSPrimitiveValue::computeDegrees() const
 {
     switch (primitiveType()) {
     case CSS_DEG:
-        return getDoubleValue();
+        return doubleValue();
     case CSS_RAD:
-        return rad2deg(getDoubleValue());
+        return rad2deg(doubleValue());
     case CSS_GRAD:
-        return grad2deg(getDoubleValue());
+        return grad2deg(doubleValue());
     case CSS_TURN:
-        return turn2deg(getDoubleValue());
+        return turn2deg(doubleValue());
     default:
         ASSERT_NOT_REACHED();
         return 0;
@@ -683,10 +683,10 @@ double CSSPrimitiveValue::computeLengthDouble(const CSSToLengthConversionData& c
         // The multiplier and factor is applied to each value in the calc expression individually
         return m_value.calc->computeLengthPx(conversionData);
 
-    return computeNonCalcLengthDouble(conversionData, primitiveType(), m_value.num);
+    return computeNonCalcLengthDouble(conversionData, static_cast<UnitTypes>(primitiveType()), m_value.num);
 }
 
-double CSSPrimitiveValue::computeNonCalcLengthDouble(const CSSToLengthConversionData& conversionData, unsigned short primitiveType, double value)
+double CSSPrimitiveValue::computeNonCalcLengthDouble(const CSSToLengthConversionData& conversionData, UnitTypes primitiveType, double value)
 {
     double factor;
 
@@ -766,15 +766,15 @@ double CSSPrimitiveValue::computeNonCalcLengthDouble(const CSSToLengthConversion
     return result * conversionData.zoom();
 }
 
-void CSSPrimitiveValue::setFloatValue(unsigned short, double, ExceptionCode& ec)
+ExceptionOr<void> CSSPrimitiveValue::setFloatValue(unsigned short, double)
 {
     // Keeping values immutable makes optimizations easier and allows sharing of the primitive value objects.
     // No other engine supports mutating style through this API. Computed style is always read-only anyway.
     // Supporting setter would require making primitive value copy-on-write and taking care of style invalidation.
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
-double CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(unsigned short unitType)
+double CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(UnitTypes unitType)
 {
     double factor = 1.0;
     // FIXME: the switch can be replaced by an array of scale factors.
@@ -826,27 +826,20 @@ double CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(unsigned short u
     return factor;
 }
 
-double CSSPrimitiveValue::getDoubleValue(unsigned short unitType, ExceptionCode& ec) const
+ExceptionOr<float> CSSPrimitiveValue::getFloatValue(unsigned short unitType) const
 {
-    double result = 0;
-    bool success = getDoubleValueInternal(static_cast<UnitTypes>(unitType), &result);
-    if (!success) {
-        ec = INVALID_ACCESS_ERR;
-        return 0.0;
-    }
-
-    ec = 0;
-    return result;
+    auto result = doubleValueInternal(static_cast<UnitTypes>(unitType));
+    if (!result)
+        return Exception { INVALID_ACCESS_ERR };
+    return clampTo<float>(result.value());
 }
 
-double CSSPrimitiveValue::getDoubleValue(unsigned short unitType) const
+double CSSPrimitiveValue::doubleValue(UnitTypes unitType) const
 {
-    double result = 0;
-    getDoubleValueInternal(static_cast<UnitTypes>(unitType), &result);
-    return result;
+    return doubleValueInternal(unitType).valueOr(0);
 }
 
-double CSSPrimitiveValue::getDoubleValue() const
+double CSSPrimitiveValue::doubleValue() const
 {
     return m_primitiveUnitType != CSS_CALC ? m_value.num : m_value.calc->doubleValue();
 }
@@ -878,16 +871,14 @@ CSSPrimitiveValue::UnitTypes CSSPrimitiveValue::canonicalUnitTypeForCategory(Uni
     }
 }
 
-bool CSSPrimitiveValue::getDoubleValueInternal(UnitTypes requestedUnitType, double* result) const
+Optional<double> CSSPrimitiveValue::doubleValueInternal(UnitTypes requestedUnitType) const
 {
     if (!isValidCSSUnitTypeForDoubleConversion(static_cast<UnitTypes>(m_primitiveUnitType)) || !isValidCSSUnitTypeForDoubleConversion(requestedUnitType))
-        return false;
+        return Nullopt;
 
     UnitTypes sourceUnitType = static_cast<UnitTypes>(primitiveType());
-    if (requestedUnitType == sourceUnitType || requestedUnitType == CSS_DIMENSION) {
-        *result = getDoubleValue();
-        return true;
-    }
+    if (requestedUnitType == sourceUnitType || requestedUnitType == CSS_DIMENSION)
+        return doubleValue();
 
     UnitCategory sourceCategory = unitCategory(sourceUnitType);
     ASSERT(sourceCategory != UOther);
@@ -898,23 +889,23 @@ bool CSSPrimitiveValue::getDoubleValueInternal(UnitTypes requestedUnitType, doub
 
     // Cannot convert between unrelated unit categories if one of them is not UNumber.
     if (sourceCategory != targetCategory && sourceCategory != UNumber && targetCategory != UNumber)
-        return false;
+        return Nullopt;
 
     if (targetCategory == UNumber) {
         // We interpret conversion to CSS_NUMBER as conversion to a canonical unit in this value's category.
         targetUnitType = canonicalUnitTypeForCategory(sourceCategory);
         if (targetUnitType == CSS_UNKNOWN)
-            return false;
+            return Nullopt;
     }
 
     if (sourceUnitType == CSS_NUMBER) {
         // We interpret conversion from CSS_NUMBER in the same way as CSSParser::validUnit() while using non-strict mode.
         sourceUnitType = canonicalUnitTypeForCategory(targetCategory);
         if (sourceUnitType == CSS_UNKNOWN)
-            return false;
+            return Nullopt;
     }
 
-    double convertedValue = getDoubleValue();
+    double convertedValue = doubleValue();
 
     // First convert the value from m_primitiveUnitType to canonical type.
     double factor = conversionToCanonicalUnitsScaleFactor(sourceUnitType);
@@ -924,41 +915,36 @@ bool CSSPrimitiveValue::getDoubleValueInternal(UnitTypes requestedUnitType, doub
     factor = conversionToCanonicalUnitsScaleFactor(targetUnitType);
     convertedValue /= factor;
 
-    *result = convertedValue;
-    return true;
+    return convertedValue;
 }
 
-void CSSPrimitiveValue::setStringValue(unsigned short, const String&, ExceptionCode& ec)
+ExceptionOr<void> CSSPrimitiveValue::setStringValue(unsigned short, const String&)
 {
     // Keeping values immutable makes optimizations easier and allows sharing of the primitive value objects.
     // No other engine supports mutating style through this API. Computed style is always read-only anyway.
     // Supporting setter would require making primitive value copy-on-write and taking care of style invalidation.
-    ec = NO_MODIFICATION_ALLOWED_ERR;
+    return Exception { NO_MODIFICATION_ALLOWED_ERR };
 }
 
-String CSSPrimitiveValue::getStringValue(ExceptionCode& ec) const
+ExceptionOr<String> CSSPrimitiveValue::getStringValue() const
 {
-    ec = 0;
     switch (m_primitiveUnitType) {
     case CSS_STRING:
     case CSS_ATTR:
     case CSS_URI:
         return m_value.string;
     case CSS_FONT_FAMILY:
-        return m_value.fontFamily->familyName;
+        return String { m_value.fontFamily->familyName };
     case CSS_VALUE_ID:
-        return valueName(m_value.valueID);
+        return String { valueName(m_value.valueID) };
     case CSS_PROPERTY_ID:
-        return propertyName(m_value.propertyID);
+        return String { propertyName(m_value.propertyID) };
     default:
-        ec = INVALID_ACCESS_ERR;
-        break;
+        return Exception { INVALID_ACCESS_ERR };
     }
-
-    return String();
 }
 
-String CSSPrimitiveValue::getStringValue() const
+String CSSPrimitiveValue::stringValue() const
 {
     switch (m_primitiveUnitType) {
     case CSS_STRING:
@@ -972,80 +958,33 @@ String CSSPrimitiveValue::getStringValue() const
     case CSS_PROPERTY_ID:
         return propertyName(m_value.propertyID);
     default:
-        break;
+        return String();
     }
-
-    return String();
 }
 
-Counter* CSSPrimitiveValue::getCounterValue(ExceptionCode& ec) const
+ExceptionOr<Counter*> CSSPrimitiveValue::getCounterValue() const
 {
-    ec = 0;
-    if (m_primitiveUnitType != CSS_COUNTER) {
-        ec = INVALID_ACCESS_ERR;
-        return 0;
-    }
-
+    if (m_primitiveUnitType != CSS_COUNTER)
+        return Exception { INVALID_ACCESS_ERR };
     return m_value.counter;
 }
 
-Rect* CSSPrimitiveValue::getRectValue(ExceptionCode& ec) const
+ExceptionOr<Rect*> CSSPrimitiveValue::getRectValue() const
 {
-    ec = 0;
-    if (m_primitiveUnitType != CSS_RECT) {
-        ec = INVALID_ACCESS_ERR;
-        return 0;
-    }
-
+    if (m_primitiveUnitType != CSS_RECT)
+        return Exception { INVALID_ACCESS_ERR };
     return m_value.rect;
 }
 
-Quad* CSSPrimitiveValue::getQuadValue(ExceptionCode& ec) const
-{
-    ec = 0;
-    if (m_primitiveUnitType != CSS_QUAD) {
-        ec = INVALID_ACCESS_ERR;
-        return 0;
-    }
-
-    return m_value.quad;
-}
-
-#if ENABLE(CSS_SCROLL_SNAP)
-LengthRepeat* CSSPrimitiveValue::getLengthRepeatValue(ExceptionCode& ec) const
-{
-    ec = 0;
-    if (m_primitiveUnitType != CSS_LENGTH_REPEAT) {
-        ec = INVALID_ACCESS_ERR;
-        return 0;
-    }
-
-    return m_value.lengthRepeat;
-}
-#endif
-
-RefPtr<RGBColor> CSSPrimitiveValue::getRGBColorValue(ExceptionCode& ec) const
+ExceptionOr<Ref<RGBColor>> CSSPrimitiveValue::getRGBColorValue() const
 {
-    if (m_primitiveUnitType != CSS_RGBCOLOR) {
-        ec = INVALID_ACCESS_ERR;
-        return nullptr;
-    }
+    if (m_primitiveUnitType != CSS_RGBCOLOR)
+        return Exception { INVALID_ACCESS_ERR };
 
-    // FIMXE: This should not return a new object for each invocation.
+    // FIXME: This should not return a new object for each invocation.
     return RGBColor::create(m_value.color->rgb());
 }
 
-Pair* CSSPrimitiveValue::getPairValue(ExceptionCode& ec) const
-{
-    ec = 0;
-    if (m_primitiveUnitType != CSS_PAIR) {
-        ec = INVALID_ACCESS_ERR;
-        return 0;
-    }
-
-    return m_value.pair;
-}
-
 NEVER_INLINE Ref<StringImpl> CSSPrimitiveValue::formatNumberValue(const char* suffix, unsigned suffixLength) const
 {
     DecimalNumber decimal(m_value.num);
@@ -1172,12 +1111,12 @@ ALWAYS_INLINE String CSSPrimitiveValue::formatNumberForCustomCSSText() const
         return result.toString();
     }
     case CSS_RECT:
-        return getRectValue()->cssText();
+        return rectValue()->cssText();
     case CSS_QUAD:
-        return getQuadValue()->cssText();
+        return quadValue()->cssText();
 #if ENABLE(CSS_SCROLL_SNAP)
     case CSS_LENGTH_REPEAT:
-        return getLengthRepeatValue()->cssText();
+        return lengthRepeatValue()->cssText();
 #endif
     case CSS_PARSER_HEXCOLOR: {
         RGBA32 rgb;
@@ -1187,11 +1126,11 @@ ALWAYS_INLINE String CSSPrimitiveValue::formatNumberForCustomCSSText() const
     case CSS_RGBCOLOR:
         return color().cssText();
     case CSS_PAIR:
-        return getPairValue()->cssText();
+        return pairValue()->cssText();
 #if ENABLE(DASHBOARD_SUPPORT)
     case CSS_DASHBOARD_REGION: {
         StringBuilder result;
-        for (DashboardRegion* region = getDashboardRegionValue(); region; region = region->m_next.get()) {
+        for (DashboardRegion* region = dashboardRegionValue(); region; region = region->m_next.get()) {
             if (!result.isEmpty())
                 result.append(' ');
             result.appendLiteral("dashboard-region(");
@@ -1202,13 +1141,13 @@ ALWAYS_INLINE String CSSPrimitiveValue::formatNumberForCustomCSSText() const
                 result.appendLiteral(" rectangle");
             else
                 break;
-            if (region->top()->m_primitiveUnitType == CSS_VALUE_ID && region->top()->getValueID() == CSSValueInvalid) {
+            if (region->top()->m_primitiveUnitType == CSS_VALUE_ID && region->top()->valueID() == CSSValueInvalid) {
                 ASSERT(region->right()->m_primitiveUnitType == CSS_VALUE_ID);
                 ASSERT(region->bottom()->m_primitiveUnitType == CSS_VALUE_ID);
                 ASSERT(region->left()->m_primitiveUnitType == CSS_VALUE_ID);
-                ASSERT(region->right()->getValueID() == CSSValueInvalid);
-                ASSERT(region->bottom()->getValueID() == CSSValueInvalid);
-                ASSERT(region->left()->getValueID() == CSSValueInvalid);
+                ASSERT(region->right()->valueID() == CSSValueInvalid);
+                ASSERT(region->bottom()->valueID() == CSSValueInvalid);
+                ASSERT(region->left()->valueID() == CSSValueInvalid);
             } else {
                 result.append(' ');
                 result.append(region->top()->cssText());
index a9a6778..e655a1b 100644 (file)
 
 namespace WebCore {
 
+class CSSBasicShape;
 class CSSCalcValue;
 class CSSToLengthConversionData;
 class Counter;
 class DashboardRegion;
+class LengthRepeat;
 class Pair;
 class Quad;
 class RGBColor;
 class Rect;
 class RenderStyle;
-class CSSBasicShape;
-struct CSSParserValue;
-
-#if ENABLE(CSS_SCROLL_SNAP)
-class LengthRepeat;
-#endif
 
 struct CSSFontFamily;
+struct CSSParserValue;
 struct Length;
 struct LengthSize;
 
@@ -178,39 +175,22 @@ public:
 #endif
         UOther
     };
-    static UnitCategory unitCategory(CSSPrimitiveValue::UnitTypes);
-
-    bool isAngle() const
-    {
-        return m_primitiveUnitType == CSS_DEG
-               || m_primitiveUnitType == CSS_RAD
-               || m_primitiveUnitType == CSS_GRAD
-               || m_primitiveUnitType == CSS_TURN;
-    }
+    static UnitCategory unitCategory(UnitTypes);
+
+    bool isAngle() const;
     bool isAttr() const { return m_primitiveUnitType == CSS_ATTR; }
     bool isCounter() const { return m_primitiveUnitType == CSS_COUNTER; }
     bool isFontIndependentLength() const { return m_primitiveUnitType >= CSS_PX && m_primitiveUnitType <= CSS_PC; }
-    static bool isFontRelativeLength(unsigned primitiveUnitType)
-    {
-        return primitiveUnitType == CSS_EMS
-            || primitiveUnitType == CSS_EXS
-            || primitiveUnitType == CSS_REMS
-            || primitiveUnitType == CSS_CHS
-            || primitiveUnitType == CSS_QUIRKY_EMS;
-    }
-    bool isFontRelativeLength() const { return isFontRelativeLength(m_primitiveUnitType); }
+    static bool isFontRelativeLength(UnitTypes);
+    bool isFontRelativeLength() const { return isFontRelativeLength(static_cast<UnitTypes>(m_primitiveUnitType)); }
     
     bool isQuirkyEms() const { return primitiveType() == UnitTypes::CSS_QUIRKY_EMS; }
 
-    static bool isViewportPercentageLength(unsigned short type) { return type >= CSS_VW && type <= CSS_VMAX; }
-    bool isViewportPercentageLength() const { return isViewportPercentageLength(m_primitiveUnitType); }
+    static bool isViewportPercentageLength(UnitTypes type) { return type >= CSS_VW && type <= CSS_VMAX; }
+    bool isViewportPercentageLength() const { return isViewportPercentageLength(static_cast<UnitTypes>(m_primitiveUnitType)); }
 
-    static bool isLength(unsigned short type)
-    {
-        return (type >= CSS_EMS && type <= CSS_PC) || type == CSS_REMS || type == CSS_CHS || isViewportPercentageLength(type) || type == CSS_QUIRKY_EMS;
-    }
-
-    bool isLength() const { return isLength(primitiveType()); }
+    static bool isLength(UnitTypes);
+    bool isLength() const { return isLength(static_cast<UnitTypes>(primitiveType())); }
     bool isNumber() const { return primitiveType() == CSS_NUMBER; }
     bool isPercentage() const { return primitiveType() == CSS_PERCENTAGE; }
     bool isPx() const { return primitiveType() == CSS_PX; }
@@ -233,12 +213,8 @@ public:
     bool isDotsPerPixel() const { return primitiveType() == CSS_DPPX; }
     bool isDotsPerCentimeter() const { return primitiveType() == CSS_DPCM; }
 
-    static bool isResolution(unsigned short type)
-    {
-        return type >= CSS_DPPX && type <= CSS_DPCM;
-    }
-
-    bool isResolution() const { return isResolution(primitiveType()); }
+    static bool isResolution(UnitTypes);
+    bool isResolution() const { return isResolution(static_cast<UnitTypes>(primitiveType())); }
     bool isViewportPercentageWidth() const { return m_primitiveUnitType == CSS_VW; }
     bool isViewportPercentageHeight() const { return m_primitiveUnitType == CSS_VH; }
     bool isViewportPercentageMax() const { return m_primitiveUnitType == CSS_VMAX; }
@@ -258,121 +234,71 @@ public:
     static Ref<CSSPrimitiveValue> create(const Length& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
     static Ref<CSSPrimitiveValue> create(const LengthSize& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
 
-    template<typename T> static Ref<CSSPrimitiveValue> create(T&& value)
-    {
-        return adoptRef(*new CSSPrimitiveValue(std::forward<T>(value)));
-    }
+    template<typename T> static Ref<CSSPrimitiveValue> create(T&&);
 
     // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
     // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
     // When the quirky value is used, if you're in quirks mode, the margin will collapse away
     // inside a table cell.
-    static Ref<CSSPrimitiveValue> createAllowingMarginQuirk(double value, UnitTypes type)
-    {
-        CSSPrimitiveValue* quirkValue = new CSSPrimitiveValue(value, type);
-        quirkValue->m_isQuirkValue = true;
-        return adoptRef(*quirkValue);
-    }
+    static Ref<CSSPrimitiveValue> createAllowingMarginQuirk(double value, UnitTypes);
 
     ~CSSPrimitiveValue();
 
     void cleanup();
 
     WEBCORE_EXPORT unsigned short primitiveType() const;
+    WEBCORE_EXPORT ExceptionOr<void> setFloatValue(unsigned short unitType, double floatValue);
+    WEBCORE_EXPORT ExceptionOr<float> getFloatValue(unsigned short unitType) const;
+    WEBCORE_EXPORT ExceptionOr<void> setStringValue(unsigned short stringType, const String& stringValue);
+    WEBCORE_EXPORT ExceptionOr<String> getStringValue() const;
+    WEBCORE_EXPORT ExceptionOr<Counter*> getCounterValue() const;
+    WEBCORE_EXPORT ExceptionOr<Rect*> getRectValue() const;
+    WEBCORE_EXPORT ExceptionOr<Ref<RGBColor>> getRGBColorValue() const;
 
     double computeDegrees() const;
     
     bool buildParserValue(CSSParserValue*) const;
     
     enum TimeUnit { Seconds, Milliseconds };
-    template <typename T, TimeUnit timeUnit> T computeTime() const
-    {
-        if (timeUnit == Seconds && primitiveType() == CSS_S)
-            return getValue<T>();
-        if (timeUnit == Seconds && primitiveType() == CSS_MS)
-            return getValue<T>() / 1000;
-        if (timeUnit == Milliseconds && primitiveType() == CSS_MS)
-            return getValue<T>();
-        if (timeUnit == Milliseconds && primitiveType() == CSS_S)
-            return getValue<T>() * 1000;
-        ASSERT_NOT_REACHED();
-        return 0;
-    }
-
-    /*
-     * computes a length in pixels out of the given CSSValue. Need the RenderStyle to get
-     * the fontinfo in case val is defined in em or ex.
-     *
-     * The metrics have to be a bit different for screen and printer output.
-     * For screen output we assume 1 inch == 72 px, for printer we assume 300 dpi
-     *
-     * this is screen/printer dependent, so we probably need a config option for this,
-     * and some tool to calibrate.
-     */
-    template<typename T> T computeLength(const CSSToLengthConversionData&) const;
+    template<typename T, TimeUnit timeUnit> T computeTime() const;
 
-    // Converts to a Length, mapping various unit types appropriately.
+    template<typename T> T computeLength(const CSSToLengthConversionData&) const;
     template<int> Length convertToLength(const CSSToLengthConversionData&) const;
 
     bool convertingToLengthRequiresNonNullStyle(int lengthConversion) const;
 
-    // use with care!!!
-    void setPrimitiveType(unsigned short type) { m_primitiveUnitType = type; }
-
-    WEBCORE_EXPORT double getDoubleValue(unsigned short unitType, ExceptionCode&) const;
-    double getDoubleValue(unsigned short unitType) const;
-    double getDoubleValue() const;
+    double doubleValue(UnitTypes) const;
+    double doubleValue() const;
 
-    WEBCORE_EXPORT void setFloatValue(unsigned short unitType, double floatValue, ExceptionCode&);
-    float getFloatValue(unsigned short unitType, ExceptionCode& ec) const { return getValue<float>(unitType, ec); }
-    float getFloatValue(unsigned short unitType) const { return getValue<float>(unitType); }
-    float getFloatValue() const { return getValue<float>(); }
+    template<typename T> inline T value(UnitTypes type) const { return clampTo<T>(doubleValue(type)); }
+    template<typename T> inline T value() const { return clampTo<T>(doubleValue()); }
 
-    int getIntValue(unsigned short unitType, ExceptionCode& ec) const { return getValue<int>(unitType, ec); }
-    int getIntValue(unsigned short unitType) const { return getValue<int>(unitType); }
-    int getIntValue() const { return getValue<int>(); }
+    float floatValue(UnitTypes type) const { return value<float>(type); }
+    float floatValue() const { return value<float>(); }
 
-    template<typename T> inline T getValue(unsigned short unitType, ExceptionCode& ec) const { return clampTo<T>(getDoubleValue(unitType, ec)); }
-    template<typename T> inline T getValue(unsigned short unitType) const { return clampTo<T>(getDoubleValue(unitType)); }
-    template<typename T> inline T getValue() const { return clampTo<T>(getDoubleValue()); }
+    int intValue(UnitTypes type) const { return value<int>(type); }
+    int intValue() const { return value<int>(); }
 
-    WEBCORE_EXPORT void setStringValue(unsigned short stringType, const String& stringValue, ExceptionCode&);
-    WEBCORE_EXPORT String getStringValue(ExceptionCode&) const;
-    WEBCORE_EXPORT String getStringValue() const;
+    WEBCORE_EXPORT String stringValue() const;
 
-    WEBCORE_EXPORT Counter* getCounterValue(ExceptionCode&) const;
-    Counter* getCounterValue() const { return m_primitiveUnitType != CSS_COUNTER ? nullptr : m_value.counter; }
-
-    WEBCORE_EXPORT Rect* getRectValue(ExceptionCode&) const;
-    Rect* getRectValue() const { return m_primitiveUnitType != CSS_RECT ? nullptr : m_value.rect; }
-
-    Quad* getQuadValue(ExceptionCode&) const;
-    Quad* getQuadValue() const { return m_primitiveUnitType != CSS_QUAD ? nullptr : m_value.quad; }
+    const Color& color() const { ASSERT(m_primitiveUnitType == CSS_RGBCOLOR); return *m_value.color; }
+    Counter* counterValue() const { return m_primitiveUnitType != CSS_COUNTER ? nullptr : m_value.counter; }
+    CSSCalcValue* cssCalcValue() const { return m_primitiveUnitType != CSS_CALC ? nullptr : m_value.calc; }
+    const CSSFontFamily& fontFamily() const { ASSERT(m_primitiveUnitType == CSS_FONT_FAMILY); return *m_value.fontFamily; }
+    Pair* pairValue() const { return m_primitiveUnitType != CSS_PAIR ? nullptr : m_value.pair; }
+    CSSPropertyID propertyID() const { return m_primitiveUnitType == CSS_PROPERTY_ID ? m_value.propertyID : CSSPropertyInvalid; }
+    Quad* quadValue() const { return m_primitiveUnitType != CSS_QUAD ? nullptr : m_value.quad; }
+    Rect* rectValue() const { return m_primitiveUnitType != CSS_RECT ? nullptr : m_value.rect; }
+    CSSBasicShape* shapeValue() const { return m_primitiveUnitType != CSS_SHAPE ? nullptr : m_value.shape; }
+    CSSValueID valueID() const { return m_primitiveUnitType == CSS_VALUE_ID ? m_value.valueID : CSSValueInvalid; }
 
 #if ENABLE(CSS_SCROLL_SNAP)
-    LengthRepeat* getLengthRepeatValue(ExceptionCode&) const;
-    LengthRepeat* getLengthRepeatValue() const { return m_primitiveUnitType != CSS_LENGTH_REPEAT ? nullptr : m_value.lengthRepeat; }
+    LengthRepeat* lengthRepeatValue() const { return m_primitiveUnitType != CSS_LENGTH_REPEAT ? nullptr : m_value.lengthRepeat; }
 #endif
-
-    WEBCORE_EXPORT RefPtr<RGBColor> getRGBColorValue(ExceptionCode&) const;
-    const Color& color() const { ASSERT(m_primitiveUnitType == CSS_RGBCOLOR); return *m_value.color; }
-
-    Pair* getPairValue(ExceptionCode&) const;
-    Pair* getPairValue() const { return m_primitiveUnitType != CSS_PAIR ? nullptr : m_value.pair; }
-
 #if ENABLE(DASHBOARD_SUPPORT)
-    DashboardRegion* getDashboardRegionValue() const { return m_primitiveUnitType != CSS_DASHBOARD_REGION ? nullptr : m_value.region; }
+    DashboardRegion* dashboardRegionValue() const { return m_primitiveUnitType != CSS_DASHBOARD_REGION ? nullptr : m_value.region; }
 #endif
 
-    CSSBasicShape* getShapeValue() const { return m_primitiveUnitType != CSS_SHAPE ? nullptr : m_value.shape; }
-
-    const CSSFontFamily& fontFamily() const { ASSERT(m_primitiveUnitType == CSS_FONT_FAMILY); return *m_value.fontFamily; }
-
-    CSSCalcValue* cssCalcValue() const { return m_primitiveUnitType != CSS_CALC ? nullptr : m_value.calc; }
-
-    CSSPropertyID getPropertyID() const { return m_primitiveUnitType == CSS_PROPERTY_ID ? m_value.propertyID : CSSPropertyInvalid; }
-    CSSValueID getValueID() const { return m_primitiveUnitType == CSS_VALUE_ID ? m_value.valueID : CSSValueInvalid; }
-
     template<typename T> inline operator T() const; // Defined in CSSPrimitiveValueMappings.h
 
     String customCSSText() const;
@@ -386,9 +312,9 @@ public:
     bool equals(const CSSPrimitiveValue&) const;
 
     static UnitTypes canonicalUnitTypeForCategory(UnitCategory);
-    static double conversionToCanonicalUnitsScaleFactor(unsigned short unitType);
+    static double conversionToCanonicalUnitsScaleFactor(UnitTypes);
 
-    static double computeNonCalcLengthDouble(const CSSToLengthConversionData&, unsigned short primitiveType, double value);
+    static double computeNonCalcLengthDouble(const CSSToLengthConversionData&, UnitTypes, double value);
 
 #if COMPILER(MSVC)
     // FIXME: This should be private, but for some reason MSVC then fails to invoke it from LazyNeverDestroyed::construct.
@@ -401,7 +327,6 @@ private:
 
     CSSPrimitiveValue(CSSValueID);
     CSSPrimitiveValue(CSSPropertyID);
-    // FIXME: int vs. unsigned overloading is too subtle to distinguish the color and operator cases.
     CSSPrimitiveValue(int parserOperator);
     CSSPrimitiveValue(const Color&);
     CSSPrimitiveValue(const Length&);
@@ -411,18 +336,8 @@ private:
     CSSPrimitiveValue(double, UnitTypes);
 
     template<typename T> CSSPrimitiveValue(T); // Defined in CSSPrimitiveValueMappings.h
-
-    template<typename T> CSSPrimitiveValue(RefPtr<T>&& value)
-        : CSSValue(PrimitiveClass)
-    {
-        init(WTFMove(value));
-    }
-
-    template<typename T> CSSPrimitiveValue(Ref<T>&& value)
-        : CSSValue(PrimitiveClass)
-    {
-        init(WTFMove(value));
-    }
+    template<typename T> CSSPrimitiveValue(RefPtr<T>&&);
+    template<typename T> CSSPrimitiveValue(Ref<T>&&);
 
     static void create(int); // compile-time guard
     static void create(unsigned); // compile-time guard
@@ -430,25 +345,26 @@ private:
 
     void init(const Length&);
     void init(const LengthSize&, const RenderStyle&);
+    void init(Ref<CSSBasicShape>&&);
+    void init(RefPtr<CSSCalcValue>&&);
     void init(Ref<Counter>&&);
-    void init(Ref<Rect>&&);
     void init(Ref<Pair>&&);
     void init(Ref<Quad>&&);
+    void init(Ref<Rect>&&);
+
 #if ENABLE(CSS_SCROLL_SNAP)
     void init(Ref<LengthRepeat>&&);
 #endif
 #if ENABLE(DASHBOARD_SUPPORT)
     void init(RefPtr<DashboardRegion>&&); // FIXME: Dashboard region should not be a primitive value.
 #endif
-    void init(Ref<CSSBasicShape>&&);
-    void init(RefPtr<CSSCalcValue>&&);
-    bool getDoubleValueInternal(UnitTypes targetUnitType, double* result) const;
+
+    Optional<double> doubleValueInternal(UnitTypes targetUnitType) const;
 
     double computeLengthDouble(const CSSToLengthConversionData&) const;
 
     ALWAYS_INLINE String formatNumberForCustomCSSText() const;
-    template <unsigned characterCount>
-    ALWAYS_INLINE Ref<StringImpl> formatNumberValue(const char (&characters)[characterCount]) const;
+    template<unsigned characterCount> ALWAYS_INLINE Ref<StringImpl> formatNumberValue(const char (&characters)[characterCount]) const;
     NEVER_INLINE Ref<StringImpl> formatNumberValue(const char* suffix, unsigned suffixLength) const;
 
     union {
@@ -460,18 +376,87 @@ private:
         Counter* counter;
         Rect* rect;
         Quad* quad;
-#if ENABLE(CSS_SCROLL_SNAP)
-        LengthRepeat* lengthRepeat;
-#endif
         const Color* color;
         Pair* pair;
         DashboardRegion* region;
         CSSBasicShape* shape;
         CSSCalcValue* calc;
         const CSSFontFamily* fontFamily;
+#if ENABLE(CSS_SCROLL_SNAP)
+        LengthRepeat* lengthRepeat;
+#endif
     } m_value;
 };
 
+inline bool CSSPrimitiveValue::isAngle() const
+{
+    return m_primitiveUnitType == CSS_DEG
+        || m_primitiveUnitType == CSS_RAD
+        || m_primitiveUnitType == CSS_GRAD
+        || m_primitiveUnitType == CSS_TURN;
+}
+
+inline bool CSSPrimitiveValue::isFontRelativeLength(UnitTypes type)
+{
+    return type == CSS_EMS
+        || type == CSS_EXS
+        || type == CSS_REMS
+        || type == CSS_CHS
+        || type == CSS_QUIRKY_EMS;
+}
+
+inline bool CSSPrimitiveValue::isLength(UnitTypes type)
+{
+    return (type >= CSS_EMS && type <= CSS_PC)
+        || type == CSS_REMS
+        || type == CSS_CHS
+        || isViewportPercentageLength(type)
+        || type == CSS_QUIRKY_EMS;
+}
+
+inline bool CSSPrimitiveValue::isResolution(UnitTypes type)
+{
+    return type >= CSS_DPPX && type <= CSS_DPCM;
+}
+
+template<typename T> inline Ref<CSSPrimitiveValue> CSSPrimitiveValue::create(T&& value)
+{
+    return adoptRef(*new CSSPrimitiveValue(std::forward<T>(value)));
+}
+
+inline Ref<CSSPrimitiveValue> CSSPrimitiveValue::createAllowingMarginQuirk(double value, UnitTypes type)
+{
+    auto result = adoptRef(*new CSSPrimitiveValue(value, type));
+    result->m_isQuirkValue = true;
+    return result;
+}
+
+template<typename T, CSSPrimitiveValue::TimeUnit timeUnit> inline T CSSPrimitiveValue::computeTime() const
+{
+    if (timeUnit == Seconds && primitiveType() == CSS_S)
+        return value<T>();
+    if (timeUnit == Seconds && primitiveType() == CSS_MS)
+        return value<T>() / 1000;
+    if (timeUnit == Milliseconds && primitiveType() == CSS_MS)
+        return value<T>();
+    if (timeUnit == Milliseconds && primitiveType() == CSS_S)
+        return value<T>() * 1000;
+    ASSERT_NOT_REACHED();
+    return 0;
+}
+
+template<typename T> inline CSSPrimitiveValue::CSSPrimitiveValue(RefPtr<T>&& value)
+    : CSSValue(PrimitiveClass)
+{
+    init(WTFMove(value));
+}
+
+template<typename T> inline CSSPrimitiveValue::CSSPrimitiveValue(Ref<T>&& value)
+    : CSSValue(PrimitiveClass)
+{
+    init(WTFMove(value));
+}
+
 } // namespace WebCore
 
 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSPrimitiveValue, isPrimitiveValue())
index 234b00f..2482c62 100644 (file)
@@ -20,7 +20,6 @@
 [
     ImplementationLacksVTable,
 ] interface CSSPrimitiveValue : CSSValue {
-
     // UnitTypes
     const unsigned short CSS_UNKNOWN = 0;
     const unsigned short CSS_NUMBER = 1;
     
     readonly attribute unsigned short primitiveType;
 
-    [MayThrowLegacyException] void setFloatValue(optional unsigned short unitType = 0, optional unrestricted float floatValue = NaN);
-    [MayThrowLegacyException] unrestricted float getFloatValue(optional unsigned short unitType = 0);
+    [MayThrowException] void setFloatValue(optional unsigned short unitType = 0, optional unrestricted float floatValue = NaN);
+    [MayThrowException] unrestricted float getFloatValue(optional unsigned short unitType = 0);
+
+    [MayThrowException] void setStringValue(optional unsigned short stringType = 0, optional DOMString stringValue);
+    [MayThrowException] DOMString getStringValue();
 
-    // FIXME: Using "undefined" as default parameter value is wrong.
-    [MayThrowLegacyException] void setStringValue(optional unsigned short stringType = 0, optional DOMString stringValue = "undefined");
-    [MayThrowLegacyException] DOMString getStringValue();
-    [MayThrowLegacyException] Counter getCounterValue();
-    [MayThrowLegacyException] Rect getRectValue();
-    [MayThrowLegacyException] RGBColor getRGBColorValue();
+    [MayThrowException] Counter getCounterValue();
+    [MayThrowException] Rect getRectValue();
+    [MayThrowException] RGBColor getRGBColorValue();
 };
index 2ebf322..2d5e8ce 100644 (file)
@@ -27,8 +27,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef CSSPrimitiveValueMappings_h
-#define CSSPrimitiveValueMappings_h
+#pragma once
 
 #include "CSSCalculationValue.h"
 #include "CSSFontFamily.h"
@@ -82,7 +81,7 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(unsigned short i)
 template<> inline CSSPrimitiveValue::operator unsigned short() const
 {
     if (primitiveType() == CSS_NUMBER)
-        return getValue<unsigned short>();
+        return value<unsigned short>();
 
     ASSERT_NOT_REACHED();
     return 0;
@@ -91,7 +90,7 @@ template<> inline CSSPrimitiveValue::operator unsigned short() const
 template<> inline CSSPrimitiveValue::operator int() const
 {
     if (primitiveType() == CSS_NUMBER)
-        return getValue<int>();
+        return value<int>();
 
     ASSERT_NOT_REACHED();
     return 0;
@@ -100,7 +99,7 @@ template<> inline CSSPrimitiveValue::operator int() const
 template<> inline CSSPrimitiveValue::operator unsigned() const
 {
     if (primitiveType() == CSS_NUMBER)
-        return getValue<unsigned>();
+        return value<unsigned>();
 
     ASSERT_NOT_REACHED();
     return 0;
@@ -117,7 +116,7 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(float i)
 template<> inline CSSPrimitiveValue::operator float() const
 {
     if (primitiveType() == CSS_NUMBER)
-        return getValue<float>();
+        return value<float>();
 
     ASSERT_NOT_REACHED();
     return 0.0f;
@@ -133,10 +132,10 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i)
 template<> inline CSSPrimitiveValue::operator LineClampValue() const
 {
     if (primitiveType() == CSS_NUMBER)
-        return LineClampValue(getValue<int>(), LineClampLineCount);
+        return LineClampValue(value<int>(), LineClampLineCount);
 
     if (primitiveType() == CSS_PERCENTAGE)
-        return LineClampValue(getValue<int>(), LineClampPercentage);
+        return LineClampValue(value<int>(), LineClampPercentage);
 
     ASSERT_NOT_REACHED();
     return LineClampValue();
@@ -4614,8 +4613,8 @@ template<int supported> Length CSSPrimitiveValue::convertToLength(const CSSToLen
     if ((supported & FixedFloatConversion) && isLength())
         return Length(computeLength<double>(conversionData), Fixed);
     if ((supported & PercentConversion) && isPercentage())
-        return Length(getDoubleValue(), Percent);
-    if ((supported & AutoConversion) && getValueID() == CSSValueAuto)
+        return Length(doubleValue(), Percent);
+    if ((supported & AutoConversion) && valueID() == CSSValueAuto)
         return Length(Auto);
     if ((supported & CalculatedConversion) && isCalculated())
         return Length(cssCalcValue()->createCalculationValue(conversionData));
@@ -5045,7 +5044,7 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ImageOrientationEnum e)
 template<> inline CSSPrimitiveValue::operator ImageOrientationEnum() const
 {
     ASSERT(isAngle());
-    double quarters = 4 * getDoubleValue(CSS_TURN);
+    double quarters = 4 * doubleValue(CSS_TURN);
     int orientation = 3 & static_cast<int>(quarters < 0 ? floor(quarters) : ceil(quarters));
     switch (orientation) {
     case 0:
@@ -5099,7 +5098,7 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSBoxType cssBox)
 
 template<> inline CSSPrimitiveValue::operator CSSBoxType() const
 {
-    switch (getValueID()) {
+    switch (valueID()) {
     case CSSValueMarginBox:
         return MarginBox;
     case CSSValueBorderBox:
@@ -5686,6 +5685,5 @@ template<> inline CSSPrimitiveValue::operator FontVariantAlternates() const
     ASSERT_NOT_REACHED();
     return FontVariantAlternates::Normal;
 }
-}
 
-#endif
+}
index f01cffa..e5260a4 100644 (file)
@@ -45,9 +45,9 @@ COMPILE_ASSERT(StyleRuleBase::Region == static_cast<StyleRuleBase::Type>(CSSRule
 COMPILE_ASSERT(StyleRuleBase::Viewport == static_cast<StyleRuleBase::Type>(CSSRule::WEBKIT_VIEWPORT_RULE), enums_should_match);
 #endif
 
-void CSSRule::setCssText(const String& /*cssText*/, ExceptionCode& /*ec*/)
+ExceptionOr<void> CSSRule::setCssText(const String&)
 {
-    notImplemented();
+    return { };
 }
 
 const CSSParserContext& CSSRule::parserContext() const
index 39463e6..86724ba 100644 (file)
 
 #pragma once
 
-#include <wtf/RefCounted.h>
+#include "ExceptionOr.h"
 #include <wtf/TypeCasts.h>
-#include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
 class CSSStyleSheet;
 class StyleRuleBase;
+
 struct CSSParserContext;
-typedef int ExceptionCode;
 
 class CSSRule : public RefCounted<CSSRule> {
 public:
@@ -89,7 +88,7 @@ public:
 
     CSSRule* parentRule() const { return m_parentIsRule ? m_parentRule : 0; }
 
-    WEBCORE_EXPORT void setCssText(const String&, ExceptionCode&);
+    WEBCORE_EXPORT ExceptionOr<void> setCssText(const String&);
 
 protected:
     CSSRule(CSSStyleSheet* parent)
index 582eaf9..1268f11 100644 (file)
     const unsigned short KEYFRAMES_RULE = 7;
     const unsigned short KEYFRAME_RULE = 8;
     const unsigned short SUPPORTS_RULE = 12;
-#if defined(ENABLE_CSS_DEVICE_ADAPTATION) && ENABLE_CSS_DEVICE_ADAPTATION
-    const unsigned short WEBKIT_VIEWPORT_RULE = 15;
-#endif
-#if defined(ENABLE_CSS_REGIONS) && ENABLE_CSS_REGIONS
-    const unsigned short WEBKIT_REGION_RULE = 16;
-#endif
+    [Conditional=CSS_DEVICE_ADAPTATION] const unsigned short WEBKIT_VIEWPORT_RULE = 15;
+    [Conditional=CSS_REGIONS] const unsigned short WEBKIT_REGION_RULE = 16;
 
-    const unsigned short WEBKIT_KEYFRAMES_RULE = 7; // Avoid breaking existing content.
+    // Legacy synonyms for the above, kept to avoid breaking existing content.
+    const unsigned short WEBKIT_KEYFRAMES_RULE = 7;
     const unsigned short WEBKIT_KEYFRAME_RULE = 8;
 
     readonly attribute unsigned short type;
 
-    [SetterMayThrowLegacyException] attribute DOMString? cssText;
+    [SetterMayThrowException] attribute DOMString? cssText;
 
     readonly attribute CSSStyleSheet? parentStyleSheet;
     readonly attribute CSSRule? parentRule;
index 48fff2a..5e4321b 100644 (file)
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef CSSStyleDeclaration_h
-#define CSSStyleDeclaration_h
+#pragma once
 
 #include "CSSPropertyNames.h"
+#include "ExceptionOr.h"
 #include "ScriptWrappable.h"
 #include <wtf/Forward.h>
 
@@ -35,8 +35,6 @@ class MutableStyleProperties;
 class StyleProperties;
 class StyledElement;
 
-typedef int ExceptionCode;
-
 class CSSStyleDeclaration : public ScriptWrappable {
     WTF_MAKE_NONCOPYABLE(CSSStyleDeclaration); WTF_MAKE_FAST_ALLOCATED;
 public:
@@ -48,7 +46,7 @@ public:
     virtual StyledElement* parentElement() const { return nullptr; }
     virtual CSSRule* parentRule() const = 0;
     virtual String cssText() const = 0;
-    virtual void setCssText(const String&, ExceptionCode&) = 0;
+    virtual ExceptionOr<void> setCssText(const String&) = 0;
     virtual unsigned length() const = 0;
     virtual String item(unsigned index) const = 0;
     virtual RefPtr<CSSValue> getPropertyCSSValue(const String& propertyName) = 0;
@@ -56,24 +54,22 @@ public:
     virtual String getPropertyPriority(const String& propertyName) = 0;
     virtual String getPropertyShorthand(const String& propertyName) = 0;
     virtual bool isPropertyImplicit(const String& propertyName) = 0;
-    virtual void setProperty(const String& propertyName, const String& value, const String& priority, ExceptionCode&) = 0;
-    virtual String removeProperty(const String& propertyName, ExceptionCode&) = 0;
+    virtual ExceptionOr<void> setProperty(const String& propertyName, const String& value, const String& priority) = 0;
+    virtual ExceptionOr<String> removeProperty(const String& propertyName) = 0;
 
     // CSSPropertyID versions of the CSSOM functions to support bindings and editing.
     // Use the non-virtual methods in the concrete subclasses when possible.
     // The CSSValue returned by this function should not be exposed to the web as it may be used by multiple documents at the same time.
     virtual RefPtr<CSSValue> getPropertyCSSValueInternal(CSSPropertyID) = 0;
     virtual String getPropertyValueInternal(CSSPropertyID) = 0;
-    virtual bool setPropertyInternal(CSSPropertyID, const String& value, bool important, ExceptionCode&) = 0;
+    virtual ExceptionOr<bool> setPropertyInternal(CSSPropertyID, const String& value, bool important) = 0;
 
     virtual Ref<MutableStyleProperties> copyProperties() const = 0;
 
-    virtual CSSStyleSheet* parentStyleSheet() const { return 0; }
+    virtual CSSStyleSheet* parentStyleSheet() const { return nullptr; }
 
 protected:
     CSSStyleDeclaration() { }
 };
 
 } // namespace WebCore
-
-#endif // CSSStyleDeclaration_h
index 47893a2..2c85a4c 100644 (file)
     JSCustomMarkFunction,
     SkipVTableValidation,
 ] interface CSSStyleDeclaration {
-    [SetterMayThrowLegacyException] attribute DOMString cssText;
+    [SetterMayThrowException] attribute DOMString cssText;
 
     DOMString getPropertyValue(DOMString propertyName);
     [Custom] CSSValue? getPropertyCSSValue(DOMString propertyName);
 
-    [MayThrowLegacyException] DOMString removeProperty(DOMString propertyName);
+    [MayThrowException] DOMString removeProperty(DOMString propertyName);
     DOMString? getPropertyPriority(DOMString propertyName);
 
-    [MayThrowLegacyException] void setProperty(DOMString propertyName, [TreatNullAs=EmptyString] DOMString value, [TreatNullAs=EmptyString] optional DOMString priority = "");
+    [MayThrowException] void setProperty(DOMString propertyName, [TreatNullAs=EmptyString] DOMString value, [TreatNullAs=EmptyString] optional DOMString priority = "");
 
     readonly attribute unsigned long length;
     getter DOMString item(unsigned long index);
index af8e245..5f91aa1 100644 (file)
@@ -284,53 +284,43 @@ RefPtr<CSSRuleList> CSSStyleSheet::rules()
     return nonCharsetRules;
 }
 
-unsigned CSSStyleSheet::deprecatedInsertRule(const String& ruleString, ExceptionCode& ec)
+ExceptionOr<unsigned> CSSStyleSheet::deprecatedInsertRule(const String& ruleString)
 {
     if (auto* document = ownerDocument())
         document->addConsoleMessage(MessageSource::JS, MessageLevel::Warning, ASCIILiteral("Calling CSSStyleSheet.insertRule() with one argument is deprecated. Please pass the index argument as well: insertRule(x, 0)."));
 
-    return insertRule(ruleString, 0, ec);
+    return insertRule(ruleString, 0);
 }
 
-unsigned CSSStyleSheet::insertRule(const String& ruleString, unsigned index, ExceptionCode& ec)
+ExceptionOr<unsigned> CSSStyleSheet::insertRule(const String& ruleString, unsigned index)
 {
     ASSERT(m_childRuleCSSOMWrappers.isEmpty() || m_childRuleCSSOMWrappers.size() == m_contents->ruleCount());
 
-    ec = 0;
-    if (index > length()) {
-        ec = INDEX_SIZE_ERR;
-        return 0;
-    }
+    if (index > length())
+        return Exception { INDEX_SIZE_ERR };
     CSSParser p(m_contents.get().parserContext());
     RefPtr<StyleRuleBase> rule = p.parseRule(m_contents.ptr(), ruleString);
 
-    if (!rule) {
-        ec = SYNTAX_ERR;
-        return 0;
-    }
+    if (!rule)
+        return Exception { SYNTAX_ERR };
 
     RuleMutationScope mutationScope(this, RuleInsertion, is<StyleRuleKeyframes>(*rule) ? downcast<StyleRuleKeyframes>(rule.get()) : nullptr);
 
     bool success = m_contents.get().wrapperInsertRule(rule.releaseNonNull(), index);
-    if (!success) {
-        ec = HIERARCHY_REQUEST_ERR;
-        return 0;
-    }        
+    if (!success)
+        return Exception { HIERARCHY_REQUEST_ERR };
     if (!m_childRuleCSSOMWrappers.isEmpty())
         m_childRuleCSSOMWrappers.insert(index, RefPtr<CSSRule>());
 
     return index;
 }
 
-void CSSStyleSheet::deleteRule(unsigned index, ExceptionCode& ec)
+ExceptionOr<void> CSSStyleSheet::deleteRule(unsigned index)
 {
     ASSERT(m_childRuleCSSOMWrappers.isEmpty() || m_childRuleCSSOMWrappers.size() == m_contents->ruleCount());
 
-    ec = 0;
-    if (index >= length()) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
+    if (index >= length())
+        return Exception { INDEX_SIZE_ERR };
     RuleMutationScope mutationScope(this);
 
     m_contents->wrapperDeleteRule(index);
@@ -340,9 +330,11 @@ void CSSStyleSheet::deleteRule(unsigned index, ExceptionCode& ec)
             m_childRuleCSSOMWrappers[index]->setParentStyleSheet(nullptr);
         m_childRuleCSSOMWrappers.remove(index);
     }
+
+    return { };
 }
 
-int CSSStyleSheet::addRule(const String& selector, const String& style, Optional<unsigned> index, ExceptionCode& ec)
+ExceptionOr<int> CSSStyleSheet::addRule(const String& selector, const String& style, Optional<unsigned> index)
 {
     StringBuilder text;
     text.append(selector);
@@ -351,7 +343,9 @@ int CSSStyleSheet::addRule(const String& selector, const String& style, Optional
     if (!style.isEmpty())
         text.append(' ');
     text.append('}');
-    insertRule(text.toString(), index.valueOr(length()), ec);
+    auto insertRuleResult = insertRule(text.toString(), index.valueOr(length()));
+    if (insertRuleResult.hasException())
+        return insertRuleResult.releaseException();
     
     // As per Microsoft documentation, always return -1.
     return -1;
index c1ae1be..744a9c2 100644 (file)
@@ -21,6 +21,7 @@
 #pragma once
 
 #include "CSSParserMode.h"
+#include "ExceptionOr.h"
 #include "StyleSheet.h"
 #include <memory>
 #include <wtf/HashMap.h>
@@ -49,8 +50,6 @@ namespace Style {
 class Scope;
 }
 
-typedef int ExceptionCode;
-
 class CSSStyleSheet final : public StyleSheet {
 public:
     static Ref<CSSStyleSheet> create(Ref<StyleSheetContents>&&, CSSImportRule* ownerRule = 0);
@@ -68,14 +67,13 @@ public:
     void setDisabled(bool) final;
     
     WEBCORE_EXPORT RefPtr<CSSRuleList> cssRules();
-    WEBCORE_EXPORT unsigned insertRule(const String& rule, unsigned index, ExceptionCode&);
-    unsigned deprecatedInsertRule(const String& rule, ExceptionCode&);
-    WEBCORE_EXPORT void deleteRule(unsigned index, ExceptionCode&);
+    WEBCORE_EXPORT ExceptionOr<unsigned> insertRule(const String& rule, unsigned index);
+    ExceptionOr<unsigned> deprecatedInsertRule(const String& rule);
+    WEBCORE_EXPORT ExceptionOr<void> deleteRule(unsigned index);
     
-    // IE Extensions
     WEBCORE_EXPORT RefPtr<CSSRuleList> rules();
-    WEBCORE_EXPORT int addRule(const String& selector, const String& style, Optional<unsigned> index, ExceptionCode&);
-    void removeRule(unsigned index, ExceptionCode& ec) { deleteRule(index, ec); }
+    WEBCORE_EXPORT ExceptionOr<int> addRule(const String& selector, const String& style, Optional<unsigned> index);
+    ExceptionOr<void> removeRule(unsigned index) { return deleteRule(index); }
     
     // For CSSRuleList.
     unsigned length() const;
index 9538f85..0ceb415 100644 (file)
@@ -22,14 +22,14 @@ interface CSSStyleSheet : StyleSheet {
     readonly attribute CSSRule ownerRule;
     readonly attribute CSSRuleList cssRules;
 
-    [MayThrowLegacyException] unsigned long insertRule(DOMString rule, unsigned long index);
-    [MayThrowLegacyException, ImplementedAs=deprecatedInsertRule] unsigned long insertRule(DOMString rule); // Deprecated.
+    [MayThrowException] unsigned long insertRule(DOMString rule, unsigned long index);
+    [MayThrowException, ImplementedAs=deprecatedInsertRule] unsigned long insertRule(DOMString rule); // Deprecated.
 
-    [MayThrowLegacyException] void deleteRule(unsigned long index);
+    [MayThrowException] void deleteRule(unsigned long index);
 
     readonly attribute CSSRuleList rules;
 
-    // FIXME: Those operations are WebKit-specific.
-    [MayThrowLegacyException] long addRule(optional DOMString selector = "undefined", optional DOMString style = "undefined", optional unsigned long index);
-    [MayThrowLegacyException] void removeRule(optional unsigned long index = 0);
+    // The following two operations are WebKit-specific.
+    [MayThrowException] long addRule(optional DOMString selector = "undefined", optional DOMString style = "undefined", optional unsigned long index);
+    [MayThrowException] void removeRule(optional unsigned long index = 0);
 };
index ad364f6..f96500b 100644 (file)
@@ -30,7 +30,6 @@ interface CSSSupportsRule : CSSRule {
     readonly attribute CSSRuleList cssRules;
     readonly attribute DOMString conditionText;
 
-    [MayThrowLegacyException] unsigned long insertRule(DOMString rule, unsigned long index);
-    [MayThrowLegacyException] void deleteRule(unsigned long index);
+    [MayThrowException] unsigned long insertRule(DOMString rule, unsigned long index);
+    [MayThrowException] void deleteRule(unsigned long index);
 };
-
index 9bd2fd6..8cf5c7e 100644 (file)
@@ -81,7 +81,7 @@ void CSSToStyleMap::mapFillAttachment(CSSPropertyID propertyID, FillLayer& layer
     if (!is<CSSPrimitiveValue>(value))
         return;
 
-    switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
+    switch (downcast<CSSPrimitiveValue>(value).valueID()) {
     case CSSValueFixed:
         layer.setAttachment(FixedBackgroundAttachment);
         break;
@@ -186,7 +186,7 @@ void CSSToStyleMap::mapFillRepeatY(CSSPropertyID propertyID, FillLayer& layer, c
 
 static inline bool convertToLengthSize(const CSSPrimitiveValue& primitiveValue, CSSToLengthConversionData conversionData, LengthSize& size)
 {
-    if (auto* pair = primitiveValue.getPairValue()) {
+    if (auto* pair = primitiveValue.pairValue()) {
         size.setWidth(pair->first()->convertToLength<AnyConversion>(conversionData));
         size.setHeight(pair->second()->convertToLength<AnyConversion>(conversionData));
     } else
@@ -207,7 +207,7 @@ void CSSToStyleMap::mapFillSize(CSSPropertyID propertyID, FillLayer& layer, cons
 
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
     FillSize fillSize;
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueContain:
         fillSize.type = Contain;
         break;
@@ -234,7 +234,7 @@ void CSSToStyleMap::mapFillXPosition(CSSPropertyID propertyID, FillLayer& layer,
         return;
 
     auto* primitiveValue = &downcast<CSSPrimitiveValue>(value);
-    Pair* pair = primitiveValue->getPairValue();
+    Pair* pair = primitiveValue->pairValue();
     if (pair) {
         ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPositionX || propertyID == CSSPropertyWebkitMaskPositionX);
         primitiveValue = pair->second();
@@ -244,7 +244,7 @@ void CSSToStyleMap::mapFillXPosition(CSSPropertyID propertyID, FillLayer& layer,
     if (primitiveValue->isLength())
         length = primitiveValue->computeLength<Length>(m_resolver->state().cssToLengthConversionData());
     else if (primitiveValue->isPercentage())
-        length = Length(primitiveValue->getDoubleValue(), Percent);
+        length = Length(primitiveValue->doubleValue(), Percent);
     else if (primitiveValue->isCalculatedPercentageWithLength())
         length = Length(primitiveValue->cssCalcValue()->createCalculationValue(m_resolver->state().cssToLengthConversionData()));
     else
@@ -266,7 +266,7 @@ void CSSToStyleMap::mapFillYPosition(CSSPropertyID propertyID, FillLayer& layer,
         return;
 
     auto* primitiveValue = &downcast<CSSPrimitiveValue>(value);
-    Pair* pair = primitiveValue->getPairValue();
+    Pair* pair = primitiveValue->pairValue();
     if (pair) {
         ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPositionY || propertyID == CSSPropertyWebkitMaskPositionY);
         primitiveValue = pair->second();
@@ -276,7 +276,7 @@ void CSSToStyleMap::mapFillYPosition(CSSPropertyID propertyID, FillLayer& layer,
     if (primitiveValue->isLength())
         length = primitiveValue->computeLength<Length>(m_resolver->state().cssToLengthConversionData());
     else if (primitiveValue->isPercentage())
-        length = Length(primitiveValue->getDoubleValue(), Percent);
+        length = Length(primitiveValue->doubleValue(), Percent);
     else if (primitiveValue->isCalculatedPercentageWithLength())
         length = Length(primitiveValue->cssCalcValue()->createCalculationValue(m_resolver->state().cssToLengthConversionData()));
     else
@@ -298,7 +298,7 @@ void CSSToStyleMap::mapFillMaskSourceType(CSSPropertyID propertyID, FillLayer& l
     if (!is<CSSPrimitiveValue>(value))
         return;
 
-    switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
+    switch (downcast<CSSPrimitiveValue>(value).valueID()) {
     case CSSValueAlpha:
         type = EMaskSourceType::MaskAlpha;
         break;
@@ -337,7 +337,7 @@ void CSSToStyleMap::mapAnimationDirection(Animation& layer, const CSSValue& valu
     if (!is<CSSPrimitiveValue>(value))
         return;
 
-    switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
+    switch (downcast<CSSPrimitiveValue>(value).valueID()) {
     case CSSValueNormal:
         layer.setDirection(Animation::AnimationDirectionNormal);
         break;
@@ -378,7 +378,7 @@ void CSSToStyleMap::mapAnimationFillMode(Animation& layer, const CSSValue& value
     if (!is<CSSPrimitiveValue>(value))
         return;
 
-    switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
+    switch (downcast<CSSPrimitiveValue>(value).valueID()) {
     case CSSValueNone:
         layer.setFillMode(AnimationFillModeNone);
         break;
@@ -407,10 +407,10 @@ void CSSToStyleMap::mapAnimationIterationCount(Animation& animation, const CSSVa
         return;
 
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueInfinite)
+    if (primitiveValue.valueID() == CSSValueInfinite)
         animation.setIterationCount(Animation::IterationCountInfinite);
     else
-        animation.setIterationCount(primitiveValue.getFloatValue());
+        animation.setIterationCount(primitiveValue.floatValue());
 }
 
 void CSSToStyleMap::mapAnimationName(Animation& layer, const CSSValue& value)
@@ -424,10 +424,10 @@ void CSSToStyleMap::mapAnimationName(Animation& layer, const CSSValue& value)
         return;
 
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueNone)
+    if (primitiveValue.valueID() == CSSValueNone)
         layer.setIsNoneAnimation(true);
     else
-        layer.setName(primitiveValue.getStringValue());
+        layer.setName(primitiveValue.stringValue());
 }
 
 void CSSToStyleMap::mapAnimationPlayState(Animation& layer, const CSSValue& value)
@@ -440,7 +440,7 @@ void CSSToStyleMap::mapAnimationPlayState(Animation& layer, const CSSValue& valu
     if (!is<CSSPrimitiveValue>(value))
         return;
 
-    EAnimPlayState playState = (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValuePaused) ? AnimPlayStatePaused : AnimPlayStatePlaying;
+    EAnimPlayState playState = (downcast<CSSPrimitiveValue>(value).valueID() == CSSValuePaused) ? AnimPlayStatePaused : AnimPlayStatePlaying;
     layer.setPlayState(playState);
 }
 
@@ -456,15 +456,15 @@ void CSSToStyleMap::mapAnimationProperty(Animation& animation, const CSSValue& v
         return;
 
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueAll) {
+    if (primitiveValue.valueID() == CSSValueAll) {
         animation.setAnimationMode(Animation::AnimateAll);
         animation.setProperty(CSSPropertyInvalid);
-    } else if (primitiveValue.getValueID() == CSSValueNone) {
+    } else if (primitiveValue.valueID() == CSSValueNone) {
         animation.setAnimationMode(Animation::AnimateNone);
         animation.setProperty(CSSPropertyInvalid);
     } else {
         animation.setAnimationMode(Animation::AnimateSingleProperty);
-        animation.setProperty(primitiveValue.getPropertyID());
+        animation.setProperty(primitiveValue.propertyID());
     }
 }
 
@@ -476,7 +476,7 @@ void CSSToStyleMap::mapAnimationTimingFunction(Animation& animation, const CSSVa
     }
 
     if (is<CSSPrimitiveValue>(value)) {
-        switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
+        switch (downcast<CSSPrimitiveValue>(value).valueID()) {
         case CSSValueLinear:
             animation.setTimingFunction(LinearTimingFunction::create());
             break;
@@ -526,7 +526,7 @@ void CSSToStyleMap::mapAnimationTrigger(Animation& animation, const CSSValue& va
 
     if (value.isPrimitiveValue()) {
         auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-        if (primitiveValue.getValueID() == CSSValueAuto)
+        if (primitiveValue.valueID() == CSSValueAuto)
             animation.setTrigger(AutoAnimationTrigger::create());
         return;
     }
@@ -608,21 +608,21 @@ void CSSToStyleMap::mapNinePieceImageSlice(CSSValue& value, NinePieceImage& imag
     LengthBox box;
     Quad* slices = borderImageSlice.slices();
     if (slices->top()->isPercentage())
-        box.top() = Length(slices->top()->getDoubleValue(), Percent);
+        box.top() = Length(slices->top()->doubleValue(), Percent);
     else
-        box.top() = Length(slices->top()->getIntValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
+        box.top() = Length(slices->top()->intValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
     if (slices->bottom()->isPercentage())
-        box.bottom() = Length(slices->bottom()->getDoubleValue(), Percent);
+        box.bottom() = Length(slices->bottom()->doubleValue(), Percent);
     else
-        box.bottom() = Length((int)slices->bottom()->getFloatValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
+        box.bottom() = Length((int)slices->bottom()->floatValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
     if (slices->left()->isPercentage())
-        box.left() = Length(slices->left()->getDoubleValue(), Percent);
+        box.left() = Length(slices->left()->doubleValue(), Percent);
     else
-        box.left() = Length(slices->left()->getIntValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
+        box.left() = Length(slices->left()->intValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
     if (slices->right()->isPercentage())
-        box.right() = Length(slices->right()->getDoubleValue(), Percent);
+        box.right() = Length(slices->right()->doubleValue(), Percent);
     else
-        box.right() = Length(slices->right()->getIntValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
+        box.right() = Length(slices->right()->intValue(CSSPrimitiveValue::CSS_NUMBER), Fixed);
     image.setImageSlices(box);
 
     // Set our fill mode.
@@ -642,33 +642,33 @@ LengthBox CSSToStyleMap::mapNinePieceImageQuad(CSSValue& value)
 
     // Set up a length box to represent our image slices.
     LengthBox box; // Defaults to 'auto' so we don't have to handle that explicitly below.
-    Quad* slices = borderWidths.getQuadValue();
+    Quad* slices = borderWidths.quadValue();
     if (slices->top()->isNumber())
-        box.top() = Length(slices->top()->getIntValue(), Relative);
+        box.top() = Length(slices->top()->intValue(), Relative);
     else if (slices->top()->isPercentage())
-        box.top() = Length(slices->top()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
-    else if (slices->top()->getValueID() != CSSValueAuto)
+        box.top() = Length(slices->top()->doubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+    else if (slices->top()->valueID() != CSSValueAuto)
         box.top() = slices->top()->computeLength<Length>(conversionData);
 
     if (slices->right()->isNumber())
-        box.right() = Length(slices->right()->getIntValue(), Relative);
+        box.right() = Length(slices->right()->intValue(), Relative);
     else if (slices->right()->isPercentage())
-        box.right() = Length(slices->right()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
-    else if (slices->right()->getValueID() != CSSValueAuto)
+        box.right() = Length(slices->right()->doubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+    else if (slices->right()->valueID() != CSSValueAuto)
         box.right() = slices->right()->computeLength<Length>(conversionData);
 
     if (slices->bottom()->isNumber())
-        box.bottom() = Length(slices->bottom()->getIntValue(), Relative);
+        box.bottom() = Length(slices->bottom()->intValue(), Relative);
     else if (slices->bottom()->isPercentage())
-        box.bottom() = Length(slices->bottom()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
-    else if (slices->bottom()->getValueID() != CSSValueAuto)
+        box.bottom() = Length(slices->bottom()->doubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+    else if (slices->bottom()->valueID() != CSSValueAuto)
         box.bottom() = slices->bottom()->computeLength<Length>(conversionData);
 
     if (slices->left()->isNumber())
-        box.left() = Length(slices->left()->getIntValue(), Relative);
+        box.left() = Length(slices->left()->intValue(), Relative);
     else if (slices->left()->isPercentage())
-        box.left() = Length(slices->left()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
-    else if (slices->left()->getValueID() != CSSValueAuto)
+        box.left() = Length(slices->left()->doubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+    else if (slices->left()->valueID() != CSSValueAuto)
         box.left() = slices->left()->computeLength<Length>(conversionData);
 
     return box;
@@ -680,12 +680,12 @@ void CSSToStyleMap::mapNinePieceImageRepeat(CSSValue& value, NinePieceImage& ima
         return;
 
     CSSPrimitiveValue& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    Pair* pair = primitiveValue.getPairValue();
+    Pair* pair = primitiveValue.pairValue();
     if (!pair || !pair->first() || !pair->second())
         return;
 
-    CSSValueID firstIdentifier = pair->first()->getValueID();
-    CSSValueID secondIdentifier = pair->second()->getValueID();
+    CSSValueID firstIdentifier = pair->first()->valueID();
+    CSSValueID secondIdentifier = pair->second()->valueID();
 
     ENinePieceImageRule horizontalRule;
     switch (firstIdentifier) {
index f99d373..efd9881 100644 (file)
@@ -20,7 +20,7 @@
 
 #pragma once
 
-#include "ExceptionCode.h"
+#include "ExceptionOr.h"
 #include "URLHash.h"
 #include <wtf/HashMap.h>
 #include <wtf/ListHashSet.h>
@@ -64,7 +64,7 @@ public:
 
     WEBCORE_EXPORT String cssText() const;
 
-    void setCssText(const String&, ExceptionCode&) { } // FIXME: Not implemented.
+    ExceptionOr<void> setCssText(const String&) { return { }; } // FIXME: Not implemented.
 
     bool isPrimitiveValue() const { return m_classType == PrimitiveClass; }
     bool isValueList() const { return m_classType >= ValueListClass; }
index 609bfc0..8cf1654 100644 (file)
@@ -19,8 +19,8 @@
  */
 
 [
-    CustomToJSObject,
     CustomIsReachable,
+    CustomToJSObject,
     ExportToWrappedFunction,
     ImplementationLacksVTable,
     JSCustomFinalize,
@@ -31,7 +31,7 @@
     const unsigned short CSS_VALUE_LIST = 2;
     const unsigned short CSS_CUSTOM = 3;
 
-    [SetterMayThrowLegacyException] attribute DOMString? cssText;
+    [SetterMayThrowException] attribute DOMString? cssText;
 
     readonly attribute unsigned short cssValueType;
 };
index 1b210be..7146a72 100644 (file)
@@ -32,11 +32,11 @@ public:
         return adoptRef(*new Counter(WTFMove(identifier), WTFMove(listStyle), WTFMove(separator)));
     }
 
-    String identifier() const { return m_identifier->getStringValue(); }
-    String listStyle() const { return m_listStyle->getStringValue(); }
-    String separator() const { return m_separator->getStringValue(); }
+    String identifier() const { return m_identifier->stringValue(); }
+    String listStyle() const { return m_listStyle->stringValue(); }
+    String separator() const { return m_separator->stringValue(); }
 
-    CSSValueID listStyleIdent() const { return m_listStyle->getValueID(); }
+    CSSValueID listStyleIdent() const { return m_listStyle->valueID(); }
 
     void setIdentifier(Ref<CSSPrimitiveValue>&& identifier) { m_identifier = WTFMove(identifier); }
     void setListStyle(Ref<CSSPrimitiveValue>&& listStyle) { m_listStyle = WTFMove(listStyle); }
index df20702..f91639a 100644 (file)
@@ -45,23 +45,20 @@ static bool populateFontFaceWithArrayBuffer(CSSFontFace& fontFace, Ref<JSC::Arra
     return false;
 }
 
-RefPtr<FontFace> FontFace::create(JSC::ExecState& state, Document& document, const String& family, JSC::JSValue source, const Descriptors& descriptors, ExceptionCode& ec)
+ExceptionOr<Ref<FontFace>> FontFace::create(JSC::ExecState& state, Document& document, const String& family, JSC::JSValue source, const Descriptors& descriptors)
 {
     auto result = adoptRef(*new FontFace(document.fontSelector()));
 
     bool dataRequiresAsynchronousLoading = true;
 
-    ec = 0;
-    result->setFamily(family, ec);
-    if (ec)
-        return nullptr;
+    auto setFamilyResult = result->setFamily(family);
+    if (setFamilyResult.hasException())
+        return setFamilyResult.releaseException();
 
     if (source.isString()) {
         auto value = FontFace::parseString(source.getString(&state), CSSPropertySrc);
-        if (!is<CSSValueList>(value.get())) {
-            ec = SYNTAX_ERR;
-            return nullptr;
-        }
+        if (!is<CSSValueList>(value.get()))
+            return Exception { SYNTAX_ERR };
         CSSFontFace::appendSources(result->backing(), downcast<CSSValueList>(*value), &document, false);
     } else if (auto arrayBufferView = toArrayBufferView(source))
         dataRequiresAsynchronousLoading = populateFontFaceWithArrayBuffer(result->backing(), arrayBufferView.releaseNonNull());
@@ -71,24 +68,24 @@ RefPtr<FontFace> FontFace::create(JSC::ExecState& state, Document& document, con
     }
 
     // These ternaries match the default strings inside the FontFaceDescriptors dictionary inside FontFace.idl.
-    result->setStyle(descriptors.style.isEmpty() ? ASCIILiteral("normal") : descriptors.style, ec);
-    if (ec)
-        return nullptr;
-    result->setWeight(descriptors.weight.isEmpty() ? ASCIILiteral("normal") : descriptors.weight, ec);
-    if (ec)
-        return nullptr;
-    result->setStretch(descriptors.stretch.isEmpty() ? ASCIILiteral("normal") : descriptors.stretch, ec);
-    if (ec)
-        return nullptr;
-    result->setUnicodeRange(descriptors.unicodeRange.isEmpty() ? ASCIILiteral("U+0-10FFFF") : descriptors.unicodeRange, ec);
-    if (ec)
-        return nullptr;
-    result->setVariant(descriptors.variant.isEmpty() ? ASCIILiteral("normal") : descriptors.variant, ec);
-    if (ec)
-        return nullptr;
-    result->setFeatureSettings(descriptors.featureSettings.isEmpty() ? ASCIILiteral("normal") : descriptors.featureSettings, ec);
-    if (ec)
-        return nullptr;
+    auto setStyleResult = result->setStyle(descriptors.style.isEmpty() ? ASCIILiteral("normal") : descriptors.style);
+    if (setStyleResult.hasException())
+        return setStyleResult.releaseException();
+    auto setWeightResult = result->setWeight(descriptors.weight.isEmpty() ? ASCIILiteral("normal") : descriptors.weight);
+    if (setWeightResult.hasException())
+        return setWeightResult.releaseException();
+    auto setStretchResult = result->setStretch(descriptors.stretch.isEmpty() ? ASCIILiteral("normal") : descriptors.stretch);
+    if (setStretchResult.hasException())
+        return setStretchResult.releaseException();
+    auto setUnicodeRangeResult = result->setUnicodeRange(descriptors.unicodeRange.isEmpty() ? ASCIILiteral("U+0-10FFFF") : descriptors.unicodeRange);
+    if (setUnicodeRangeResult.hasException())
+        return setUnicodeRangeResult.releaseException();
+    auto setVariantResult = result->setVariant(descriptors.variant.isEmpty() ? ASCIILiteral("normal") : descriptors.variant);
+    if (setVariantResult.hasException())
+        return setVariantResult.releaseException();
+    auto setFeatureSettingsResult = result->setFeatureSettings(descriptors.featureSettings.isEmpty() ? ASCIILiteral("normal") : descriptors.featureSettings);
+    if (setFeatureSettingsResult.hasException())
+        return setFeatureSettingsResult.releaseException();
 
     if (!dataRequiresAsynchronousLoading) {
         result->backing().load();
@@ -135,80 +132,73 @@ RefPtr<CSSValue> FontFace::parseString(const String& string, CSSPropertyID prope
     return style->getPropertyCSSValue(propertyID);
 }
 
-void FontFace::setFamily(const String& family, ExceptionCode& ec)
+ExceptionOr<void> FontFace::setFamily(const String& family)
 {
-    if (family.isEmpty()) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (family.isEmpty())
+        return Exception { SYNTAX_ERR };
 
     bool success = false;
     if (auto value = parseString(family, CSSPropertyFontFamily))
         success = m_backing->setFamilies(*value);
     if (!success)
-        ec = SYNTAX_ERR;
+        return Exception { SYNTAX_ERR };
+    return { };
 }
 
-void FontFace::setStyle(const String& style, ExceptionCode& ec)
+ExceptionOr<void> FontFace::setStyle(const String& style)
 {
-    if (style.isEmpty()) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (style.isEmpty())
+        return Exception { SYNTAX_ERR };
 
     bool success = false;
     if (auto value = parseString(style, CSSPropertyFontStyle))
         success = m_backing->setStyle(*value);
     if (!success)
-        ec = SYNTAX_ERR;
+        return Exception { SYNTAX_ERR };
+    return { };
 }
 
-void FontFace::setWeight(const String& weight, ExceptionCode& ec)
+ExceptionOr<void> FontFace::setWeight(const String& weight)
 {
-    if (weight.isEmpty()) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (weight.isEmpty())
+        return Exception { SYNTAX_ERR };
 
     bool success = false;
     if (auto value = parseString(weight, CSSPropertyFontWeight))
         success = m_backing->setWeight(*value);
     if (!success)
-        ec = SYNTAX_ERR;
+        return Exception { SYNTAX_ERR };
+    return { };
 }
 
-void FontFace::setStretch(const String&, ExceptionCode&)
+ExceptionOr<void> FontFace::setStretch(const String&)
 {
     // We don't support font-stretch. Swallow the call.
+    return { };
 }
 
-void FontFace::setUnicodeRange(const String& unicodeRange, ExceptionCode& ec)
+ExceptionOr<void> FontFace::setUnicodeRange(const String& unicodeRange)
 {
-    if (unicodeRange.isEmpty()) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (unicodeRange.isEmpty())
+        return Exception { SYNTAX_ERR };
 
     bool success = false;
     if (auto value = parseString(unicodeRange, CSSPropertyUnicodeRange))
         success = m_backing->setUnicodeRange(*value);
     if (!success)
-        ec = SYNTAX_ERR;
+        return Exception { SYNTAX_ERR };
+    return { };
 }
 
-void FontFace::setVariant(const String& variant, ExceptionCode& ec)
+ExceptionOr<void> FontFace::setVariant(const String& variant)
 {
-    if (variant.isEmpty()) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (variant.isEmpty())
+        return Exception { SYNTAX_ERR };
 
     auto style = MutableStyleProperties::create();
     auto result = CSSParser::parseValue(style, CSSPropertyFontVariant, variant, true, HTMLStandardMode, nullptr);
-    if (result == CSSParser::ParseResult::Error) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (result == CSSParser::ParseResult::Error)
+        return Exception { SYNTAX_ERR };
 
     // FIXME: Would be much better to stage the new settings and set them all at once
     // instead of this dance where we make a backup and revert to it if something fails.
@@ -249,23 +239,22 @@ void FontFace::setVariant(const String& variant, ExceptionCode& ec)
 
     if (!success) {
         m_backing->setVariantSettings(backup);
-        ec = SYNTAX_ERR;
+        return Exception { SYNTAX_ERR };
     }
+
+    return { };
 }
 
-void FontFace::setFeatureSettings(const String& featureSettings, ExceptionCode& ec)
+ExceptionOr<void> FontFace::setFeatureSettings(const String& featureSettings)
 {
-    if (featureSettings.isEmpty()) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (featureSettings.isEmpty())
+        return Exception { SYNTAX_ERR };
 
     auto value = parseString(featureSettings, CSSPropertyFontFeatureSettings);
-    if (!value) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (!value)
+        return Exception { SYNTAX_ERR };
     m_backing->setFeatureSettings(*value);
+    return { };
 }
 
 String FontFace::family() const
index ed30ddb..fa8f313 100644 (file)
@@ -42,17 +42,17 @@ public:
         String variant;
         String featureSettings;
     };
-    static RefPtr<FontFace> create(JSC::ExecState&, Document&, const String& family, JSC::JSValue source, const Descriptors&, ExceptionCode&);
+    static ExceptionOr<Ref<FontFace>> create(JSC::ExecState&, Document&, const String& family, JSC::JSValue source, const Descriptors&);
     static Ref<FontFace> create(CSSFontFace&);
     virtual ~FontFace();
 
-    void setFamily(const String&, ExceptionCode&);
-    void setStyle(const String&, ExceptionCode&);
-    void setWeight(const String&, ExceptionCode&);
-    void setStretch(const String&, ExceptionCode&);
-    void setUnicodeRange(const String&, ExceptionCode&);
-    void setVariant(const String&, ExceptionCode&);
-    void setFeatureSettings(const String&, ExceptionCode&);
+    ExceptionOr<void> setFamily(const String&);
+    ExceptionOr<void> setStyle(const String&);
+    ExceptionOr<void> setWeight(const String&);
+    ExceptionOr<void> setStretch(const String&);
+    ExceptionOr<void> setUnicodeRange(const String&);
+    ExceptionOr<void> setVariant(const String&);
+    ExceptionOr<void> setFeatureSettings(const String&);
 
     String family() const;
     String style() const;
index 77fa147..5695b5d 100644 (file)
@@ -41,16 +41,16 @@ dictionary FontFaceDescriptors {
 
 [
     ConstructorCallWith=Document&ScriptState,
-    ConstructorMayThrowLegacyException,
+    ConstructorMayThrowException,
     Constructor(DOMString family, any source, optional FontFaceDescriptors descriptors)
 ] interface FontFace {
-    [SetterMayThrowLegacyException] attribute DOMString family;
-    [SetterMayThrowLegacyException] attribute DOMString style;
-    [SetterMayThrowLegacyException] attribute DOMString weight;
-    [SetterMayThrowLegacyException] attribute DOMString stretch;
-    [SetterMayThrowLegacyException] attribute DOMString unicodeRange;
-    [SetterMayThrowLegacyException] attribute DOMString variant;
-    [SetterMayThrowLegacyException] attribute DOMString featureSettings;
+    [SetterMayThrowException] attribute DOMString family;
+    [SetterMayThrowException] attribute DOMString style;
+    [SetterMayThrowException] attribute DOMString weight;
+    [SetterMayThrowException] attribute DOMString stretch;
+    [SetterMayThrowException] attribute DOMString unicodeRange;
+    [SetterMayThrowException] attribute DOMString variant;
+    [SetterMayThrowException] attribute DOMString featureSettings;
 
     readonly attribute FontFaceLoadStatus status;
 
index 0d55dd7..139c455 100644 (file)
@@ -125,12 +125,12 @@ void FontFaceSet::clear()
 
 void FontFaceSet::load(const String& font, const String& text, LoadPromise&& promise)
 {
-    ExceptionCode ec = 0;
-    auto matchingFaces = m_backing->matchingFaces(font, text, ec);
-    if (ec) {
-        promise.reject(ec);
+    auto matchingFacesResult = m_backing->matchingFaces(font, text);
+    if (matchingFacesResult.hasException()) {
+        promise.reject(matchingFacesResult.releaseException());
         return;
     }
+    auto matchingFaces = matchingFacesResult.releaseReturnValue();
 
     if (matchingFaces.isEmpty()) {
         promise.resolve(Vector<RefPtr<FontFace>>());
@@ -162,9 +162,9 @@ void FontFaceSet::load(const String& font, const String& text, LoadPromise&& pro
         pendingPromise->promise.resolve(pendingPromise->faces);
 }
 
-bool FontFaceSet::check(const String& family, const String& text, ExceptionCode& ec)
+ExceptionOr<bool> FontFaceSet::check(const String& family, const String& text)
 {
-    return m_backing->check(family, text, ec);
+    return m_backing->check(family, text);
 }
 
 void FontFaceSet::registerReady(ReadyPromise&& promise)
index ac27480..e1a7274 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef FontFaceSet_h
-#define FontFaceSet_h
+#pragma once
 
 #include "ActiveDOMObject.h"
 #include "CSSFontFaceSet.h"
@@ -49,7 +48,7 @@ public:
 
     typedef DOMPromise<Vector<RefPtr<FontFace>>> LoadPromise;
     void load(const String& font, const String& text, LoadPromise&&);
-    bool check(const String& font, const String& text, ExceptionCode&);
+    ExceptionOr<bool> check(const String& font, const String& text);
 
     enum class LoadStatus { Loading, Loaded };
     LoadStatus status() const;
@@ -115,5 +114,3 @@ private:
 };
 
 }
-
-#endif
index b76a1a1..7ab1e3c 100644 (file)
@@ -48,7 +48,7 @@ enum FontFaceSetLoadStatus {
     attribute EventHandler onloadingerror;
 
     Promise load(DOMString font, optional DOMString text = " ");
-    [MayThrowLegacyException] boolean check(DOMString font, optional DOMString text = " ");
+    [MayThrowException] boolean check(DOMString font, optional DOMString text = " ");
 
     [CustomGetter, CachedAttribute] readonly attribute Promise ready;
     readonly attribute FontFaceSetLoadStatus status;
index 92fb66f..54648ae 100644 (file)
@@ -42,7 +42,7 @@ FontVariantLigaturesValues extractFontVariantLigatures(const CSSValue& value)
 
     if (is<CSSValueList>(value)) {
         for (auto& item : downcast<CSSValueList>(value)) {
-            switch (downcast<CSSPrimitiveValue>(item.get()).getValueID()) {
+            switch (downcast<CSSPrimitiveValue>(item.get()).valueID()) {
             case CSSValueNoCommonLigatures:
                 common = FontVariantLigatures::No;
                 break;
@@ -73,7 +73,7 @@ FontVariantLigaturesValues extractFontVariantLigatures(const CSSValue& value)
             }
         }
     } else if (is<CSSPrimitiveValue>(value)) {
-        switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
+        switch (downcast<CSSPrimitiveValue>(value).valueID()) {
         case CSSValueNormal:
             break;
         case CSSValueNone:
@@ -101,7 +101,7 @@ FontVariantNumericValues extractFontVariantNumeric(const CSSValue& value)
 
     if (is<CSSValueList>(value)) {
         for (auto& item : downcast<CSSValueList>(value)) {
-            switch (downcast<CSSPrimitiveValue>(item.get()).getValueID()) {
+            switch (downcast<CSSPrimitiveValue>(item.get()).valueID()) {
             case CSSValueLiningNums:
                 figure = FontVariantNumericFigure::LiningNumbers;
                 break;
@@ -132,7 +132,7 @@ FontVariantNumericValues extractFontVariantNumeric(const CSSValue& value)
             }
         }
     } else if (is<CSSPrimitiveValue>(value))
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal);
 
     return FontVariantNumericValues(figure, spacing, fraction, ordinal, slashedZero);
 }
@@ -145,7 +145,7 @@ FontVariantEastAsianValues extractFontVariantEastAsian(const CSSValue& value)
 
     if (is<CSSValueList>(value)) {
         for (auto& item : downcast<CSSValueList>(value)) {
-            switch (downcast<CSSPrimitiveValue>(item.get()).getValueID()) {
+            switch (downcast<CSSPrimitiveValue>(item.get()).valueID()) {
             case CSSValueJis78:
                 variant = FontVariantEastAsianVariant::Jis78;
                 break;
@@ -179,7 +179,7 @@ FontVariantEastAsianValues extractFontVariantEastAsian(const CSSValue& value)
             }
         }
     } else if (is<CSSPrimitiveValue>(value))
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal);
 
     return FontVariantEastAsianValues(variant, width, ruby);
 }
index 29d8269..e853887 100644 (file)
@@ -222,15 +222,14 @@ MediaList::~MediaList()
 {
 }
 
-void MediaList::setMediaText(const String& value, ExceptionCode& ec)
+ExceptionOr<void> MediaList::setMediaText(const String& value)
 {
     CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
-    if (!m_mediaQueries->parse(value)) {
-        ec = SYNTAX_ERR;
-        return;
-    }
+    if (!m_mediaQueries->parse(value))
+        return Exception { SYNTAX_ERR };
     if (m_parentStyleSheet)
         m_parentStyleSheet->didMutate();
+    return { };
 }
 
 String MediaList::item(unsigned index) const
@@ -241,31 +240,30 @@ String MediaList::item(unsigned index) const
     return String();
 }
 
-void MediaList::deleteMedium(const String& medium, ExceptionCode& ec)
+ExceptionOr<void> MediaList::deleteMedium(const String& medium)
 {
     CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
 
     bool success = m_mediaQueries->remove(medium);
-    if (!success) {
-        ec = NOT_FOUND_ERR;
-        return;
-    }
+    if (!success)
+        return Exception { NOT_FOUND_ERR };
     if (m_parentStyleSheet)
         m_parentStyleSheet->didMutate();
+    return { };
 }
 
-void MediaList::appendMedium(const String& medium, ExceptionCode& ec)
+ExceptionOr<void> MediaList::appendMedium(const String& medium)
 {
     CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
 
     bool success = m_mediaQueries->add(medium);
     if (!success) {
         // FIXME: Should this really be INVALID_CHARACTER_ERR?
-        ec = INVALID_CHARACTER_ERR;
-        return;
+        return Exception { INVALID_CHARACTER_ERR };
     }
     if (m_parentStyleSheet)
         m_parentStyleSheet->didMutate();
+    return { };
 }
 
 void MediaList::reattach(MediaQuerySet* mediaQueries)
index bf071fe..672aa4a 100644 (file)
 
 #pragma once
 
+#include "ExceptionOr.h"
 #include <memory>
 #include <wtf/Forward.h>
 #include <wtf/Vector.h>
-#include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
@@ -33,8 +33,6 @@ class CSSStyleSheet;
 class Document;
 class MediaQuery;
 
-using ExceptionCode = int;
-
 class MediaQuerySet final : public RefCounted<MediaQuerySet> {
 public:
     static Ref<MediaQuerySet> create()
@@ -96,11 +94,11 @@ public:
 
     unsigned length() const { return m_mediaQueries->queryVector().size(); }
     WEBCORE_EXPORT String item(unsigned index) const;
-    WEBCORE_EXPORT void deleteMedium(const String& oldMedium, ExceptionCode&);
-    WEBCORE_EXPORT void appendMedium(const String& newMedium, ExceptionCode&);
+    WEBCORE_EXPORT ExceptionOr<void> deleteMedium(const String& oldMedium);
+    WEBCORE_EXPORT ExceptionOr<void> appendMedium(const String& newMedium);
 
     String mediaText() const { return m_mediaQueries->mediaText(); }
-    WEBCORE_EXPORT void setMediaText(const String&, ExceptionCode&);
+    WEBCORE_EXPORT ExceptionOr<void> setMediaText(const String&);
 
     CSSRule* parentRule() const { return m_parentRule; }
     CSSStyleSheet* parentStyleSheet() const { return m_parentStyleSheet; }
index baf5c93..6d6d3c4 100644 (file)
     ImplementationLacksVTable,
     JSCustomHeader,
 ] interface MediaList {
-    [SetterMayThrowLegacyException, TreatNullAs=EmptyString] attribute DOMString mediaText;
+    [SetterMayThrowException, TreatNullAs=EmptyString] attribute DOMString mediaText;
     readonly attribute unsigned long length;
 
     getter DOMString? item(unsigned long index);
 
-    [MayThrowLegacyException] void deleteMedium(DOMString oldMedium);
-    [MayThrowLegacyException] void appendMedium(DOMString newMedium);
+    [MayThrowException] void deleteMedium(DOMString oldMedium);
+    [MayThrowException] void appendMedium(DOMString newMedium);
 };
index 75bb746..2c1cd23 100644 (file)
@@ -208,7 +208,7 @@ static Optional<double> doubleValue(CSSValue* value)
 {
     if (!is<CSSPrimitiveValue>(value) || !downcast<CSSPrimitiveValue>(*value).isNumber())
         return Nullopt;
-    return downcast<CSSPrimitiveValue>(*value).getDoubleValue(CSSPrimitiveValue::CSS_NUMBER);
+    return downcast<CSSPrimitiveValue>(*value).doubleValue(CSSPrimitiveValue::CSS_NUMBER);
 }
 
 static bool zeroEvaluate(CSSValue* value, MediaFeaturePrefix op)
@@ -245,7 +245,7 @@ static bool colorGamutEvaluate(CSSValue* value, const CSSToLengthConversionData&
     if (!value)
         return true;
 
-    switch (downcast<CSSPrimitiveValue>(*value).getValueID()) {
+    switch (downcast<CSSPrimitiveValue>(*value).valueID()) {
     case CSSValueSrgb:
         return true;
     case CSSValueP3:
@@ -271,7 +271,7 @@ static bool invertedColorsEvaluate(CSSValue* value, const CSSToLengthConversionD
     bool isInverted = screenHasInvertedColors();
     if (!value)
         return isInverted;
-    return downcast<CSSPrimitiveValue>(*value).getValueID() == (isInverted ? CSSValueInverted : CSSValueNone);
+    return downcast<CSSPrimitiveValue>(*value).valueID() == (isInverted ? CSSValueInverted : CSSValueNone);
 }
 
 static bool orientationEvaluate(CSSValue* value, const CSSToLengthConversionData&, Frame& frame, MediaFeaturePrefix)
@@ -288,7 +288,7 @@ static bool orientationEvaluate(CSSValue* value, const CSSToLengthConversionData
         return height >= 0 && width >= 0;
     }
 
-    auto keyword = downcast<CSSPrimitiveValue>(*value).getValueID();
+    auto keyword = downcast<CSSPrimitiveValue>(*value).valueID();
     if (width > height) // Square viewport is portrait.
         return keyword == CSSValueLandscape;
     return keyword == CSSValuePortrait;
@@ -349,7 +349,7 @@ static bool evaluateResolution(CSSValue* value, Frame& frame, MediaFeaturePrefix
         return false;
 
     auto& resolution = downcast<CSSPrimitiveValue>(*value);
-    return compareValue(deviceScaleFactor, resolution.isNumber() ? resolution.getFloatValue() : resolution.getFloatValue(CSSPrimitiveValue::CSS_DPPX), op);
+    return compareValue(deviceScaleFactor, resolution.isNumber() ? resolution.floatValue() : resolution.floatValue(CSSPrimitiveValue::CSS_DPPX), op);
 }
 
 static bool devicePixelRatioEvaluate(CSSValue* value, const CSSToLengthConversionData&, Frame& frame, MediaFeaturePrefix op)
@@ -382,7 +382,7 @@ static bool computeLength(CSSValue* value, bool strict, const CSSToLengthConvers
     auto& primitiveValue = downcast<CSSPrimitiveValue>(*value);
 
     if (primitiveValue.isNumber()) {
-        result = primitiveValue.getIntValue();
+        result = primitiveValue.intValue();
         return !strict || !result;
     }
 
@@ -587,7 +587,7 @@ static bool viewModeEvaluate(CSSValue* value, const CSSToLengthConversionData&,
     if (!value)
         return true;
 
-    auto keyword = downcast<CSSPrimitiveValue>(*value).getValueID();
+    auto keyword = downcast<CSSPrimitiveValue>(*value).valueID();
 
     switch (frame.page()->viewMode()) {
     case Page::ViewModeWindowed:
@@ -624,7 +624,7 @@ static bool hoverEvaluate(CSSValue* value, const CSSToLengthConversionData&, Fra
 #endif
     }
 
-    auto keyword = downcast<CSSPrimitiveValue>(*value).getValueID();
+    auto keyword = downcast<CSSPrimitiveValue>(*value).valueID();
 #if ENABLE(TOUCH_EVENTS)
     return keyword == CSSValueNone;
 #else
@@ -642,7 +642,7 @@ static bool pointerEvaluate(CSSValue* value, const CSSToLengthConversionData&, F
     if (!is<CSSPrimitiveValue>(value))
         return true;
 
-    auto keyword = downcast<CSSPrimitiveValue>(*value).getValueID();
+    auto keyword = downcast<CSSPrimitiveValue>(*value).valueID();
 #if ENABLE(TOUCH_EVENTS)
     return keyword == CSSValueCoarse;
 #else
@@ -671,7 +671,7 @@ static bool prefersReducedMotionEvaluate(CSSValue* value, const CSSToLengthConve
     if (!value)
         return userPrefersReducedMotion;
 
-    return downcast<CSSPrimitiveValue>(*value).getValueID() == (userPrefersReducedMotion ? CSSValueReduce : CSSValueDefault);
+    return downcast<CSSPrimitiveValue>(*value).valueID() == (userPrefersReducedMotion ? CSSValueReduce : CSSValueDefault);
 }
 
 // Use this function instead of calling add directly to avoid inlining.
index 80f2f77..6bed94a 100644 (file)
@@ -129,7 +129,7 @@ static inline bool isFeatureValidWithIdentifier(const AtomicString& mediaFeature
 
 static inline bool isFeatureValidWithNonNegativeLengthOrNumber(const AtomicString& mediaFeature, const CSSParserValue& value)
 {
-    if (!(CSSPrimitiveValue::isLength(value.unit) || value.unit == CSSPrimitiveValue::CSS_NUMBER) || value.fValue < 0)
+    if (!(CSSPrimitiveValue::isLength(static_cast<CSSPrimitiveValue::UnitTypes>(value.unit)) || value.unit == CSSPrimitiveValue::CSS_NUMBER) || value.fValue < 0)
         return false;
 
     return mediaFeature == MediaFeatureNames::height
@@ -148,7 +148,7 @@ static inline bool isFeatureValidWithNonNegativeLengthOrNumber(const AtomicStrin
 
 static inline bool isFeatureValidWithDensity(const AtomicString& mediaFeature, const CSSParserValue& value)
 {
-    if (!CSSPrimitiveValue::isResolution(value.unit) || value.fValue <= 0)
+    if (!CSSPrimitiveValue::isResolution(static_cast<CSSPrimitiveValue::UnitTypes>(value.unit)) || value.fValue <= 0)
         return false;
 
     return mediaFeature == MediaFeatureNames::resolution
index 99fc5dd..fd5e1b4 100644 (file)
@@ -148,17 +148,18 @@ String PropertySetCSSStyleDeclaration::cssText() const
     return m_propertySet->asText();
 }
 
-void PropertySetCSSStyleDeclaration::setCssText(const String& text, ExceptionCode&)
+ExceptionOr<void> PropertySetCSSStyleDeclaration::setCssText(const String& text)
 {
     StyleAttributeMutationScope mutationScope(this);
     if (!willMutate())
-        return;
+        return { };
 
     bool changed = m_propertySet->parseDeclaration(text, cssParserContext(), contextStyleSheet());
 
     didMutate(changed ? PropertyChanged : NoChanges);
 
-    mutationScope.enqueueMutationRecord();    
+    mutationScope.enqueueMutationRecord();
+    return { };
 }
 
 RefPtr<CSSValue> PropertySetCSSStyleDeclaration::getPropertyCSSValue(const String& propertyName)
@@ -214,7 +215,7 @@ bool PropertySetCSSStyleDeclaration::isPropertyImplicit(const String& propertyNa
     return m_propertySet->isPropertyImplicit(propertyID);
 }
 
-void PropertySetCSSStyleDeclaration::setProperty(const String& propertyName, const String& value, const String& priority, ExceptionCode& ec)
+ExceptionOr<void> PropertySetCSSStyleDeclaration::setProperty(const String& propertyName, const String& value, const String& priority)
 {
     StyleAttributeMutationScope mutationScope(this);
     
@@ -222,16 +223,14 @@ void PropertySetCSSStyleDeclaration::setProperty(const String& propertyName, con
     if (isCustomPropertyName(propertyName))
         propertyID = CSSPropertyCustom;
     if (!propertyID)
-        return;
+        return { };
 
     if (!willMutate())
-        return;
+        return { };
 
     bool important = equalIgnoringASCIICase(priority, "important");
     if (!important && !priority.isEmpty())
-        return;
-
-    ec = 0;
+        return { };
 
     bool changed;
     if (propertyID == CSSPropertyCustom)
@@ -246,9 +245,11 @@ void PropertySetCSSStyleDeclaration::setProperty(const String& propertyName, con
         // see <http://bugs.webkit.org/show_bug.cgi?id=7296>.
         mutationScope.enqueueMutationRecord();
     }
+
+    return { };
 }
 
-String PropertySetCSSStyleDeclaration::removeProperty(const String& propertyName, ExceptionCode& ec)
+ExceptionOr<String> PropertySetCSSStyleDeclaration::removeProperty(const String& propertyName)
 {
     StyleAttributeMutationScope mutationScope(this);
     CSSPropertyID propertyID = cssPropertyID(propertyName);
@@ -260,7 +261,6 @@ String PropertySetCSSStyleDeclaration::removeProperty(const String& propertyName
     if (!willMutate())
         return String();
 
-    ec = 0;
     String result;
     bool changed = propertyID != CSSPropertyCustom ? m_propertySet->removeProperty(propertyID, &result) : m_propertySet->removeCustomProperty(propertyName, &result);
 
@@ -268,16 +268,12 @@ String PropertySetCSSStyleDeclaration::removeProperty(const String& propertyName
 
     if (changed)
         mutationScope.enqueueMutationRecord();
-    return result;
+    return WTFMove(result);
 }
 
 RefPtr<CSSValue> PropertySetCSSStyleDeclaration::getPropertyCSSValueInternal(CSSPropertyID propertyID)
 {
-    RefPtr<CSSValue> value = m_propertySet->getPropertyCSSValue(propertyID);
-    if (value)
-        return value;
-
-    return nullptr;
+    return m_propertySet->getPropertyCSSValue(propertyID);
 }
 
 String PropertySetCSSStyleDeclaration::getPropertyValueInternal(CSSPropertyID propertyID)
@@ -289,13 +285,12 @@ String PropertySetCSSStyleDeclaration::getPropertyValueInternal(CSSPropertyID pr
     return String();
 }
 
-bool PropertySetCSSStyleDeclaration::setPropertyInternal(CSSPropertyID propertyID, const String& value, bool important, ExceptionCode& ec)
+ExceptionOr<bool> PropertySetCSSStyleDeclaration::setPropertyInternal(CSSPropertyID propertyID, const String& value, bool important)
 { 
     StyleAttributeMutationScope mutationScope(this);
     if (!willMutate())
         return false;
 
-    ec = 0;
     bool changed = m_propertySet->setProperty(propertyID, value, important, cssParserContext(), contextStyleSheet());
 
     didMutate(changed ? PropertyChanged : NoChanges);
index 875e98d..5abd097 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef PropertySetCSSStyleDeclaration_h
-#define PropertySetCSSStyleDeclaration_h
+#pragma once
 
 #include "CSSParserMode.h"
 #include "CSSStyleDeclaration.h"
@@ -44,14 +43,23 @@ class StyledElement;
 class PropertySetCSSStyleDeclaration : public CSSStyleDeclaration {
 public:
     PropertySetCSSStyleDeclaration(MutableStyleProperties* propertySet) : m_propertySet(propertySet) { }
-    
+
     virtual void clearParentElement() { ASSERT_NOT_REACHED(); }
+
     StyleSheetContents* contextStyleSheet() const;
-    
+
+protected:
+    enum MutationType { NoChanges, PropertyChanged };
+
+    virtual CSSParserContext cssParserContext() const;
+
+    MutableStyleProperties* m_propertySet;
+    std::unique_ptr<HashMap<CSSValue*, RefPtr<CSSValue>>> m_cssomCSSValueClones;
+
+private:
     void ref() override;
     void deref() override;
 
-private:
     CSSRule* parentRule() const override { return nullptr; }
     unsigned length() const final;
     String item(unsigned index) const final;
@@ -60,30 +68,23 @@ private:
     String getPropertyPriority(const String& propertyName) final;
     String getPropertyShorthand(const String& propertyName) final;
     bool isPropertyImplicit(const String& propertyName) final;
-    void setProperty(const String& propertyName, const String& value, const String& priority, ExceptionCode&) final;
-    String removeProperty(const String& propertyName, ExceptionCode&) final;
+    ExceptionOr<void> setProperty(const String& propertyName, const String& value, const String& priority) final;
+    ExceptionOr<String> removeProperty(const String& propertyName) final;
     String cssText() const final;
-    void setCssText(const String&, ExceptionCode&) final;
+    ExceptionOr<void> setCssText(const String&) final;
     RefPtr<CSSValue> getPropertyCSSValueInternal(CSSPropertyID) final;
     String getPropertyValueInternal(CSSPropertyID) final;
-    bool setPropertyInternal(CSSPropertyID, const String& value, bool important, ExceptionCode&) final;
+    ExceptionOr<bool> setPropertyInternal(CSSPropertyID, const String& value, bool important) final;
     
     Ref<MutableStyleProperties> copyProperties() const final;
 
     CSSValue* cloneAndCacheForCSSOM(CSSValue*);
     
-protected:
-    enum MutationType { NoChanges, PropertyChanged };
     virtual bool willMutate() WARN_UNUSED_RETURN { return true; }
     virtual void didMutate(MutationType) { }
-    virtual CSSParserContext cssParserContext() const;
-
-    MutableStyleProperties* m_propertySet;
-    std::unique_ptr<HashMap<CSSValue*, RefPtr<CSSValue>>> m_cssomCSSValueClones;
 };
 
-class StyleRuleCSSStyleDeclaration final : public PropertySetCSSStyleDeclaration
-{
+class StyleRuleCSSStyleDeclaration final : public PropertySetCSSStyleDeclaration {
 public:
     static Ref<StyleRuleCSSStyleDeclaration> create(MutableStyleProperties& propertySet, CSSRule& parentRule)
     {
@@ -91,7 +92,7 @@ public:
     }
     virtual ~StyleRuleCSSStyleDeclaration();
 
-    void clearParentRule() { m_parentRule = 0; }
+    void clearParentRule() { m_parentRule = nullptr; }
     
     void ref() final;
     void deref() final;
@@ -113,19 +114,18 @@ private:
     CSSRule* m_parentRule;
 };
 
-class InlineCSSStyleDeclaration final : public PropertySetCSSStyleDeclaration
-{
+class InlineCSSStyleDeclaration final : public PropertySetCSSStyleDeclaration {
 public:
     InlineCSSStyleDeclaration(MutableStyleProperties* propertySet, StyledElement* parentElement)
         : PropertySetCSSStyleDeclaration(propertySet)
         , m_parentElement(parentElement) 
     {
     }
-    
+
 private:
     CSSStyleSheet* parentStyleSheet() const final;
     StyledElement* parentElement() const final { return m_parentElement; }
-    void clearParentElement() final { m_parentElement = 0; }
+    void clearParentElement() final { m_parentElement = nullptr; }
 
     void didMutate(MutationType) final;
     CSSParserContext cssParserContext() const final;
@@ -134,5 +134,3 @@ private:
 };
 
 } // namespace WebCore
-
-#endif
index 1ef6596..478630b 100644 (file)
@@ -187,7 +187,7 @@ inline Length StyleBuilderConverter::convertLength(StyleResolver& styleResolver,
     }
 
     if (primitiveValue.isPercentage())
-        return Length(primitiveValue.getDoubleValue(), Percent);
+        return Length(primitiveValue.doubleValue(), Percent);
 
     if (primitiveValue.isCalculatedPercentageWithLength())
         return Length(primitiveValue.cssCalcValue()->createCalculationValue(conversionData));
@@ -198,7 +198,7 @@ inline Length StyleBuilderConverter::convertLength(StyleResolver& styleResolver,
 
 inline Length StyleBuilderConverter::convertLengthOrAuto(StyleResolver& styleResolver, CSSValue& value)
 {
-    if (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueAuto)
+    if (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueAuto)
         return Length(Auto);
     return convertLength(styleResolver, value);
 }
@@ -206,7 +206,7 @@ inline Length StyleBuilderConverter::convertLengthOrAuto(StyleResolver& styleRes
 inline Length StyleBuilderConverter::convertLengthSizing(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueInvalid:
         return convertLength(styleResolver, value);
     case CSSValueIntrinsic:
@@ -231,7 +231,7 @@ inline Length StyleBuilderConverter::convertLengthSizing(StyleResolver& styleRes
 
 inline Length StyleBuilderConverter::convertLengthMaxSizing(StyleResolver& styleResolver, CSSValue& value)
 {
-    if (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone)
+    if (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone)
         return Length(Undefined);
     return convertLengthSizing(styleResolver, value);
 }
@@ -246,7 +246,7 @@ template <typename T>
 inline T StyleBuilderConverter::convertLineWidth(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueThin:
         return 1;
     case CSSValueMedium:
@@ -276,7 +276,7 @@ inline T StyleBuilderConverter::convertLineWidth(StyleResolver& styleResolver, C
 inline float StyleBuilderConverter::convertSpacing(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueNormal)
+    if (primitiveValue.valueID() == CSSValueNormal)
         return 0.f;
 
     CSSToLengthConversionData conversionData = styleResolver.useSVGZoomRulesForLength() ?
@@ -288,7 +288,7 @@ inline float StyleBuilderConverter::convertSpacing(StyleResolver& styleResolver,
 inline Length StyleBuilderConverter::convertToRadiusLength(CSSToLengthConversionData& conversionData, CSSPrimitiveValue& value)
 {
     if (value.isPercentage())
-        return Length(value.getDoubleValue(), Percent);
+        return Length(value.doubleValue(), Percent);
     if (value.isCalculatedPercentageWithLength())
         return Length(value.cssCalcValue()->createCalculationValue(conversionData));
     return value.computeLength<Length>(conversionData);
@@ -297,7 +297,7 @@ inline Length StyleBuilderConverter::convertToRadiusLength(CSSToLengthConversion
 inline LengthSize StyleBuilderConverter::convertRadius(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    Pair* pair = primitiveValue.getPairValue();
+    Pair* pair = primitiveValue.pairValue();
     if (!pair || !pair->first() || !pair->second())
         return LengthSize(Length(0, Fixed), Length(0, Fixed));
 
@@ -333,11 +333,11 @@ inline Length StyleBuilderConverter::convertPositionComponent(StyleResolver& sty
     bool relativeToTrailingEdge = false;
     
     if (value.isPair()) {
-        auto& first = *value.getPairValue()->first();
-        if (first.getValueID() == CSSValueRight || first.getValueID() == CSSValueBottom)
+        auto& first = *value.pairValue()->first();
+        if (first.valueID() == CSSValueRight || first.valueID() == CSSValueBottom)
             relativeToTrailingEdge = true;
 
-        lengthValue = value.getPairValue()->second();
+        lengthValue = value.pairValue()->second();
     }
 
     length = convertLength(styleResolver, *lengthValue);
@@ -351,7 +351,7 @@ inline Length StyleBuilderConverter::convertPositionComponent(StyleResolver& sty
 inline LengthPoint StyleBuilderConverter::convertObjectPosition(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    Pair* pair = primitiveValue.getPairValue();
+    Pair* pair = primitiveValue.pairValue();
     if (!pair || !pair->first() || !pair->second())
         return RenderStyle::initialObjectPosition();
 
@@ -374,13 +374,13 @@ inline TextDecoration StyleBuilderConverter::convertTextDecoration(StyleResolver
 template <typename T>
 inline T StyleBuilderConverter::convertNumber(StyleResolver&, CSSValue& value)
 {
-    return downcast<CSSPrimitiveValue>(value).getValue<T>(CSSPrimitiveValue::CSS_NUMBER);
+    return downcast<CSSPrimitiveValue>(value).value<T>(CSSPrimitiveValue::CSS_NUMBER);
 }
 
 template <typename T>
 inline T StyleBuilderConverter::convertNumberOrAuto(StyleResolver& styleResolver, CSSValue& value)
 {
-    if (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueAuto)
+    if (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueAuto)
         return -1;
     return convertNumber<T>(styleResolver, value);
 }
@@ -388,9 +388,9 @@ inline T StyleBuilderConverter::convertNumberOrAuto(StyleResolver& styleResolver
 inline short StyleBuilderConverter::convertWebkitHyphenateLimitLines(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueNoLimit)
+    if (primitiveValue.valueID() == CSSValueNoLimit)
         return -1;
-    return primitiveValue.getValue<short>(CSSPrimitiveValue::CSS_NUMBER);
+    return primitiveValue.value<short>(CSSPrimitiveValue::CSS_NUMBER);
 }
 
 template <CSSPropertyID property>
@@ -425,19 +425,19 @@ inline TransformOperations StyleBuilderConverter::convertTransform(StyleResolver
 
 inline String StyleBuilderConverter::convertString(StyleResolver&, CSSValue& value)
 {
-    return downcast<CSSPrimitiveValue>(value).getStringValue();
+    return downcast<CSSPrimitiveValue>(value).stringValue();
 }
 
 inline String StyleBuilderConverter::convertStringOrAuto(StyleResolver& styleResolver, CSSValue& value)
 {
-    if (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueAuto)
+    if (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueAuto)
         return nullAtom;
     return convertString(styleResolver, value);
 }
 
 inline String StyleBuilderConverter::convertStringOrNone(StyleResolver& styleResolver, CSSValue& value)
 {
-    if (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone)
+    if (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone)
         return nullAtom;
     return convertString(styleResolver, value);
 }
@@ -446,7 +446,7 @@ inline TextEmphasisPosition StyleBuilderConverter::valueToEmphasisPosition(CSSPr
 {
     ASSERT(primitiveValue.isValueID());
 
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueOver:
         return TextEmphasisPositionOver;
     case CSSValueUnder:
@@ -479,7 +479,7 @@ inline ETextAlign StyleBuilderConverter::convertTextAlign(StyleResolver& styleRe
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
     ASSERT(primitiveValue.isValueID());
 
-    if (primitiveValue.getValueID() != CSSValueWebkitMatchParent)
+    if (primitiveValue.valueID() != CSSValueWebkitMatchParent)
         return primitiveValue;
 
     auto* parentStyle = styleResolver.parentStyle();
@@ -495,12 +495,12 @@ inline RefPtr<ClipPathOperation> StyleBuilderConverter::convertClipPath(StyleRes
     if (is<CSSPrimitiveValue>(value)) {
         auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
         if (primitiveValue.primitiveType() == CSSPrimitiveValue::CSS_URI) {
-            String cssURLValue = primitiveValue.getStringValue();
+            String cssURLValue = primitiveValue.stringValue();
             URL url = styleResolver.document().completeURL(cssURLValue);
             // FIXME: It doesn't work with external SVG references (see https://bugs.webkit.org/show_bug.cgi?id=126133)
             return ReferenceClipPathOperation::create(cssURLValue, url.fragmentIdentifier());
         }
-        ASSERT(primitiveValue.getValueID() == CSSValueNone);
+        ASSERT(primitiveValue.valueID() == CSSValueNone);
         return nullptr;
     }
 
@@ -511,15 +511,15 @@ inline RefPtr<ClipPathOperation> StyleBuilderConverter::convertClipPath(StyleRes
         auto& primitiveValue = downcast<CSSPrimitiveValue>(currentValue.get());
         if (primitiveValue.isShape()) {
             ASSERT(!operation);
-            operation = ShapeClipPathOperation::create(basicShapeForValue(styleResolver.state().cssToLengthConversionData(), *primitiveValue.getShapeValue()));
+            operation = ShapeClipPathOperation::create(basicShapeForValue(styleResolver.state().cssToLengthConversionData(), *primitiveValue.shapeValue()));
         } else {
-            ASSERT(primitiveValue.getValueID() == CSSValueContentBox
-                   || primitiveValue.getValueID() == CSSValueBorderBox
-                   || primitiveValue.getValueID() == CSSValuePaddingBox
-                   || primitiveValue.getValueID() == CSSValueMarginBox
-                   || primitiveValue.getValueID() == CSSValueFill
-                   || primitiveValue.getValueID() == CSSValueStroke
-                   || primitiveValue.getValueID() == CSSValueViewBox);
+            ASSERT(primitiveValue.valueID() == CSSValueContentBox
+                || primitiveValue.valueID() == CSSValueBorderBox
+                || primitiveValue.valueID() == CSSValuePaddingBox
+                || primitiveValue.valueID() == CSSValueMarginBox
+                || primitiveValue.valueID() == CSSValueFill
+                || primitiveValue.valueID() == CSSValueStroke
+                || primitiveValue.valueID() == CSSValueViewBox);
             ASSERT(referenceBox == BoxMissing);
             referenceBox = primitiveValue;
         }
@@ -539,7 +539,7 @@ inline EResize StyleBuilderConverter::convertResize(StyleResolver& styleResolver
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
 
     EResize resize = RESIZE_NONE;
-    if (primitiveValue.getValueID() == CSSValueAuto) {
+    if (primitiveValue.valueID() == CSSValueAuto) {
         if (Settings* settings = styleResolver.document().settings())
             resize = settings->textAreasAreResizable() ? RESIZE_BOTH : RESIZE_NONE;
     } else
@@ -551,18 +551,18 @@ inline EResize StyleBuilderConverter::convertResize(StyleResolver& styleResolver
 inline int StyleBuilderConverter::convertMarqueeRepetition(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueInfinite)
+    if (primitiveValue.valueID() == CSSValueInfinite)
         return -1; // -1 means repeat forever.
 
     ASSERT(primitiveValue.isNumber());
-    return primitiveValue.getIntValue();
+    return primitiveValue.intValue();
 }
 
 inline int StyleBuilderConverter::convertMarqueeSpeed(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
     int speed = 85;
-    if (CSSValueID ident = primitiveValue.getValueID()) {
+    if (CSSValueID ident = primitiveValue.valueID()) {
         switch (ident) {
         case CSSValueSlow:
             speed = 500; // 500 msec.
@@ -582,7 +582,7 @@ inline int StyleBuilderConverter::convertMarqueeSpeed(StyleResolver&, CSSValue&
     else {
         // For scrollamount support.
         ASSERT(primitiveValue.isNumber());
-        speed = primitiveValue.getIntValue();
+        speed = primitiveValue.intValue();
     }
     return speed;
 }
@@ -590,7 +590,7 @@ inline int StyleBuilderConverter::convertMarqueeSpeed(StyleResolver&, CSSValue&
 inline PassRefPtr<QuotesData> StyleBuilderConverter::convertQuotes(StyleResolver&, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);
         return QuotesData::create(Vector<std::pair<String, String>>());
     }
 
@@ -603,8 +603,8 @@ inline PassRefPtr<QuotesData> StyleBuilderConverter::convertQuotes(StyleResolver
         CSSValue* second = list.item(i + 1);
         if (!second)
             break;
-        String startQuote = downcast<CSSPrimitiveValue>(*first).getStringValue();
-        String endQuote = downcast<CSSPrimitiveValue>(*second).getStringValue();
+        String startQuote = downcast<CSSPrimitiveValue>(*first).stringValue();
+        String endQuote = downcast<CSSPrimitiveValue>(*second).stringValue();
         quotes.append(std::make_pair(startQuote, endQuote));
     }
     return QuotesData::create(quotes);
@@ -627,7 +627,7 @@ inline TextUnderlinePosition StyleBuilderConverter::convertTextUnderlinePosition
 inline RefPtr<StyleReflection> StyleBuilderConverter::convertReflection(StyleResolver& styleResolver, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);
         return nullptr;
     }
 
@@ -649,15 +649,15 @@ inline IntSize StyleBuilderConverter::convertInitialLetter(StyleResolver&, CSSVa
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
 
-    if (primitiveValue.getValueID() == CSSValueNormal)
+    if (primitiveValue.valueID() == CSSValueNormal)
         return IntSize();
 
-    Pair* pair = primitiveValue.getPairValue();
+    Pair* pair = primitiveValue.pairValue();
     ASSERT(pair);
     ASSERT(pair->first());
     ASSERT(pair->second());
 
-    return IntSize(pair->first()->getIntValue(), pair->second()->getIntValue());
+    return IntSize(pair->first()->intValue(), pair->second()->intValue());
 }
 
 inline float StyleBuilderConverter::convertTextStrokeWidth(StyleResolver& styleResolver, CSSValue& value)
@@ -665,14 +665,14 @@ inline float StyleBuilderConverter::convertTextStrokeWidth(StyleResolver& styleR
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
 
     float width = 0;
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueThin:
     case CSSValueMedium:
     case CSSValueThick: {
         double result = 1.0 / 48;
-        if (primitiveValue.getValueID() == CSSValueMedium)
+        if (primitiveValue.valueID() == CSSValueMedium)
             result *= 3;
-        else if (primitiveValue.getValueID() == CSSValueThick)
+        else if (primitiveValue.valueID() == CSSValueThick)
             result *= 5;
         Ref<CSSPrimitiveValue> emsValue(CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS));
         width = convertComputedLength<float>(styleResolver, emsValue);
@@ -693,7 +693,7 @@ inline float StyleBuilderConverter::convertTextStrokeWidth(StyleResolver& styleR
 inline LineBoxContain StyleBuilderConverter::convertLineBoxContain(StyleResolver&, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);
         return LineBoxContainNone;
     }
 
@@ -704,7 +704,7 @@ inline TextDecorationSkip StyleBuilderConverter::valueToDecorationSkip(const CSS
 {
     ASSERT(primitiveValue.isValueID());
 
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueAuto:
         return TextDecorationSkipAuto;
     case CSSValueNone:
@@ -741,7 +741,7 @@ static inline bool isImageShape(const CSSValue& value)
 inline PassRefPtr<ShapeValue> StyleBuilderConverter::convertShapeValue(StyleResolver& styleResolver, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);
         return nullptr;
     }
 
@@ -753,11 +753,11 @@ inline PassRefPtr<ShapeValue> StyleBuilderConverter::convertShapeValue(StyleReso
     for (auto& currentValue : downcast<CSSValueList>(value)) {
         CSSPrimitiveValue& primitiveValue = downcast<CSSPrimitiveValue>(currentValue.get());
         if (primitiveValue.isShape())
-            shape = basicShapeForValue(styleResolver.state().cssToLengthConversionData(), *primitiveValue.getShapeValue());
-        else if (primitiveValue.getValueID() == CSSValueContentBox
-            || primitiveValue.getValueID() == CSSValueBorderBox
-            || primitiveValue.getValueID() == CSSValuePaddingBox
-            || primitiveValue.getValueID() == CSSValueMarginBox)
+            shape = basicShapeForValue(styleResolver.state().cssToLengthConversionData(), *primitiveValue.shapeValue());
+        else if (primitiveValue.valueID() == CSSValueContentBox
+            || primitiveValue.valueID() == CSSValueBorderBox
+            || primitiveValue.valueID() == CSSValuePaddingBox
+            || primitiveValue.valueID() == CSSValueMarginBox)
             referenceBox = primitiveValue;
         else {
             ASSERT_NOT_REACHED();
@@ -787,14 +787,14 @@ inline std::unique_ptr<ScrollSnapPoints> StyleBuilderConverter::convertScrollSna
     auto points = std::make_unique<ScrollSnapPoints>();
 
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueElements);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueElements);
         points->usesElements = true;
         return points;
     }
 
     for (auto& currentValue : downcast<CSSValueList>(value)) {
         auto& itemValue = downcast<CSSPrimitiveValue>(currentValue.get());
-        if (auto* lengthRepeat = itemValue.getLengthRepeatValue()) {
+        if (auto* lengthRepeat = itemValue.lengthRepeatValue()) {
             if (auto* interval = lengthRepeat->interval()) {
                 points->repeatOffset = parseSnapCoordinate(styleResolver, *interval);
                 points->hasRepeat = true;
@@ -829,15 +829,15 @@ inline Vector<LengthSize> StyleBuilderConverter::convertScrollSnapCoordinates(St
 #if ENABLE(CSS_GRID_LAYOUT)
 inline GridLength StyleBuilderConverter::createGridTrackBreadth(CSSPrimitiveValue& primitiveValue, StyleResolver& styleResolver)
 {
-    if (primitiveValue.getValueID() == CSSValueWebkitMinContent)
+    if (primitiveValue.valueID() == CSSValueWebkitMinContent)
         return Length(MinContent);
 
-    if (primitiveValue.getValueID() == CSSValueWebkitMaxContent)
+    if (primitiveValue.valueID() == CSSValueWebkitMaxContent)
         return Length(MaxContent);
 
     // Fractional unit.
     if (primitiveValue.isFlex())
-        return GridLength(primitiveValue.getDoubleValue());
+        return GridLength(primitiveValue.doubleValue());
 
     return primitiveValue.convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | AutoConversion>(styleResolver.state().cssToLengthConversionData());
 }
@@ -864,7 +864,7 @@ static void createGridLineNamesList(const CSSValue& value, unsigned currentNamed
     ASSERT(value.isGridLineNamesValue());
 
     for (auto& namedGridLineValue : downcast<CSSGridLineNamesValue>(value)) {
-        String namedGridLine = downcast<CSSPrimitiveValue>(namedGridLineValue.get()).getStringValue();
+        String namedGridLine = downcast<CSSPrimitiveValue>(namedGridLineValue.get()).stringValue();
         auto result = namedGridLines.add(namedGridLine, Vector<unsigned>());
         result.iterator->value.append(currentNamedGridLine);
         auto orderedResult = orderedNamedGridLines.add(currentNamedGridLine, Vector<String>());
@@ -891,7 +891,7 @@ inline bool StyleBuilderConverter::createGridTrackList(CSSValue& value, TracksDa
 {
     // Handle 'none'.
     if (is<CSSPrimitiveValue>(value))
-        return downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone;
+        return downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone;
 
     if (!is<CSSValueList>(value))
         return false;
@@ -939,11 +939,11 @@ inline bool StyleBuilderConverter::createGridPosition(CSSValue& value, GridPosit
         auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
         // We translate <ident> to <string> during parsing as it makes handling it simpler.
         if (primitiveValue.isString()) {
-            position.setNamedGridArea(primitiveValue.getStringValue());
+            position.setNamedGridArea(primitiveValue.stringValue());
             return true;
         }
 
-        ASSERT(primitiveValue.getValueID() == CSSValueAuto);
+        ASSERT(primitiveValue.valueID() == CSSValueAuto);
         return true;
     }
 
@@ -953,7 +953,7 @@ inline bool StyleBuilderConverter::createGridPosition(CSSValue& value, GridPosit
     auto it = values.begin();
     CSSPrimitiveValue* currentValue = &downcast<CSSPrimitiveValue>(it->get());
     bool isSpanPosition = false;
-    if (currentValue->getValueID() == CSSValueSpan) {
+    if (currentValue->valueID() == CSSValueSpan) {
         isSpanPosition = true;
         ++it;
         currentValue = it != values.end() ? &downcast<CSSPrimitiveValue>(it->get()) : nullptr;
@@ -961,14 +961,14 @@ inline bool StyleBuilderConverter::createGridPosition(CSSValue& value, GridPosit
 
     int gridLineNumber = 0;
     if (currentValue && currentValue->isNumber()) {
-        gridLineNumber = currentValue->getIntValue();
+        gridLineNumber = currentValue->intValue();
         ++it;
         currentValue = it != values.end() ? &downcast<CSSPrimitiveValue>(it->get()) : nullptr;
     }
 
     String gridLineName;
     if (currentValue && currentValue->isString()) {
-        gridLineName = currentValue->getStringValue();
+        gridLineName = currentValue->stringValue();
         ++it;
     }
 
@@ -1035,15 +1035,15 @@ inline GridAutoFlow StyleBuilderConverter::convertGridAutoFlow(StyleResolver&, C
     auto* second = downcast<CSSPrimitiveValue>(list.item(1));
 
     GridAutoFlow autoFlow = RenderStyle::initialGridAutoFlow();
-    switch (first.getValueID()) {
+    switch (first.valueID()) {
     case CSSValueRow:
-        if (second && second->getValueID() == CSSValueDense)
+        if (second && second->valueID() == CSSValueDense)
             autoFlow =  AutoFlowRowDense;
         else
             autoFlow = AutoFlowRow;
         break;
     case CSSValueColumn:
-        if (second && second->getValueID() == CSSValueDense)
+        if (second && second->valueID() == CSSValueDense)
             autoFlow = AutoFlowColumnDense;
         else
             autoFlow = AutoFlowColumn;
@@ -1070,14 +1070,14 @@ inline Optional<Length> StyleBuilderConverter::convertWordSpacing(StyleResolver&
 {
     Optional<Length> wordSpacing;
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueNormal)
+    if (primitiveValue.valueID() == CSSValueNormal)
         wordSpacing = RenderStyle::initialWordSpacing();
     else if (primitiveValue.isLength())
         wordSpacing = primitiveValue.computeLength<Length>(csstoLengthConversionDataWithTextZoomFactor(styleResolver));
     else if (primitiveValue.isPercentage())
-        wordSpacing = Length(clampTo<float>(primitiveValue.getDoubleValue(), minValueForCssLength, maxValueForCssLength), Percent);
+        wordSpacing = Length(clampTo<float>(primitiveValue.doubleValue(), minValueForCssLength, maxValueForCssLength), Percent);
     else if (primitiveValue.isNumber())
-        wordSpacing = Length(primitiveValue.getDoubleValue(), Fixed);
+        wordSpacing = Length(primitiveValue.doubleValue(), Fixed);
 
     return wordSpacing;
 }
@@ -1085,14 +1085,14 @@ inline Optional<Length> StyleBuilderConverter::convertWordSpacing(StyleResolver&
 inline Optional<float> StyleBuilderConverter::convertPerspective(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueNone)
+    if (primitiveValue.valueID() == CSSValueNone)
         return 0.f;
 
     float perspective = -1;
     if (primitiveValue.isLength())
         perspective = primitiveValue.computeLength<float>(styleResolver.state().cssToLengthConversionData());
     else if (primitiveValue.isNumber())
-        perspective = primitiveValue.getDoubleValue() * styleResolver.state().cssToLengthConversionData().zoom();
+        perspective = primitiveValue.doubleValue() * styleResolver.state().cssToLengthConversionData().zoom();
     else
         ASSERT_NOT_REACHED();
 
@@ -1103,7 +1103,7 @@ inline Optional<Length> StyleBuilderConverter::convertMarqueeIncrement(StyleReso
 {
     Optional<Length> marqueeLength;
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueSmall:
         marqueeLength = Length(1, Fixed); // 1px.
         break;
@@ -1136,7 +1136,7 @@ inline Optional<FilterOperations> StyleBuilderConverter::convertFilterOperations
 inline FontFeatureSettings StyleBuilderConverter::convertFontFeatureSettings(StyleResolver&, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal);
         return { };
     }
 
@@ -1152,7 +1152,7 @@ inline FontFeatureSettings StyleBuilderConverter::convertFontFeatureSettings(Sty
 inline FontVariationSettings StyleBuilderConverter::convertFontVariationSettings(StyleResolver&, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal);
         return { };
     }
 
@@ -1168,7 +1168,7 @@ inline FontVariationSettings StyleBuilderConverter::convertFontVariationSettings
 #if PLATFORM(IOS)
 inline bool StyleBuilderConverter::convertTouchCallout(StyleResolver&, CSSValue& value)
 {
-    return !equalLettersIgnoringASCIICase(downcast<CSSPrimitiveValue>(value).getStringValue(), "none");
+    return !equalLettersIgnoringASCIICase(downcast<CSSPrimitiveValue>(value).stringValue(), "none");
 }
 #endif
 
@@ -1182,7 +1182,7 @@ inline Color StyleBuilderConverter::convertTapHighlightColor(StyleResolver& styl
 #if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
 inline bool StyleBuilderConverter::convertOverflowScrolling(StyleResolver&, CSSValue& value)
 {
-    return downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueTouch;
+    return downcast<CSSPrimitiveValue>(value).valueID() == CSSValueTouch;
 }
 #endif
 
@@ -1206,7 +1206,7 @@ inline Vector<SVGLength> StyleBuilderConverter::convertSVGLengthVector(StyleReso
 inline Vector<SVGLength> StyleBuilderConverter::convertStrokeDashArray(StyleResolver& styleResolver, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);
         return SVGRenderStyle::initialStrokeDashArray();
     }
 
@@ -1216,12 +1216,12 @@ inline Vector<SVGLength> StyleBuilderConverter::convertStrokeDashArray(StyleReso
 inline PaintOrder StyleBuilderConverter::convertPaintOrder(StyleResolver&, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal);
         return PaintOrderNormal;
     }
 
     auto& orderTypeList = downcast<CSSValueList>(value);
-    switch (downcast<CSSPrimitiveValue>(*orderTypeList.itemWithoutBoundsCheck(0)).getValueID()) {
+    switch (downcast<CSSPrimitiveValue>(*orderTypeList.itemWithoutBoundsCheck(0)).valueID()) {
     case CSSValueFill:
         return orderTypeList.length() > 1 ? PaintOrderFillMarkers : PaintOrderFill;
     case CSSValueStroke:
@@ -1237,7 +1237,7 @@ inline PaintOrder StyleBuilderConverter::convertPaintOrder(StyleResolver&, CSSVa
 inline float StyleBuilderConverter::convertOpacity(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    float opacity = primitiveValue.getFloatValue();
+    float opacity = primitiveValue.floatValue();
     if (primitiveValue.isPercentage())
         opacity /= 100.0f;
     return opacity;
@@ -1248,7 +1248,7 @@ inline String StyleBuilderConverter::convertSVGURIReference(StyleResolver& style
     String s;
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
     if (primitiveValue.isURI())
-        s = primitiveValue.getStringValue();
+        s = primitiveValue.stringValue();
 
     return SVGURIReference::fragmentIdentifierFromIRIString(s, styleResolver.document());
 }
@@ -1263,8 +1263,8 @@ inline StyleSelfAlignmentData StyleBuilderConverter::convertSelfOrDefaultAlignme
 {
     StyleSelfAlignmentData alignmentData = RenderStyle::initialSelfAlignment();
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (Pair* pairValue = primitiveValue.getPairValue()) {
-        if (pairValue->first()->getValueID() == CSSValueLegacy) {
+    if (Pair* pairValue = primitiveValue.pairValue()) {
+        if (pairValue->first()->valueID() == CSSValueLegacy) {
             alignmentData.setPositionType(LegacyPosition);
             alignmentData.setPosition(*pairValue->second());
         } else {
@@ -1282,17 +1282,17 @@ inline StyleContentAlignmentData StyleBuilderConverter::convertContentAlignmentD
 #if ENABLE(CSS_GRID_LAYOUT)
     if (RuntimeEnabledFeatures::sharedFeatures().isCSSGridLayoutEnabled()) {
         auto& contentValue = downcast<CSSContentDistributionValue>(value);
-        if (contentValue.distribution()->getValueID() != CSSValueInvalid)
+        if (contentValue.distribution()->valueID() != CSSValueInvalid)
             alignmentData.setDistribution(contentValue.distribution().get());
-        if (contentValue.position()->getValueID() != CSSValueInvalid)
+        if (contentValue.position()->valueID() != CSSValueInvalid)
             alignmentData.setPosition(contentValue.position().get());
-        if (contentValue.overflow()->getValueID() != CSSValueInvalid)
+        if (contentValue.overflow()->valueID() != CSSValueInvalid)
             alignmentData.setOverflow(contentValue.overflow().get());
         return alignmentData;
     }
 #endif
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueStretch:
     case CSSValueSpaceBetween:
     case CSSValueSpaceAround:
@@ -1311,7 +1311,7 @@ inline StyleContentAlignmentData StyleBuilderConverter::convertContentAlignmentD
 
 inline EGlyphOrientation StyleBuilderConverter::convertGlyphOrientation(StyleResolver&, CSSValue& value)
 {
-    float angle = fabsf(fmodf(downcast<CSSPrimitiveValue>(value).getFloatValue(), 360.0f));
+    float angle = fabsf(fmodf(downcast<CSSPrimitiveValue>(value).floatValue(), 360.0f));
     if (angle <= 45.0f || angle > 315.0f)
         return GO_0DEG;
     if (angle > 45.0f && angle <= 135.0f)
@@ -1323,7 +1323,7 @@ inline EGlyphOrientation StyleBuilderConverter::convertGlyphOrientation(StyleRes
 
 inline EGlyphOrientation StyleBuilderConverter::convertGlyphOrientationOrAuto(StyleResolver& styleResolver, CSSValue& value)
 {
-    if (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueAuto)
+    if (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueAuto)
         return GO_AUTO;
     return convertGlyphOrientation(styleResolver, value);
 }
@@ -1331,7 +1331,7 @@ inline EGlyphOrientation StyleBuilderConverter::convertGlyphOrientationOrAuto(St
 inline Optional<Length> StyleBuilderConverter::convertLineHeight(StyleResolver& styleResolver, CSSValue& value, float multiplier)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueNormal)
+    if (primitiveValue.valueID() == CSSValueNormal)
         return RenderStyle::initialLineHeight();
 
     if (primitiveValue.isLength()) {
@@ -1342,11 +1342,11 @@ inline Optional<Length> StyleBuilderConverter::convertLineHeight(StyleResolver&
     }
     if (primitiveValue.isPercentage()) {
         // FIXME: percentage should not be restricted to an integer here.
-        return Length((styleResolver.style()->computedFontSize() * primitiveValue.getIntValue()) / 100, Fixed);
+        return Length((styleResolver.style()->computedFontSize() * primitiveValue.intValue()) / 100, Fixed);
     }
     if (primitiveValue.isNumber()) {
         // FIXME: number and percentage values should produce the same type of Length (ie. Fixed or Percent).
-        return Length(primitiveValue.getDoubleValue() * multiplier * 100.0, Percent);
+        return Length(primitiveValue.doubleValue() * multiplier * 100.0, Percent);
     }
     return Nullopt;
 }
@@ -1354,14 +1354,14 @@ inline Optional<Length> StyleBuilderConverter::convertLineHeight(StyleResolver&
 FontSynthesis StyleBuilderConverter::convertFontSynthesis(StyleResolver&, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);
         return FontSynthesisNone;
     }
 
     FontSynthesis result = FontSynthesisNone;
     ASSERT(is<CSSValueList>(value));
     for (CSSValue& v : downcast<CSSValueList>(value)) {
-        switch (downcast<CSSPrimitiveValue>(v).getValueID()) {
+        switch (downcast<CSSPrimitiveValue>(v).valueID()) {
         case CSSValueWeight:
             result |= FontSynthesisWeight;
             break;
@@ -1380,9 +1380,9 @@ FontSynthesis StyleBuilderConverter::convertFontSynthesis(StyleResolver&, CSSVal
 inline BreakBetween StyleBuilderConverter::convertPageBreakBetween(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueAlways)
+    if (primitiveValue.valueID() == CSSValueAlways)
         return PageBreakBetween;
-    if (primitiveValue.getValueID() == CSSValueAvoid)
+    if (primitiveValue.valueID() == CSSValueAvoid)
         return AvoidPageBreakBetween;
     return primitiveValue;
 }
@@ -1390,7 +1390,7 @@ inline BreakBetween StyleBuilderConverter::convertPageBreakBetween(StyleResolver
 inline BreakInside StyleBuilderConverter::convertPageBreakInside(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueAvoid)
+    if (primitiveValue.valueID() == CSSValueAvoid)
         return AvoidPageBreakInside;
     return primitiveValue;
 }
@@ -1398,9 +1398,9 @@ inline BreakInside StyleBuilderConverter::convertPageBreakInside(StyleResolver&,
 inline BreakBetween StyleBuilderConverter::convertColumnBreakBetween(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueAlways)
+    if (primitiveValue.valueID() == CSSValueAlways)
         return ColumnBreakBetween;
-    if (primitiveValue.getValueID() == CSSValueAvoid)
+    if (primitiveValue.valueID() == CSSValueAvoid)
         return AvoidColumnBreakBetween;
     return primitiveValue;
 }
@@ -1408,7 +1408,7 @@ inline BreakBetween StyleBuilderConverter::convertColumnBreakBetween(StyleResolv
 inline BreakInside StyleBuilderConverter::convertColumnBreakInside(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueAvoid)
+    if (primitiveValue.valueID() == CSSValueAvoid)
         return AvoidColumnBreakInside;
     return primitiveValue;
 }
@@ -1417,9 +1417,9 @@ inline BreakInside StyleBuilderConverter::convertColumnBreakInside(StyleResolver
 inline BreakBetween StyleBuilderConverter::convertRegionBreakBetween(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueAlways)
+    if (primitiveValue.valueID() == CSSValueAlways)
         return RegionBreakBetween;
-    if (primitiveValue.getValueID() == CSSValueAvoid)
+    if (primitiveValue.valueID() == CSSValueAvoid)
         return AvoidRegionBreakBetween;
     return primitiveValue;
 }
@@ -1427,7 +1427,7 @@ inline BreakBetween StyleBuilderConverter::convertRegionBreakBetween(StyleResolv
 inline BreakInside StyleBuilderConverter::convertRegionBreakInside(StyleResolver&, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueAvoid)
+    if (primitiveValue.valueID() == CSSValueAvoid)
         return AvoidRegionBreakInside;
     return primitiveValue;
 }
index caabf32..609aad5 100644 (file)
@@ -24,8 +24,7 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef StyleBuilderCustom_h
-#define StyleBuilderCustom_h
+#pragma once
 
 #include "CSSAspectRatioValue.h"
 #include "CSSCursorImageValue.h"
@@ -194,23 +193,23 @@ inline void StyleBuilderCustom::applyValueZoom(StyleResolver& styleResolver, CSS
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
 
-    if (primitiveValue.getValueID() == CSSValueNormal) {
+    if (primitiveValue.valueID() == CSSValueNormal) {
         resetEffectiveZoom(styleResolver);
         styleResolver.setZoom(RenderStyle::initialZoom());
-    } else if (primitiveValue.getValueID() == CSSValueReset) {
+    } else if (primitiveValue.valueID() == CSSValueReset) {
         styleResolver.setEffectiveZoom(RenderStyle::initialZoom());
         styleResolver.setZoom(RenderStyle::initialZoom());
-    } else if (primitiveValue.getValueID() == CSSValueDocument) {
+    } else if (primitiveValue.valueID() == CSSValueDocument) {
         float docZoom = styleResolver.rootElementStyle() ? styleResolver.rootElementStyle()->zoom() : RenderStyle::initialZoom();
         styleResolver.setEffectiveZoom(docZoom);
         styleResolver.setZoom(docZoom);
     } else if (primitiveValue.isPercentage()) {
         resetEffectiveZoom(styleResolver);
-        if (float percent = primitiveValue.getFloatValue())
+        if (float percent = primitiveValue.floatValue())
             styleResolver.setZoom(percent / 100.0f);
     } else if (primitiveValue.isNumber()) {
         resetEffectiveZoom(styleResolver);
-        if (float number = primitiveValue.getFloatValue())
+        if (float number = primitiveValue.floatValue())
             styleResolver.setZoom(number);
     }
 }
@@ -246,7 +245,7 @@ bool StyleBuilderCustom::getPageSizeFromName(CSSPrimitiveValue* pageSizeName, CS
     if (!pageSizeName)
         return false;
 
-    switch (pageSizeName->getValueID()) {
+    switch (pageSizeName->valueID()) {
     case CSSValueA5:
         width = a5Width;
         height = a5Height;
@@ -284,7 +283,7 @@ bool StyleBuilderCustom::getPageSizeFromName(CSSPrimitiveValue* pageSizeName, CS
     }
 
     if (pageOrientation) {
-        switch (pageOrientation->getValueID()) {
+        switch (pageOrientation->valueID()) {
         case CSSValueLandscape:
             std::swap(width, height);
             break;
@@ -301,7 +300,7 @@ bool StyleBuilderCustom::getPageSizeFromName(CSSPrimitiveValue* pageSizeName, CS
 inline void StyleBuilderCustom::applyValueVerticalAlign(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID())
+    if (primitiveValue.valueID())
         styleResolver.style()->setVerticalAlign(primitiveValue);
     else
         styleResolver.style()->setVerticalAlignLength(primitiveValue.convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(styleResolver.state().cssToLengthConversionData()));
@@ -316,12 +315,12 @@ static Length convertToIntLength(const CSSPrimitiveValue* primitiveValue, const
 inline void StyleBuilderCustom::applyValueWebkitDashboardRegion(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueNone) {
+    if (primitiveValue.valueID() == CSSValueNone) {
         styleResolver.style()->setDashboardRegions(RenderStyle::noneDashboardRegions());
         return;
     }
 
-    DashboardRegion* region = primitiveValue.getDashboardRegionValue();
+    auto* region = primitiveValue.dashboardRegionValue();
     if (!region)
         return;
 
@@ -374,12 +373,12 @@ inline void StyleBuilderCustom::applyValueImageResolution(StyleResolver& styleRe
     double resolution = RenderStyle::initialImageResolution();
     for (auto& item : downcast<CSSValueList>(value)) {
         CSSPrimitiveValue& primitiveValue = downcast<CSSPrimitiveValue>(item.get());
-        if (primitiveValue.getValueID() == CSSValueFromImage)
+        if (primitiveValue.valueID() == CSSValueFromImage)
             source = ImageResolutionFromImage;
-        else if (primitiveValue.getValueID() == CSSValueSnap)
+        else if (primitiveValue.valueID() == CSSValueSnap)
             snap = ImageResolutionSnapPixels;
         else
-            resolution = primitiveValue.getDoubleValue(CSSPrimitiveValue::CSS_DPPX);
+            resolution = primitiveValue.doubleValue(CSSPrimitiveValue::CSS_DPPX);
     }
     styleResolver.style()->setImageResolutionSource(source);
     styleResolver.style()->setImageResolutionSnap(snap);
@@ -435,7 +434,7 @@ inline void StyleBuilderCustom::applyValueSize(StyleResolver& styleResolver, CSS
             pageSizeType = PAGE_SIZE_RESOLVED;
             width = height = primitiveValue.computeLength<Length>(styleResolver.state().cssToLengthConversionData().copyWithAdjustedZoom(1.0f));
         } else {
-            switch (primitiveValue.getValueID()) {
+            switch (primitiveValue.valueID()) {
             case 0:
                 return;
             case CSSValueAuto:
@@ -490,12 +489,12 @@ inline void StyleBuilderCustom::applyValueTextIndent(StyleResolver& styleResolve
 #endif
     for (auto& item : downcast<CSSValueList>(value)) {
         auto& primitiveValue = downcast<CSSPrimitiveValue>(item.get());
-        if (!primitiveValue.getValueID())
+        if (!primitiveValue.valueID())
             lengthOrPercentageValue = primitiveValue.convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(styleResolver.state().cssToLengthConversionData());
 #if ENABLE(CSS3_TEXT)
-        else if (primitiveValue.getValueID() == CSSValueWebkitEachLine)
+        else if (primitiveValue.valueID() == CSSValueWebkitEachLine)
             textIndentLineValue = TextIndentEachLine;
-        else if (primitiveValue.getValueID() == CSSValueWebkitHanging)
+        else if (primitiveValue.valueID() == CSSValueWebkitHanging)
             textIndentTypeValue = TextIndentHanging;
 #endif
     }
@@ -680,7 +679,7 @@ inline void StyleBuilderCustom::applyValueClip(StyleResolver& styleResolver, CSS
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
 
-    if (Rect* rect = primitiveValue.getRectValue()) {
+    if (Rect* rect = primitiveValue.rectValue()) {
         auto conversionData = styleResolver.state().cssToLengthConversionData();
         Length top = rect->top()->convertToLength<FixedIntegerConversion | PercentConversion | AutoConversion>(conversionData);
         Length right = rect->right()->convertToLength<FixedIntegerConversion | PercentConversion | AutoConversion>(conversionData);
@@ -689,7 +688,7 @@ inline void StyleBuilderCustom::applyValueClip(StyleResolver& styleResolver, CSS
         styleResolver.style()->setClip(top, right, bottom, left);
         styleResolver.style()->setHasClip(true);
     } else {
-        ASSERT(primitiveValue.getValueID() == CSSValueAuto);
+        ASSERT(primitiveValue.valueID() == CSSValueAuto);
         applyInitialClip(styleResolver);
     }
 }
@@ -699,10 +698,10 @@ inline void StyleBuilderCustom::applyValueWebkitLocale(StyleResolver& styleResol
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
 
     FontCascadeDescription fontDescription = styleResolver.style()->fontDescription();
-    if (primitiveValue.getValueID() == CSSValueAuto)
+    if (primitiveValue.valueID() == CSSValueAuto)
         fontDescription.setLocale(nullAtom);
     else
-        fontDescription.setLocale(primitiveValue.getStringValue());
+        fontDescription.setLocale(primitiveValue.stringValue());
     styleResolver.setFontDescription(fontDescription);
 }
 
@@ -721,12 +720,12 @@ inline void StyleBuilderCustom::applyValueWebkitTextOrientation(StyleResolver& s
 inline void StyleBuilderCustom::applyValueWebkitTextSizeAdjust(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueAuto)
+    if (primitiveValue.valueID() == CSSValueAuto)
         styleResolver.style()->setTextSizeAdjust(TextSizeAdjustment(AutoTextSizeAdjustment));
-    else if (primitiveValue.getValueID() == CSSValueNone)
+    else if (primitiveValue.valueID() == CSSValueNone)
         styleResolver.style()->setTextSizeAdjust(TextSizeAdjustment(NoTextSizeAdjustment));
     else
-        styleResolver.style()->setTextSizeAdjust(TextSizeAdjustment(primitiveValue.getFloatValue()));
+        styleResolver.style()->setTextSizeAdjust(TextSizeAdjustment(primitiveValue.floatValue()));
 
     styleResolver.state().setFontDirty(true);
 }
@@ -735,9 +734,9 @@ inline void StyleBuilderCustom::applyValueWebkitTextSizeAdjust(StyleResolver& st
 inline void StyleBuilderCustom::applyValueWebkitTextZoom(StyleResolver& styleResolver, CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
-    if (primitiveValue.getValueID() == CSSValueNormal)
+    if (primitiveValue.valueID() == CSSValueNormal)
         styleResolver.style()->setTextZoom(TextZoomNormal);
-    else if (primitiveValue.getValueID() == CSSValueReset)
+    else if (primitiveValue.valueID() == CSSValueReset)
         styleResolver.style()->setTextZoom(TextZoomReset);
     styleResolver.state().setFontDirty(true);
 }
@@ -746,7 +745,7 @@ template <CSSPropertyID id>
 inline void StyleBuilderCustom::applyTextOrBoxShadowValue(StyleResolver& styleResolver, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);
         if (id == CSSPropertyTextShadow)
             styleResolver.style()->setTextShadow(nullptr);
         else
@@ -762,7 +761,7 @@ inline void StyleBuilderCustom::applyTextOrBoxShadowValue(StyleResolver& styleRe
         int y = shadowValue.y->computeLength<int>(conversionData);
         int blur = shadowValue.blur ? shadowValue.blur->computeLength<int>(conversionData) : 0;
         int spread = shadowValue.spread ? shadowValue.spread->computeLength<int>(conversionData) : 0;
-        ShadowStyle shadowStyle = shadowValue.style && shadowValue.style->getValueID() == CSSValueInset ? Inset : Normal;
+        ShadowStyle shadowStyle = shadowValue.style && shadowValue.style->valueID() == CSSValueInset ? Inset : Normal;
         Color color;
         if (shadowValue.color)
             color = styleResolver.colorFromPrimitiveValue(*shadowValue.color);
@@ -869,7 +868,7 @@ inline void StyleBuilderCustom::applyValueFontFamily(StyleResolver& styleResolve
             // If the family name was resolved by the CSS parser from a system font ID, then it is generic.
             isGenericFamily = fontFamily.fromSystemFontID;
         } else {
-            switch (contentValue.getValueID()) {
+            switch (contentValue.valueID()) {
             case CSSValueWebkitBody:
                 if (Settings* settings = styleResolver.document().settings())
                     family = settings->standardFontFamily();
@@ -948,7 +947,7 @@ inline void StyleBuilderCustom::applyValueBaselineShift(StyleResolver& styleReso
     SVGRenderStyle& svgStyle = styleResolver.style()->accessSVGStyle();
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
     if (primitiveValue.isValueID()) {
-        switch (primitiveValue.getValueID()) {
+        switch (primitiveValue.valueID()) {
         case CSSValueBaseline:
             svgStyle.setBaselineShift(BS_BASELINE);
             break;
@@ -988,12 +987,12 @@ inline void StyleBuilderCustom::applyValueWebkitAspectRatio(StyleResolver& style
     if (is<CSSPrimitiveValue>(value)) {
         auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
 
-        if (primitiveValue.getValueID() == CSSValueFromDimensions)
+        if (primitiveValue.valueID() == CSSValueFromDimensions)
             return styleResolver.style()->setAspectRatioType(AspectRatioFromDimensions);
-        if (primitiveValue.getValueID() == CSSValueFromIntrinsic)
+        if (primitiveValue.valueID() == CSSValueFromIntrinsic)
             return styleResolver.style()->setAspectRatioType(AspectRatioFromIntrinsic);
 
-        ASSERT(primitiveValue.getValueID() == CSSValueAuto);
+        ASSERT(primitiveValue.valueID() == CSSValueAuto);
         return styleResolver.style()->setAspectRatioType(AspectRatioAuto);
     }
 
@@ -1025,7 +1024,7 @@ inline void StyleBuilderCustom::applyValueWebkitTextEmphasisStyle(StyleResolver&
 
         for (auto& item : list) {
             CSSPrimitiveValue& value = downcast<CSSPrimitiveValue>(item.get());
-            if (value.getValueID() == CSSValueFilled || value.getValueID() == CSSValueOpen)
+            if (value.valueID() == CSSValueFilled || value.valueID() == CSSValueOpen)
                 styleResolver.style()->setTextEmphasisFill(value);
             else
                 styleResolver.style()->setTextEmphasisMark(value);
@@ -1038,13 +1037,13 @@ inline void StyleBuilderCustom::applyValueWebkitTextEmphasisStyle(StyleResolver&
     if (primitiveValue.isString()) {
         styleResolver.style()->setTextEmphasisFill(TextEmphasisFillFilled);
         styleResolver.style()->setTextEmphasisMark(TextEmphasisMarkCustom);
-        styleResolver.style()->setTextEmphasisCustomMark(primitiveValue.getStringValue());
+        styleResolver.style()->setTextEmphasisCustomMark(primitiveValue.stringValue());
         return;
     }
 
     styleResolver.style()->setTextEmphasisCustomMark(nullAtom);
 
-    if (primitiveValue.getValueID() == CSSValueFilled || primitiveValue.getValueID() == CSSValueOpen) {
+    if (primitiveValue.valueID() == CSSValueFilled || primitiveValue.valueID() == CSSValueOpen) {
         styleResolver.style()->setTextEmphasisFill(primitiveValue);
         styleResolver.style()->setTextEmphasisMark(TextEmphasisMarkAuto);
     } else {
@@ -1069,7 +1068,7 @@ inline void StyleBuilderCustom::applyInheritCounter(StyleResolver& styleResolver
 template <StyleBuilderCustom::CounterBehavior counterBehavior>
 inline void StyleBuilderCustom::applyValueCounter(StyleResolver& styleResolver, CSSValue& value)
 {
-    bool setCounterIncrementToNone = counterBehavior == Increment && is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone;
+    bool setCounterIncrementToNone = counterBehavior == Increment && is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone;
 
     if (!is<CSSValueList>(value) && !setCounterIncrementToNone)
         return;
@@ -1086,12 +1085,12 @@ inline void StyleBuilderCustom::applyValueCounter(StyleResolver& styleResolver,
         return;
 
     for (auto& item : downcast<CSSValueList>(value)) {
-        Pair* pair = downcast<CSSPrimitiveValue>(item.get()).getPairValue();
+        Pair* pair = downcast<CSSPrimitiveValue>(item.get()).pairValue();
         if (!pair || !pair->first() || !pair->second())
             continue;
 
-        AtomicString identifier = pair->first()->getStringValue();
-        int value = pair->second()->getIntValue();
+        AtomicString identifier = pair->first()->stringValue();
+        int value = pair->second()->intValue();
         CounterDirectives& directives = map.add(identifier, CounterDirectives()).iterator->value;
         if (counterBehavior == Reset)
             directives.setResetValue(value);
@@ -1219,7 +1218,7 @@ inline void StyleBuilderCustom::applyValueWebkitSvgShadow(StyleResolver& styleRe
 {
     SVGRenderStyle& svgStyle = styleResolver.style()->accessSVGStyle();
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);
         svgStyle.setShadow(nullptr);
         return;
     }
@@ -1257,7 +1256,7 @@ inline void StyleBuilderCustom::applyValueFontWeight(StyleResolver& styleResolve
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
     auto fontDescription = styleResolver.fontDescription();
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueInvalid:
         ASSERT_NOT_REACHED();
         break;
@@ -1290,7 +1289,7 @@ inline void StyleBuilderCustom::applyInheritColumnGap(StyleResolver& styleResolv
 
 inline void StyleBuilderCustom::applyValueColumnGap(StyleResolver& styleResolver, CSSValue& value)
 {
-    if (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal)
+    if (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal)
         styleResolver.style()->setHasNormalColumnGap();
     else
         styleResolver.style()->setColumnGap(StyleBuilderConverter::convertComputedLength<float>(styleResolver, value));
@@ -1333,7 +1332,7 @@ inline void StyleBuilderCustom::applyValueContent(StyleResolver& styleResolver,
 
         auto& contentValue = downcast<CSSPrimitiveValue>(item.get());
         if (contentValue.isString()) {
-            styleResolver.style()->setContent(contentValue.getStringValue().impl(), didSet);
+            styleResolver.style()->setContent(contentValue.stringValue().impl(), didSet);
             didSet = true;
         } else if (contentValue.isAttr()) {
             // FIXME: Can a namespace be specified for an attr(foo)?
@@ -1341,7 +1340,7 @@ inline void StyleBuilderCustom::applyValueContent(StyleResolver& styleResolver,
                 styleResolver.style()->setHasAttrContent();
             else
                 const_cast<RenderStyle*>(styleResolver.parentStyle())->setHasAttrContent();
-            QualifiedName attr(nullAtom, contentValue.getStringValue().impl(), nullAtom);
+            QualifiedName attr(nullAtom, contentValue.stringValue().impl(), nullAtom);
             const AtomicString& value = styleResolver.element()->getAttribute(attr);
             styleResolver.style()->setContent(value.isNull() ? emptyAtom : value.impl(), didSet);
             didSet = true;
@@ -1349,7 +1348,7 @@ inline void StyleBuilderCustom::applyValueContent(StyleResolver& styleResolver,
             styleResolver.ruleSets().mutableFeatures().attributeCanonicalLocalNamesInRules.add(attr.localName().impl());
             styleResolver.ruleSets().mutableFeatures().attributeLocalNamesInRules.add(attr.localName().impl());
         } else if (contentValue.isCounter()) {
-            Counter* counterValue = contentValue.getCounterValue();
+            auto* counterValue = contentValue.counterValue();
             EListStyleType listStyleType = NoneListStyle;
             CSSValueID listStyleIdent = counterValue->listStyleIdent();
             if (listStyleIdent != CSSValueNone)
@@ -1358,7 +1357,7 @@ inline void StyleBuilderCustom::applyValueContent(StyleResolver& styleResolver,
             styleResolver.style()->setContent(WTFMove(counter), didSet);
             didSet = true;
         } else {
-            switch (contentValue.getValueID()) {
+            switch (contentValue.valueID()) {
             case CSSValueOpenQuote:
                 styleResolver.style()->setContent(OPEN_QUOTE, didSet);
                 didSet = true;
@@ -1553,7 +1552,7 @@ inline void StyleBuilderCustom::applyValueFontSize(StyleResolver& styleResolver,
 
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
     float size;
-    if (CSSValueID ident = primitiveValue.getValueID()) {
+    if (CSSValueID ident = primitiveValue.valueID()) {
         fontDescription.setIsAbsoluteSize(parentIsAbsoluteSize && (ident == CSSValueLarger || ident == CSSValueSmaller || ident == CSSValueWebkitRubyText));
 
         // Keywords are being used.
@@ -1587,7 +1586,7 @@ inline void StyleBuilderCustom::applyValueFontSize(StyleResolver& styleResolver,
             size = primitiveValue.computeLength<float>(CSSToLengthConversionData(styleResolver.parentStyle(), styleResolver.rootElementStyle(), styleResolver.document().renderView(), 1.0f, true));
             styleResolver.state().setFontSizeHasViewportUnits(primitiveValue.isViewportPercentageLength());
         } else if (primitiveValue.isPercentage())
-            size = (primitiveValue.getFloatValue() * parentSize) / 100.0f;
+            size = (primitiveValue.floatValue() * parentSize) / 100.0f;
         else if (primitiveValue.isCalculatedPercentageWithLength())
             size = primitiveValue.cssCalcValue()->createCalculationValue(styleResolver.state().cssToLengthConversionData().copyWithAdjustedZoom(1.0f))->evaluate(parentSize);
         else
@@ -1619,7 +1618,7 @@ inline void StyleBuilderCustom::applyInheritGridTemplateAreas(StyleResolver& sty
 inline void StyleBuilderCustom::applyValueGridTemplateAreas(StyleResolver& styleResolver, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNone);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);
         return;
     }
 
@@ -1706,7 +1705,7 @@ void StyleBuilderCustom::applyValueAlt(StyleResolver& styleResolver, CSSValue& v
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
     if (primitiveValue.isString())
-        styleResolver.style()->setContentAltText(primitiveValue.getStringValue());
+        styleResolver.style()->setContentAltText(primitiveValue.stringValue());
     else if (primitiveValue.isAttr()) {
         // FIXME: Can a namespace be specified for an attr(foo)?
         if (styleResolver.style()->styleType() == NOPSEUDO)
@@ -1714,7 +1713,7 @@ void StyleBuilderCustom::applyValueAlt(StyleResolver& styleResolver, CSSValue& v
         else
             const_cast<RenderStyle*>(styleResolver.parentStyle())->setUnique();
 
-        QualifiedName attr(nullAtom, primitiveValue.getStringValue(), nullAtom);
+        QualifiedName attr(nullAtom, primitiveValue.stringValue(), nullAtom);
         const AtomicString& value = styleResolver.element()->getAttribute(attr);
         styleResolver.style()->setContentAltText(value.isNull() ? emptyAtom : value);
 
@@ -1726,6 +1725,7 @@ void StyleBuilderCustom::applyValueAlt(StyleResolver& styleResolver, CSSValue& v
 }
 
 #if ENABLE(CSS_SCROLL_SNAP)
+
 inline void StyleBuilderCustom::applyInitialWebkitScrollSnapPointsX(StyleResolver& styleResolver)
 {
     styleResolver.style()->setScrollSnapPointsX(nullptr);
@@ -1745,23 +1745,23 @@ inline void StyleBuilderCustom::applyInheritWebkitScrollSnapPointsY(StyleResolve
 {
     styleResolver.style()->setScrollSnapPointsY(styleResolver.parentStyle()->scrollSnapPointsY() ? std::make_unique<ScrollSnapPoints>(*styleResolver.parentStyle()->scrollSnapPointsY()) : nullptr);
 }
+
 #endif
 
 inline void StyleBuilderCustom::applyValueWillChange(StyleResolver& styleResolver, CSSValue& value)
 {
     if (is<CSSPrimitiveValue>(value)) {
-        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueAuto);
+        ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueAuto);
         styleResolver.style()->setWillChange(nullptr);
         return;
     }
 
-    Ref<WillChangeData> willChange = WillChangeData::create();
+    auto willChange = WillChangeData::create();
     for (auto& item : downcast<CSSValueList>(value)) {
         if (!is<CSSPrimitiveValue>(item.get()))
             continue;
-
-        const auto& primitiveValue = downcast<CSSPrimitiveValue>(item.get());
-        switch (primitiveValue.getValueID()) {
+        auto& primitiveValue = downcast<CSSPrimitiveValue>(item.get());
+        switch (primitiveValue.valueID()) {
         case CSSValueScrollPosition:
             willChange->addFeature(WillChangeData::Feature::ScrollPosition);
             break;
@@ -1770,14 +1770,11 @@ inline void StyleBuilderCustom::applyValueWillChange(StyleResolver& styleResolve
             break;
         default:
             if (primitiveValue.isPropertyID())
-                willChange->addFeature(WillChangeData::Feature::Property, primitiveValue.getPropertyID());
+                willChange->addFeature(WillChangeData::Feature::Property, primitiveValue.propertyID());
             break;
         }
     }
-
     styleResolver.style()->setWillChange(WTFMove(willChange));
 }
 
 } // namespace WebCore
-
-#endif // StyleBuilderCustom_h
index 6dd4c5a..66b59cc 100644 (file)
@@ -441,8 +441,8 @@ String StyleProperties::getLayeredShorthandValue(const StylePropertyShorthand& s
                         if (!is<CSSPrimitiveValue>(*value) || !is<CSSPrimitiveValue>(*yValue))
                             continue;
 
-                        CSSValueID xId = downcast<CSSPrimitiveValue>(*value).getValueID();
-                        CSSValueID yId = downcast<CSSPrimitiveValue>(*yValue).getValueID();
+                        CSSValueID xId = downcast<CSSPrimitiveValue>(*value).valueID();
+                        CSSValueID yId = downcast<CSSPrimitiveValue>(*yValue).valueID();
                         if (xId != yId) {
                             if (xId == CSSValueRepeat && yId == CSSValueNoRepeat) {
                                 useRepeatXShorthand = true;
index 8499d8f..5da6bb7 100644 (file)
@@ -227,7 +227,7 @@ void StyleResolver::MatchResult::addMatchedProperties(const StyleProperties& pro
 
                 // The value currentColor has implicitely the same side effect. It depends on the value of color,
                 // which is an inherited value, making the non-inherited property implicitly inherited.
-                if (is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueCurrentcolor) {
+                if (is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).valueID() == CSSValueCurrentcolor) {
                     isCacheable = false;
                     break;
                 }
@@ -1816,7 +1816,7 @@ static Color colorForCSSValue(CSSValueID cssValueId)
 
 bool StyleResolver::colorFromPrimitiveValueIsDerivedFromElement(const CSSPrimitiveValue& value)
 {
-    int ident = value.getValueID();
+    int ident = value.valueID();
     switch (ident) {
     case CSSValueWebkitText:
     case CSSValueWebkitLink:
@@ -1834,7 +1834,7 @@ Color StyleResolver::colorFromPrimitiveValue(const CSSPrimitiveValue& value, boo
         return value.color();
 
     const State& state = m_state;
-    CSSValueID ident = value.getValueID();
+    CSSValueID ident = value.valueID();
     switch (ident) {
     case 0:
         return Color();
@@ -1905,7 +1905,7 @@ bool StyleResolver::createFilterOperations(const CSSValue& inValue, FilterOperat
     
     if (is<CSSPrimitiveValue>(inValue)) {
         auto& primitiveValue = downcast<CSSPrimitiveValue>(inValue);
-        if (primitiveValue.getValueID() == CSSValueNone)
+        if (primitiveValue.valueID() == CSSValueNone)
             return true;
     }
     
@@ -1929,7 +1929,7 @@ bool StyleResolver::createFilterOperations(const CSSValue& inValue, FilterOperat
                 continue;
 
             auto& primitiveValue = downcast<CSSPrimitiveValue>(argument);
-            String cssUrl = primitiveValue.getStringValue();
+            String cssUrl = primitiveValue.stringValue();
             URL url = m_state.document().completeURL(cssUrl);
 
             RefPtr<ReferenceFilterOperation> operation = ReferenceFilterOperation::create(cssUrl, url.fragmentIdentifier());
@@ -1960,7 +1960,7 @@ bool StyleResolver::createFilterOperations(const CSSValue& inValue, FilterOperat
         case WebKitCSSFilterValue::SaturateFilterOperation: {
             double amount = 1;
             if (filterValue.length() == 1) {
-                amount = firstValue->getDoubleValue();
+                amount = firstValue->doubleValue();
                 if (firstValue->isPercentage())
                     amount /= 100;
             }
@@ -1982,7 +1982,7 @@ bool StyleResolver::createFilterOperations(const CSSValue& inValue, FilterOperat
         case WebKitCSSFilterValue::OpacityFilterOperation: {
             double amount = (filterValue.operationType() == WebKitCSSFilterValue::BrightnessFilterOperation) ? 0 : 1;
             if (filterValue.length() == 1) {
-                amount = firstValue->getDoubleValue();
+                amount = firstValue->doubleValue();
                 if (firstValue->isPercentage())
                     amount /= 100;
             }
index 61958bc..f62325e 100644 (file)
@@ -115,13 +115,13 @@ bool transformsForValue(const CSSValue& value, const CSSToLengthConversionData&
             double sx = 1.0;
             double sy = 1.0;
             if (transformValue.operationType() == WebKitCSSTransformValue::ScaleYTransformOperation)
-                sy = firstValue.getDoubleValue();
+                sy = firstValue.doubleValue();
             else {
-                sx = firstValue.getDoubleValue();
+                sx = firstValue.doubleValue();
                 if (transformValue.operationType() != WebKitCSSTransformValue::ScaleXTransformOperation) {
                     if (transformValue.length() > 1) {
                         auto& secondValue = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(1));
-                        sy = secondValue.getDoubleValue();
+                        sy = secondValue.doubleValue();
                     } else
                         sy = sx;
                 }
@@ -135,19 +135,19 @@ bool transformsForValue(const CSSValue& value, const CSSToLengthConversionData&
             double sy = 1.0;
             double sz = 1.0;
             if (transformValue.operationType() == WebKitCSSTransformValue::ScaleZTransformOperation)
-                sz = firstValue.getDoubleValue();
+                sz = firstValue.doubleValue();
             else if (transformValue.operationType() == WebKitCSSTransformValue::ScaleYTransformOperation)
-                sy = firstValue.getDoubleValue();
+                sy = firstValue.doubleValue();
             else {
-                sx = firstValue.getDoubleValue();
+                sx = firstValue.doubleValue();
                 if (transformValue.operationType() != WebKitCSSTransformValue::ScaleXTransformOperation) {
                     if (transformValue.length() > 2) {
                         auto& thirdValue = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(2));
-                        sz = thirdValue.getDoubleValue();
+                        sz = thirdValue.doubleValue();
                     }
                     if (transformValue.length() > 1) {
                         auto& secondValue = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(1));
-                        sy = secondValue.getDoubleValue();
+                        sy = secondValue.doubleValue();
                     } else
                         sy = sx;
                 }
@@ -235,9 +235,9 @@ bool transformsForValue(const CSSValue& value, const CSSToLengthConversionData&
             auto& secondValue = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(1));
             auto& thirdValue = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(2));
             auto& fourthValue = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(3));
-            double x = firstValue.getDoubleValue();
-            double y = secondValue.getDoubleValue();
-            double z = thirdValue.getDoubleValue();
+            double x = firstValue.doubleValue();
+            double y = secondValue.doubleValue();
+            double z = thirdValue.doubleValue();
             double angle = fourthValue.computeDegrees();
             operations.operations().append(RotateTransformOperation::create(x, y, z, angle, transformOperationType(transformValue.operationType())));
             break;
@@ -265,34 +265,34 @@ bool transformsForValue(const CSSValue& value, const CSSToLengthConversionData&
         case WebKitCSSTransformValue::MatrixTransformOperation: {
             if (transformValue.length() < 6)
                 break;
-            double a = firstValue.getDoubleValue();
-            double b = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(1)).getDoubleValue();
-            double c = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(2)).getDoubleValue();
-            double d = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(3)).getDoubleValue();
-            double e = conversionData.zoom() * downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(4)).getDoubleValue();
-            double f = conversionData.zoom() * downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(5)).getDoubleValue();
+            double a = firstValue.doubleValue();
+            double b = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(1)).doubleValue();
+            double c = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(2)).doubleValue();
+            double d = downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(3)).doubleValue();
+            double e = conversionData.zoom() * downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(4)).doubleValue();
+            double f = conversionData.zoom() * downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(5)).doubleValue();
             operations.operations().append(MatrixTransformOperation::create(a, b, c, d, e, f));
             break;
         }
         case WebKitCSSTransformValue::Matrix3DTransformOperation: {
             if (transformValue.length() < 16)
                 break;
-            TransformationMatrix matrix(downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(0)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(1)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(2)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(3)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(4)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(5)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(6)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(7)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(8)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(9)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(10)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(11)).getDoubleValue(),
-                conversionData.zoom() * downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(12)).getDoubleValue(),
-                conversionData.zoom() * downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(13)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(14)).getDoubleValue(),
-                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(15)).getDoubleValue());
+            TransformationMatrix matrix(downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(0)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(1)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(2)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(3)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(4)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(5)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(6)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(7)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(8)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(9)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(10)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(11)).doubleValue(),
+                conversionData.zoom() * downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(12)).doubleValue(),
+                conversionData.zoom() * downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(13)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(14)).doubleValue(),
+                downcast<CSSPrimitiveValue>(*transformValue.itemWithoutBoundsCheck(15)).doubleValue());
             operations.operations().append(Matrix3DTransformOperation::create(matrix));
             break;
         }
@@ -302,7 +302,7 @@ bool transformsForValue(const CSSValue& value, const CSSToLengthConversionData&
                 p = convertToFloatLength(&firstValue, conversionData);
             else {
                 // This is a quirk that should go away when 3d transforms are finalized.
-                double val = firstValue.getDoubleValue();
+                double val = firstValue.doubleValue();
                 p = val >= 0 ? Length(clampToPositiveInteger(val), Fixed) : Length(Undefined);
             }
 
index dbb6cc4..dc34219 100644 (file)
@@ -114,13 +114,13 @@ float ViewportStyleResolver::getViewportArgumentValue(CSSPropertyID id) const
     CSSPrimitiveValue& primitiveValue = downcast<CSSPrimitiveValue>(*value);
 
     if (primitiveValue.isNumber() || primitiveValue.isPx())
-        return primitiveValue.getFloatValue();
+        return primitiveValue.floatValue();
 
     if (primitiveValue.isFontRelativeLength())
-        return primitiveValue.getFloatValue() * m_document->documentElement()->renderStyle()->fontDescription().computedSize();
+        return primitiveValue.floatValue() * m_document->documentElement()->renderStyle()->fontDescription().computedSize();
 
     if (primitiveValue.isPercentage()) {
-        float percentValue = primitiveValue.getFloatValue() / 100.0f;
+        float percentValue = primitiveValue.floatValue() / 100.0f;
         switch (id) {
         case CSSPropertyMaxHeight:
         case CSSPropertyMinHeight:
@@ -140,7 +140,7 @@ float ViewportStyleResolver::getViewportArgumentValue(CSSPropertyID id) const
         }
     }
 
-    switch (primitiveValue.getValueID()) {
+    switch (primitiveValue.valueID()) {
     case CSSValueAuto:
         return defaultValue;
     case CSSValueDeviceHeight:
index 1bca4fd..e38aafc 100644 (file)
 
 namespace WebCore {
 
-WebKitCSSMatrix::WebKitCSSMatrix(const TransformationMatrix& m)
-    : m_matrix(m)
+inline WebKitCSSMatrix::WebKitCSSMatrix(const TransformationMatrix& matrix)
+    : m_matrix(matrix)
 {
 }
 
-WebKitCSSMatrix::WebKitCSSMatrix(const String& s, ExceptionCode& ec)
+Ref<WebKitCSSMatrix> WebKitCSSMatrix::create(const TransformationMatrix& matrix)
 {
-    setMatrixValue(s, ec);
+    return adoptRef(*new WebKitCSSMatrix(matrix));
+}
+
+ExceptionOr<Ref<WebKitCSSMatrix>> WebKitCSSMatrix::create(const String& string)
+{
+    auto result = adoptRef(*new WebKitCSSMatrix);
+    auto setMatrixValueResult = result->setMatrixValue(string);
+    if (setMatrixValueResult.hasException())
+        return setMatrixValueResult.releaseException();
+    return WTFMove(result);
 }
 
 WebKitCSSMatrix::~WebKitCSSMatrix()
 {
 }
 
-void WebKitCSSMatrix::setMatrixValue(const String& string, ExceptionCode& ec)
+ExceptionOr<void> WebKitCSSMatrix::setMatrixValue(const String& string)
 {
     if (string.isEmpty())
-        return;
+        return { };
 
     auto styleDeclaration = MutableStyleProperties::create();
-    if (CSSParser::parseValue(styleDeclaration, CSSPropertyTransform, string, true, HTMLStandardMode, nullptr) != CSSParser::ParseResult::Error) {
-        // Convert to TransformOperations. This can fail if a property
-        // requires style (i.e., param uses 'ems' or 'exs')
-        RefPtr<CSSValue> value = styleDeclaration->getPropertyCSSValue(CSSPropertyTransform);
-
-        // Check for a "none" or empty transform. In these cases we can use the default identity matrix.
-        if (!value || (is<CSSPrimitiveValue>(*value) && downcast<CSSPrimitiveValue>(*value).getValueID() == CSSValueNone))
-            return;
-
-        TransformOperations operations;
-        if (!transformsForValue(*value, CSSToLengthConversionData(), operations)) {
-            ec = SYNTAX_ERR;
-            return;
-        }
-
-        // Convert transform operations to a TransformationMatrix. This can fail
-        // if a param has a percentage ('%')
-        TransformationMatrix t;
-        for (unsigned i = 0; i < operations.operations().size(); ++i) {
-            if (operations.operations()[i].get()->apply(t, IntSize(0, 0))) {
-                ec = SYNTAX_ERR;
-                return;
-            }
-        }
-
-        // set the matrix
-        m_matrix = t;
-    } else // There is something there but parsing failed.
-        ec = SYNTAX_ERR;
+    if (CSSParser::parseValue(styleDeclaration, CSSPropertyTransform, string, true, HTMLStandardMode, nullptr) == CSSParser::ParseResult::Error)
+        return Exception { SYNTAX_ERR };
+
+    // Convert to TransformOperations. This can fail if a property requires style (i.e., param uses 'ems' or 'exs')
+    auto value = styleDeclaration->getPropertyCSSValue(CSSPropertyTransform);
+
+    // Check for a "none" or empty transform. In these cases we can use the default identity matrix.
+    if (!value || (is<CSSPrimitiveValue>(*value) && downcast<CSSPrimitiveValue>(*value).valueID() == CSSValueNone))
+        return { };
+
+    TransformOperations operations;
+    if (!transformsForValue(*value, CSSToLengthConversionData(), operations))
+        return Exception { SYNTAX_ERR };
+
+    // Convert transform operations to a TransformationMatrix. This can fail if a parameter has a percentage ('%').
+    TransformationMatrix matrix;
+    for (auto& operation : operations.operations()) {
+        if (operation->apply(matrix, IntSize(0, 0)))
+            return Exception { SYNTAX_ERR };
+    }
+    m_matrix = matrix;
+    return { };
 }
 
 // Perform a concatenation of the matrices (this * secondMatrix)
@@ -94,21 +96,20 @@ RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::multiply(WebKitCSSMatrix* secondMatrix)
     if (!secondMatrix)
         return nullptr;
 
-    RefPtr<WebKitCSSMatrix> matrix = WebKitCSSMatrix::create(m_matrix);
+    auto matrix = create(m_matrix);
     matrix->m_matrix.multiply(secondMatrix->m_matrix);
-    return matrix;
+    return WTFMove(matrix);
 }
 
-RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::inverse(ExceptionCode& ec) const
+ExceptionOr<Ref<WebKitCSSMatrix>> WebKitCSSMatrix::inverse() const
 {
-    if (auto inverse = m_matrix.inverse())
-        return WebKitCSSMatrix::create(inverse.value());
-    
-    ec = NOT_SUPPORTED_ERR;
-    return nullptr;
+    auto inverse = m_matrix.inverse();
+    if (!inverse)
+        return Exception { NOT_SUPPORTED_ERR };
+    return create(inverse.value());
 }
 
-RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::translate(double x, double y, double z) const
+Ref<WebKitCSSMatrix> WebKitCSSMatrix::translate(double x, double y, double z) const
 {
     if (std::isnan(x))
         x = 0;
@@ -117,12 +118,12 @@ RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::translate(double x, double y, double z)
     if (std::isnan(z))
         z = 0;
 
-    RefPtr<WebKitCSSMatrix> matrix = WebKitCSSMatrix::create(m_matrix);
+    auto matrix = create(m_matrix);
     matrix->m_matrix.translate3d(x, y, z);
     return matrix;
 }
 
-RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::scale(double scaleX, double scaleY, double scaleZ) const
+Ref<WebKitCSSMatrix> WebKitCSSMatrix::scale(double scaleX, double scaleY, double scaleZ) const
 {
     if (std::isnan(scaleX))
         scaleX = 1;
@@ -131,12 +132,12 @@ RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::scale(double scaleX, double scaleY, dou
     if (std::isnan(scaleZ))
         scaleZ = 1;
 
-    RefPtr<WebKitCSSMatrix> matrix = WebKitCSSMatrix::create(m_matrix);
+    auto matrix = create(m_matrix);
     matrix->m_matrix.scale3d(scaleX, scaleY, scaleZ);
     return matrix;
 }
 
-RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::rotate(double rotX, double rotY, double rotZ) const
+Ref<WebKitCSSMatrix> WebKitCSSMatrix::rotate(double rotX, double rotY, double rotZ) const
 {
     if (std::isnan(rotX))
         rotX = 0;
@@ -152,12 +153,12 @@ RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::rotate(double rotX, double rotY, double
     if (std::isnan(rotZ))
         rotZ = 0;
 
-    RefPtr<WebKitCSSMatrix> matrix = WebKitCSSMatrix::create(m_matrix);
+    auto matrix = create(m_matrix);
     matrix->m_matrix.rotate3d(rotX, rotY, rotZ);
     return matrix;
 }
 
-RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::rotateAxisAngle(double x, double y, double z, double angle) const
+Ref<WebKitCSSMatrix> WebKitCSSMatrix::rotateAxisAngle(double x, double y, double z, double angle) const
 {
     if (std::isnan(x))
         x = 0;
@@ -170,27 +171,27 @@ RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::rotateAxisAngle(double x, double y, dou
     if (x == 0 && y == 0 && z == 0)
         z = 1;
 
-    RefPtr<WebKitCSSMatrix> matrix = WebKitCSSMatrix::create(m_matrix);
+    auto matrix = create(m_matrix);
     matrix->m_matrix.rotate3d(x, y, z, angle);
     return matrix;
 }
 
-RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::skewX(double angle) const
+Ref<WebKitCSSMatrix> WebKitCSSMatrix::skewX(double angle) const
 {
     if (std::isnan(angle))
         angle = 0;
 
-    RefPtr<WebKitCSSMatrix> matrix = WebKitCSSMatrix::create(m_matrix);
+    auto matrix = create(m_matrix);
     matrix->m_matrix.skewX(angle);
     return matrix;
 }
 
-RefPtr<WebKitCSSMatrix> WebKitCSSMatrix::skewY(double angle) const
+Ref<WebKitCSSMatrix> WebKitCSSMatrix::skewY(double angle) const
 {
     if (std::isnan(angle))
         angle = 0;
 
-    RefPtr<WebKitCSSMatrix> matrix = WebKitCSSMatrix::create(m_matrix);
+    auto matrix = create(m_matrix);
     matrix->m_matrix.skewY(angle);
     return matrix;
 }
@@ -199,13 +200,12 @@ String WebKitCSSMatrix::toString() const
 {
     // FIXME - Need to ensure valid CSS floating point values (https://bugs.webkit.org/show_bug.cgi?id=20674)
     if (m_matrix.isAffine())
-        return String::format("matrix(%f, %f, %f, %f, %f, %f)",
-                                m_matrix.a(), m_matrix.b(), m_matrix.c(), m_matrix.d(), m_matrix.e(), m_matrix.f());
+        return String::format("matrix(%f, %f, %f, %f, %f, %f)", m_matrix.a(), m_matrix.b(), m_matrix.c(), m_matrix.d(), m_matrix.e(), m_matrix.f());
     return String::format("matrix3d(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)",
-                            m_matrix.m11(), m_matrix.m12(), m_matrix.m13(), m_matrix.m14(),
-                            m_matrix.m21(), m_matrix.m22(), m_matrix.m23(), m_matrix.m24(),
-                            m_matrix.m31(), m_matrix.m32(), m_matrix.m33(), m_matrix.m34(),
-                            m_matrix.m41(), m_matrix.m42(), m_matrix.m43(), m_matrix.m44());
+        m_matrix.m11(), m_matrix.m12(), m_matrix.m13(), m_matrix.m14(),
+        m_matrix.m21(), m_matrix.m22(), m_matrix.m23(), m_matrix.m24(),
+        m_matrix.m31(), m_matrix.m32(), m_matrix.m33(), m_matrix.m34(),
+        m_matrix.m41(), m_matrix.m42(), m_matrix.m43(), m_matrix.m44());
 }
 
 } // namespace WebCore
index 8921ce4..84c0279 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef WebKitCSSMatrix_h
-#define WebKitCSSMatrix_h
+#pragma once
 
+#include "ExceptionOr.h"
 #include "ScriptWrappable.h"
 #include "TransformationMatrix.h"
-#include <wtf/RefCounted.h>
-#include <wtf/RefPtr.h>
-#include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
-typedef int ExceptionCode;
-
 class WebKitCSSMatrix final : public ScriptWrappable, public RefCounted<WebKitCSSMatrix> {
 public:
-    static Ref<WebKitCSSMatrix> create(const TransformationMatrix& m)
-    {
-        return adoptRef(*new WebKitCSSMatrix(m));
-    }
-    static Ref<WebKitCSSMatrix> create(const String& s, ExceptionCode& ec)
-    {
-        return adoptRef(*new WebKitCSSMatrix(s, ec));
-    }
+    static Ref<WebKitCSSMatrix> create(const TransformationMatrix&);
+    static ExceptionOr<Ref<WebKitCSSMatrix>> create(const String&);
 
     ~WebKitCSSMatrix();
 
@@ -97,7 +86,7 @@ public:
     void setM43(double f) { m_matrix.setM43(f); }
     void setM44(double f) { m_matrix.setM44(f); }
 
-    void setMatrixValue(const String&, ExceptionCode&);
+    ExceptionOr<void> setMatrixValue(const String&);
 
     // The following math function return a new matrix with the
     // specified operation applied. The this value is not modified.
@@ -106,57 +95,55 @@ public:
     RefPtr<WebKitCSSMatrix> multiply(WebKitCSSMatrix* secondMatrix) const;
 
     // Return the inverse of this matrix. Throw an exception if the matrix is not invertible
-    RefPtr<WebKitCSSMatrix> inverse(ExceptionCode&) const;
+    ExceptionOr<Ref<WebKitCSSMatrix>> inverse() const;
 
     // Return this matrix translated by the passed values.
     // Passing a NaN will use a value of 0. This allows the 3D form to used for 2D operations
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the translation values on the left (result = translation(x,y,z) * this)
-    RefPtr<WebKitCSSMatrix> translate(double x, double y, double z) const;
+    Ref<WebKitCSSMatrix> translate(double x, double y, double z) const;
 
     // Returns this matrix scaled by the passed values.
     // Passing scaleX or scaleZ as NaN uses a value of 1, but passing scaleY of NaN
     // makes it the same as scaleX. This allows the 3D form to used for 2D operations
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the scale values on the left (result = scale(x,y,z) * this)
-    RefPtr<WebKitCSSMatrix> scale(double scaleX, double scaleY, double scaleZ) const;
+    Ref<WebKitCSSMatrix> scale(double scaleX, double scaleY, double scaleZ) const;
 
     // Returns this matrix rotated by the passed values.
     // If rotY and rotZ are NaN, rotate about Z (rotX=0, rotateY=0, rotateZ=rotX).
     // Otherwise use a rotation value of 0 for any passed NaN.
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the rotation values on the left (result = rotation(x,y,z) * this)
-    RefPtr<WebKitCSSMatrix> rotate(double rotX, double rotY, double rotZ) const;
+    Ref<WebKitCSSMatrix> rotate(double rotX, double rotY, double rotZ) const;
 
     // Returns this matrix rotated about the passed axis by the passed angle.
     // Passing a NaN will use a value of 0. If the axis is (0,0,0) use a value
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the rotation values on the left (result = rotation(x,y,z,angle) * this)
-    RefPtr<WebKitCSSMatrix> rotateAxisAngle(double x, double y, double z, double angle) const;
+    Ref<WebKitCSSMatrix> rotateAxisAngle(double x, double y, double z, double angle) const;
 
     // Return this matrix skewed along the X axis by the passed values.
     // Passing a NaN will use a value of 0.
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the skew values on the left (result = skewX(angle) * this)
-    RefPtr<WebKitCSSMatrix> skewX(double angle) const;
+    Ref<WebKitCSSMatrix> skewX(double angle) const;
 
     // Return this matrix skewed along the Y axis by the passed values.
     // Passing a NaN will use a value of 0.
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the skew values on the left (result = skewY(angle) * this)
-    RefPtr<WebKitCSSMatrix> skewY(double angle) const;
+    Ref<WebKitCSSMatrix> skewY(double angle) const;
 
     const TransformationMatrix& transform() const { return m_matrix; }
 
     String toString() const;
 
-protected:
+private:
+    WebKitCSSMatrix() = default;
     WebKitCSSMatrix(const TransformationMatrix&);
-    WebKitCSSMatrix(const String&, ExceptionCode&);
 
     TransformationMatrix m_matrix;
 };
 
 } // namespace WebCore
-
-#endif // WebKitCSSMatrix_h
index b7f12b2..b8d5f32 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-// Introduced in DOM Level ?:
 [
     Constructor(optional DOMString cssValue),
-    ConstructorMayThrowLegacyException,
+    ConstructorMayThrowException,
     ImplementationLacksVTable,
 ] interface WebKitCSSMatrix {
 
     attribute unrestricted double m44;
 
     // FIXME: Using "undefined" as default parameter value is wrong.
-    [MayThrowLegacyException] void setMatrixValue(optional DOMString string = "undefined");
+    [MayThrowException] void setMatrixValue(optional DOMString string = "undefined");
     
     // Multiply this matrix by secondMatrix, on the right (result = this * secondMatrix)
     [Immutable] WebKitCSSMatrix multiply(optional WebKitCSSMatrix? secondMatrix = null);
     
     // Return the inverse of this matrix. Throw an exception if the matrix is not invertible
-    [Immutable, MayThrowLegacyException] WebKitCSSMatrix inverse();
+    [Immutable, MayThrowException] WebKitCSSMatrix inverse();
     
     // Return this matrix translated by the passed values.
     // Passing a NaN will use a value of 0. This allows the 3D form to used for 2D operations
 
     [NotEnumerable] DOMString toString();
 };
-
index 9e96d9b..423fba6 100755 (executable)
@@ -518,7 +518,7 @@ sub handleCurrentColorValue {
   my $primitiveValue = shift;
   my $indent = shift;
 
-  my $code = $indent . "if (" . $primitiveValue . ".getValueID() == CSSValueCurrentcolor) {\n";
+  my $code = $indent . "if (" . $primitiveValue . ".valueID() == CSSValueCurrentcolor) {\n";
   $code .= $indent . "    applyInherit" . $nameToId{$name} . "(styleResolver);\n";
   $code .= $indent . "    return;\n";
   $code .= $indent . "}\n";
@@ -794,7 +794,7 @@ sub generateValueSetter {
   my $style = "styleResolver.style()";
   my $didCallSetValue = 0;
   if (exists $propertiesWithStyleBuilderOptions{$name}{"AutoFunctions"}) {
-    $setterContent .= $indent . "    if (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueAuto) {\n";
+    $setterContent .= $indent . "    if (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueAuto) {\n";
     $setterContent .= $indent . "        ". getAutoSetter($name, $style) . ";\n";
     $setterContent .= $indent . "        return;\n";
     $setterContent .= $indent . "    }\n";
index 3e06f85..2426cc3 100644 (file)
@@ -4245,7 +4245,7 @@ void CSSParser::parse4ValuesFillPosition(CSSParserValueList& valueList, RefPtr<C
 {
     // [ left | right ] [ <percentage] | <length> ] && [ top | bottom ] [ <percentage> | <length> ]
     // In the case of 4 values <position> requires the second value to be a length or a percentage.
-    if (isFillPositionKeyword(parsedValue2->getValueID()))
+    if (isFillPositionKeyword(parsedValue2->valueID()))
         return;
 
     unsigned cumulativeFlags = 0;
@@ -4254,8 +4254,8 @@ void CSSParser::parse4ValuesFillPosition(CSSParserValueList& valueList, RefPtr<C
     if (!value3)
         return;
 
-    CSSValueID ident1 = parsedValue1->getValueID();
-    CSSValueID ident3 = value3->getValueID();
+    CSSValueID ident1 = parsedValue1->valueID();
+    CSSValueID ident3 = value3->valueID();
 
     if (ident1 == CSSValueCenter)
         return;
@@ -4278,7 +4278,7 @@ void CSSParser::parse4ValuesFillPosition(CSSParserValueList& valueList, RefPtr<C
         return;
 
     // 4th value must be a length or a percentage.
-    if (isFillPositionKeyword(value4->getValueID()))
+    if (isFillPositionKeyword(value4->valueID()))
         return;
 
     value1 = createPrimitiveValuePair(WTFMove(parsedValue1), WTFMove(parsedValue2));
@@ -4303,9 +4303,9 @@ void CSSParser::parse3ValuesFillPosition(CSSParserValueList& valueList, RefPtr<C
     valueList.next();
 
     bool swapNeeded = false;
-    CSSValueID ident1 = parsedValue1->getValueID();
-    CSSValueID ident2 = parsedValue2->getValueID();
-    CSSValueID ident3 = value3->getValueID();
+    CSSValueID ident1 = parsedValue1->valueID();
+    CSSValueID ident2 = parsedValue2->valueID();
+    CSSValueID ident3 = value3->valueID();
 
     CSSValueID firstPositionKeyword;
     CSSValueID secondPositionKeyword;
@@ -4375,8 +4375,8 @@ void CSSParser::parse3ValuesFillPosition(CSSParserValueList& valueList, RefPtr<C
 #ifndef NDEBUG
     CSSPrimitiveValue& first = *value1;
     CSSPrimitiveValue& second = *value2;
-    ident1 = first.getPairValue()->first()->getValueID();
-    ident2 = second.getPairValue()->first()->getValueID();
+    ident1 = first.pairValue()->first()->valueID();
+    ident2 = second.pairValue()->first()->valueID();
     ASSERT(ident1 == CSSValueLeft || ident1 == CSSValueRight);
     ASSERT(ident2 == CSSValueBottom || ident2 == CSSValueTop);
 #endif
@@ -4441,7 +4441,7 @@ void CSSParser::parseFillPosition(CSSParserValueList& valueList, RefPtr<CSSPrimi
     auto parsedValue2 = value2.releaseNonNull();
 
     // Per CSS3 syntax, <position> can't have 'center' as its second keyword as we have more arguments to follow.
-    if (parsedValue2->getValueID() == CSSValueCenter)
+    if (parsedValue2->valueID() == CSSValueCenter)
         return;
 
     if (numberOfValues == 3)
@@ -4532,7 +4532,7 @@ void CSSParser::parseFillRepeat(RefPtr<CSSValue>& value1, RefPtr<CSSValue>& valu
 
     // If only one value was specified, value2 is the same as value1.
     m_implicitShorthand = true;
-    value2 = CSSValuePool::singleton().createIdentifierValue(downcast<CSSPrimitiveValue>(*value1).getValueID());
+    value2 = CSSValuePool::singleton().createIdentifierValue(downcast<CSSPrimitiveValue>(*value1).valueID());
 }
 
 RefPtr<CSSPrimitiveValue> CSSParser::parseFillSize(CSSPropertyID propId, bool& allowComma)
@@ -5274,12 +5274,12 @@ RefPtr<CSSValue> CSSParser::parseGridPosition()
         return nullptr;
 
     // Negative numbers are not allowed for span (but are for <integer>).
-    if (hasSeenSpanKeyword && numericValue && numericValue->getIntValue() < 0)
+    if (hasSeenSpanKeyword && numericValue && numericValue->intValue() < 0)
         return nullptr;
 
     // For the <custom-ident> case.
     if (gridLineName && !numericValue && !hasSeenSpanKeyword)
-        return CSSValuePool::singleton().createValue(gridLineName->getStringValue(), CSSPrimitiveValue::CSS_STRING);
+        return CSSValuePool::singleton().createValue(gridLineName->stringValue(), CSSPrimitiveValue::CSS_STRING);
 
     auto values = CSSValueList::createSpaceSeparated();
     if (hasSeenSpanKeyword)
@@ -5437,7 +5437,7 @@ bool CSSParser::parseGridTemplateRowsAndAreasAndColumns(bool important)
         if (!templateColumns)
             return false;
         // The template-columns <track-list> can't be 'none'.
-        if (templateColumns->isPrimitiveValue() && downcast<CSSPrimitiveValue>(*templateColumns).getValueID() == CSSValueNone)
+        if (templateColumns->isPrimitiveValue() && downcast<CSSPrimitiveValue>(*templateColumns).valueID() == CSSValueNone)
             return false;
     }
 
@@ -5701,7 +5701,7 @@ bool CSSParser::parseGridLineNames(CSSParserValueList& inputList, CSSValueList&
 
 static bool isGridTrackFixedSized(const CSSPrimitiveValue& value)
 {
-    CSSValueID valueID = value.getValueID();
+    CSSValueID valueID = value.valueID();
     if (valueID == CSSValueWebkitMinContent || valueID == CSSValueWebkitMaxContent || valueID == CSSValueAuto || value.isFlex())
         return false;
 
@@ -9178,10 +9178,10 @@ bool CSSParser::parseRadialGradient(CSSParserValueList& valueList, RefPtr<CSSVal
     if (sizeValue && horizontalSize)
         return false;
     // Circles must have 0 or 1 lengths.
-    if (shapeValue && shapeValue->getValueID() == CSSValueCircle && verticalSize)
+    if (shapeValue && shapeValue->valueID() == CSSValueCircle && verticalSize)
         return false;
     // Ellipses must have 0 or 2 length/percentages.
-    if (shapeValue && shapeValue->getValueID() == CSSValueEllipse && horizontalSize && !verticalSize)
+    if (shapeValue && shapeValue->valueID() == CSSValueEllipse && horizontalSize && !verticalSize)
         return false;
     // If there's only one size, it must be a length.
     if (!verticalSize && horizontalSize && horizontalSize->isPercentage())
@@ -9957,7 +9957,7 @@ RefPtr<WebKitCSSFilterValue> CSSParser::parseBuiltinFilterArguments(CSSParserVal
             if (filterType != WebKitCSSFilterValue::SaturateFilterOperation
                 && filterType != WebKitCSSFilterValue::ContrastFilterOperation) {
                 double maxAllowed = primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_PERCENTAGE ? 100.0 : 1.0;
-                if (primitiveValue->getDoubleValue() > maxAllowed)
+                if (primitiveValue->doubleValue() > maxAllowed)
                     return nullptr;
             }
 
index d3a61b4..477b6f6 100644 (file)
@@ -94,11 +94,8 @@ RefPtr<CSSValue> CSSParserValue::createCSSValue()
     if (id)
         return CSSPrimitiveValue::createIdentifier(id);
     
-    if (unit == CSSParserValue::Operator) {
-        auto primitiveValue = CSSPrimitiveValue::createParserOperator(iValue);
-        primitiveValue->setPrimitiveType(CSSPrimitiveValue::CSS_PARSER_OPERATOR);
-        return WTFMove(primitiveValue);
-    }
+    if (unit == CSSParserValue::Operator)
+        return CSSPrimitiveValue::createParserOperator(iValue);
     if (unit == CSSParserValue::Function)
         return CSSFunctionValue::create(function);
     if (unit == CSSParserValue::Variable)
index 206b869..4584724 100644 (file)
@@ -883,7 +883,7 @@ static CSSValue* consumeCounter(CSSParserTokenRange& range, int defaultValue)
             return nullptr;
         int i = defaultValue;
         if (CSSPrimitiveValue* counterValue = consumeInteger(range))
-            i = c