Changeset 272870 in webkit

Timestamp:

Feb 15, 2021 11:24:12 AM (3 years ago)

Author:

weinig@apple.com

Message:

Prepare for adding relative color support
​https://bugs.webkit.org/show_bug.cgi?id=221881

Reviewed by Darin Adler.

Source/WebCore:

In preparation for adding experimental relative color support a little cleanup
is in order. This change:

• Threads a CSSParserContext through the color parsing functions. This will be needed to check if the feature is enabled or not.
• Does a small cleanup of CSSParserContext, sorting features and using the initialization list in the constructor.
• Refactors some of the color parsing helpers to extract more helpers. These clarify the code better and will be shared by the relative parsers.
• Move normalization of components to after parsing to avoid unnecessary work in the case of failure and separate the phases a bit more.
• Removes some unnecessary ValueRangeAll parameters that were already the default.
• Switch HSLA and HWBA to stop storing their components in a 0-1 normalization and instead use values that match the input, 0-360 for hue, and 0-100 for the the remaining two components. This seems more natural, and will simplify future color function work that expects the values in this form.

• css/parser/CSSParser.cpp:

(WebCore::CSSParser::parseColorWorkerSafe):

• css/parser/CSSParserContext.cpp:

(WebCore::shouldEnableLegacyOverflowScrollingTouch):
(WebCore::CSSParserContext::CSSParserContext):
(WebCore::operator==):

• css/parser/CSSParserContext.h:

(WebCore::CSSParserContextHash::hash):

• css/parser/CSSPropertyParser.cpp:

(WebCore::consumeShadow):
(WebCore::consumeCaretColor):
(WebCore::consumeOutlineColor):
(WebCore::consumePaintStroke):
(WebCore::consumeBackgroundComponent):
(WebCore::CSSPropertyParser::parseSingleValue):
(WebCore::CSSPropertyParser::consumeBorder):

• css/parser/CSSPropertyParserHelpers.cpp:

(WebCore::CSSPropertyParserHelpers::consumeOptionalAlpha):
(WebCore::CSSPropertyParserHelpers::consumeHue):
(WebCore::CSSPropertyParserHelpers::normalizeHue):
(WebCore::CSSPropertyParserHelpers::clampRGBComponent):
(WebCore::CSSPropertyParserHelpers::parseRGBParameters):
(WebCore::CSSPropertyParserHelpers::parseHSLParameters):
(WebCore::CSSPropertyParserHelpers::normalizeWhitenessBlackness):
(WebCore::CSSPropertyParserHelpers::parseHWBParameters):
(WebCore::CSSPropertyParserHelpers::parseLabParameters):
(WebCore::CSSPropertyParserHelpers::parseLCHParameters):
(WebCore::CSSPropertyParserHelpers::parseColorFunctionForRGBTypes):
(WebCore::CSSPropertyParserHelpers::parseColorFunctionForLabParameters):
(WebCore::CSSPropertyParserHelpers::parseColorFunctionForXYZParameters):
(WebCore::CSSPropertyParserHelpers::parseColorFunction):
(WebCore::CSSPropertyParserHelpers::consumeColorWorkerSafe):
(WebCore::CSSPropertyParserHelpers::consumeColor):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientStopColor):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientColorStop):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradient):
(WebCore::CSSPropertyParserHelpers::consumeGradientColorStops):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedRadialGradient):
(WebCore::CSSPropertyParserHelpers::consumeRadialGradient):
(WebCore::CSSPropertyParserHelpers::consumeLinearGradient):
(WebCore::CSSPropertyParserHelpers::consumeConicGradient):
(WebCore::CSSPropertyParserHelpers::consumeImageOrNone):
(WebCore::CSSPropertyParserHelpers::consumeCrossFade):
(WebCore::CSSPropertyParserHelpers::consumeGeneratedImage):
(WebCore::CSSPropertyParserHelpers::consumeFilterFunction):
(WebCore::CSSPropertyParserHelpers::consumeSingleShadow):
(WebCore::CSSPropertyParserHelpers::consumeImage):
(WebCore::CSSPropertyParserHelpers::parseOptionalAlpha): Deleted.

• css/parser/CSSPropertyParserHelpers.h:

(WebCore::CSSPropertyParserHelpers::consumeImage):

• editing/cocoa/DataDetection.mm:

(WebCore::DataDetection::detectContentInRange):

• platform/graphics/ColorConversion.cpp:

(WebCore::calculateHSLHue):
(WebCore::SRGBA<float>>::convert):
(WebCore::HSLA<float>>::convert):
(WebCore::HWBA<float>>::convert):

• platform/graphics/ColorModels.h:
• rendering/RenderTheme.cpp:

(WebCore::RenderTheme::datePlaceholderTextColor const):

Tools:

• TestWebKitAPI/Tests/WebCore/ColorTests.cpp:

Update HSLA tests to account for HSLA now using 0-360, 0-100, 0-100 bounds rather than 0-1, 0-1, 0-1.

Location:

trunk

Files:

• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/css/parser/CSSParser.cpp (modified) (1 diff)
• Source/WebCore/css/parser/CSSParserContext.cpp (modified) (3 diffs)
• Source/WebCore/css/parser/CSSParserContext.h (modified) (4 diffs)
• Source/WebCore/css/parser/CSSPropertyParser.cpp (modified) (13 diffs)
• Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp (modified) (44 diffs)
• Source/WebCore/css/parser/CSSPropertyParserHelpers.h (modified) (3 diffs)
• Source/WebCore/editing/cocoa/DataDetection.mm (modified) (1 diff)
• Source/WebCore/platform/graphics/ColorConversion.cpp (modified) (6 diffs)
• Source/WebCore/platform/graphics/ColorModels.h (modified) (2 diffs)
• Source/WebCore/rendering/RenderTheme.cpp (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/Tests/WebCore/ColorTests.cpp (modified) (8 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2021-02-15  Sam Weinig  <weinig@apple.com>
+
+        Prepare for adding relative color support
+        https://bugs.webkit.org/show_bug.cgi?id=221881
+
+        Reviewed by Darin Adler.
+
+        In preparation for adding experimental relative color support a little cleanup
+        is in order. This change:
+        
+        - Threads a CSSParserContext through the color parsing functions. This will be
+          needed to check if the feature is enabled or not.
+        - Does a small cleanup of CSSParserContext, sorting features and using the initialization
+          list in the constructor.
+        - Refactors some of the color parsing helpers to extract more helpers. These clarify
+          the code better and will be shared by the relative parsers.
+        - Move normalization of components to after parsing to avoid unnecessary work
+          in the case of failure and separate the phases a bit more.
+        - Removes some unnecessary ValueRangeAll parameters that were already the default.
+        - Switch HSLA and HWBA to stop storing their components in a 0-1 normalization
+          and instead use values that match the input, 0-360 for hue, and 0-100 for the
+          the remaining two components. This seems more natural, and will simplify
+          future color function work that expects the values in this form.
+
+        * css/parser/CSSParser.cpp:
+        (WebCore::CSSParser::parseColorWorkerSafe):
+        * css/parser/CSSParserContext.cpp:
+        (WebCore::shouldEnableLegacyOverflowScrollingTouch):
+        (WebCore::CSSParserContext::CSSParserContext):
+        (WebCore::operator==):
+        * css/parser/CSSParserContext.h:
+        (WebCore::CSSParserContextHash::hash):
+        * css/parser/CSSPropertyParser.cpp:
+        (WebCore::consumeShadow):
+        (WebCore::consumeCaretColor):
+        (WebCore::consumeOutlineColor):
+        (WebCore::consumePaintStroke):
+        (WebCore::consumeBackgroundComponent):
+        (WebCore::CSSPropertyParser::parseSingleValue):
+        (WebCore::CSSPropertyParser::consumeBorder):
+        * css/parser/CSSPropertyParserHelpers.cpp:
+        (WebCore::CSSPropertyParserHelpers::consumeOptionalAlpha):
+        (WebCore::CSSPropertyParserHelpers::consumeHue):
+        (WebCore::CSSPropertyParserHelpers::normalizeHue):
+        (WebCore::CSSPropertyParserHelpers::clampRGBComponent):
+        (WebCore::CSSPropertyParserHelpers::parseRGBParameters):
+        (WebCore::CSSPropertyParserHelpers::parseHSLParameters):
+        (WebCore::CSSPropertyParserHelpers::normalizeWhitenessBlackness):
+        (WebCore::CSSPropertyParserHelpers::parseHWBParameters):
+        (WebCore::CSSPropertyParserHelpers::parseLabParameters):
+        (WebCore::CSSPropertyParserHelpers::parseLCHParameters):
+        (WebCore::CSSPropertyParserHelpers::parseColorFunctionForRGBTypes):
+        (WebCore::CSSPropertyParserHelpers::parseColorFunctionForLabParameters):
+        (WebCore::CSSPropertyParserHelpers::parseColorFunctionForXYZParameters):
+        (WebCore::CSSPropertyParserHelpers::parseColorFunction):
+        (WebCore::CSSPropertyParserHelpers::consumeColorWorkerSafe):
+        (WebCore::CSSPropertyParserHelpers::consumeColor):
+        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientStopColor):
+        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientColorStop):
+        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradient):
+        (WebCore::CSSPropertyParserHelpers::consumeGradientColorStops):
+        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedRadialGradient):
+        (WebCore::CSSPropertyParserHelpers::consumeRadialGradient):
+        (WebCore::CSSPropertyParserHelpers::consumeLinearGradient):
+        (WebCore::CSSPropertyParserHelpers::consumeConicGradient):
+        (WebCore::CSSPropertyParserHelpers::consumeImageOrNone):
+        (WebCore::CSSPropertyParserHelpers::consumeCrossFade):
+        (WebCore::CSSPropertyParserHelpers::consumeGeneratedImage):
+        (WebCore::CSSPropertyParserHelpers::consumeFilterFunction):
+        (WebCore::CSSPropertyParserHelpers::consumeSingleShadow):
+        (WebCore::CSSPropertyParserHelpers::consumeImage):
+        (WebCore::CSSPropertyParserHelpers::parseOptionalAlpha): Deleted.
+        * css/parser/CSSPropertyParserHelpers.h:
+        (WebCore::CSSPropertyParserHelpers::consumeImage):
+        * editing/cocoa/DataDetection.mm:
+        (WebCore::DataDetection::detectContentInRange):
+        * platform/graphics/ColorConversion.cpp:
+        (WebCore::calculateHSLHue):
+        (WebCore::SRGBA<float>>::convert):
+        (WebCore::HSLA<float>>::convert):
+        (WebCore::HWBA<float>>::convert):
+        * platform/graphics/ColorModels.h:
+        * rendering/RenderTheme.cpp:
+        (WebCore::RenderTheme::datePlaceholderTextColor const):
+
 2021-02-15  Antoine Quint  <graouts@webkit.org>
 

trunk/Source/WebCore/css/parser/CSSParser.cpp

@@ -118 +118 @@
     range.consumeWhitespace();
 
-    return CSSPropertyParserHelpers::consumeColorWorkerSafe(range, HTMLStandardMode);
+    return CSSPropertyParserHelpers::consumeColorWorkerSafe(range, strictCSSParserContext());
 }
 

trunk/Source/WebCore/css/parser/CSSParserContext.cpp

@@ -1 +1 @@
 /*
- * Copyright (C) 2018-2020 Apple Inc. All rights reserved.
+ * Copyright (C) 2018-2021 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -48 +48 @@
 }
 
-CSSParserContext::CSSParserContext(const Document& document, const URL& sheetBaseURL, const String& charset)
-    : baseURL(sheetBaseURL.isNull() ? document.baseURL() : sheetBaseURL)
-    , charset(charset)
-    , mode(document.inQuirksMode() ? HTMLQuirksMode : HTMLStandardMode)
-    , isHTMLDocument(document.isHTMLDocument())
-    , hasDocumentSecurityOrigin(sheetBaseURL.isNull() || document.securityOrigin().canRequest(baseURL))
+#if ENABLE(OVERFLOW_SCROLLING_TOUCH)
+static bool shouldEnableLegacyOverflowScrollingTouch(const Document& document)
 {
-    enforcesCSSMIMETypeInNoQuirksMode = document.settings().enforceCSSMIMETypeInNoQuirksMode();
-    useLegacyBackgroundSizeShorthandBehavior = document.settings().useLegacyBackgroundSizeShorthandBehavior();
-#if ENABLE(TEXT_AUTOSIZING)
-    textAutosizingEnabled = document.settings().textAutosizingEnabled();
-#endif
-#if ENABLE(OVERFLOW_SCROLLING_TOUCH)
-    legacyOverflowScrollingTouchEnabled = document.settings().legacyOverflowScrollingTouchEnabled();
     // The legacy -webkit-overflow-scrolling: touch behavior may have been disabled through the website policy,
     // in that case we want to disable the legacy behavior regardless of what the setting says.
     if (auto* loader = document.loader()) {
         if (loader->legacyOverflowScrollingTouchPolicy() == LegacyOverflowScrollingTouchPolicy::Disable)
-            legacyOverflowScrollingTouchEnabled = false;
+            return false;
     }
+    return document.settings().legacyOverflowScrollingTouchEnabled();
+}
 #endif
-    springTimingFunctionEnabled = document.settings().springTimingFunctionEnabled();
-    constantPropertiesEnabled = document.settings().constantPropertiesEnabled();
-    colorFilterEnabled = document.settings().colorFilterEnabled();
+
+CSSParserContext::CSSParserContext(const Document& document, const URL& sheetBaseURL, const String& charset)
+    : baseURL { sheetBaseURL.isNull() ? document.baseURL() : sheetBaseURL }
+    , charset { charset }
+    , mode { document.inQuirksMode() ? HTMLQuirksMode : HTMLStandardMode }
+    , isHTMLDocument { document.isHTMLDocument() }
+    , hasDocumentSecurityOrigin { sheetBaseURL.isNull() || document.securityOrigin().canRequest(baseURL) }
+    , useSystemAppearance { document.page() ? document.page()->useSystemAppearance() : false }
+    , aspectRatioEnabled { document.settings().aspectRatioEnabled() }
+    , colorFilterEnabled { document.settings().colorFilterEnabled() }
+    , constantPropertiesEnabled { document.settings().constantPropertiesEnabled() }
+    , deferredCSSParserEnabled { document.settings().deferredCSSParserEnabled() }
+    , enforcesCSSMIMETypeInNoQuirksMode { document.settings().enforceCSSMIMETypeInNoQuirksMode() }
+    , individualTransformPropertiesEnabled { document.settings().cssIndividualTransformPropertiesEnabled() }
+#if ENABLE(OVERFLOW_SCROLLING_TOUCH)
+    , legacyOverflowScrollingTouchEnabled { shouldEnableLegacyOverflowScrollingTouch(document) }
+#endif
+    , overscrollBehaviorEnabled { document.settings().overscrollBehaviorEnabled() }
+    , scrollBehaviorEnabled { document.settings().CSSOMViewSmoothScrollingEnabled() }
+    , springTimingFunctionEnabled { document.settings().springTimingFunctionEnabled() }
+#if ENABLE(TEXT_AUTOSIZING)
+    , textAutosizingEnabled { document.settings().textAutosizingEnabled() }
+#endif
+    , useLegacyBackgroundSizeShorthandBehavior { document.settings().useLegacyBackgroundSizeShorthandBehavior() }
 #if ENABLE(ATTACHMENT_ELEMENT)
-    attachmentEnabled = RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled();
+    , attachmentEnabled { RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled() }
 #endif
-    deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();
-    scrollBehaviorEnabled = document.settings().CSSOMViewSmoothScrollingEnabled();
-    overscrollBehaviorEnabled = document.settings().overscrollBehaviorEnabled();
-    useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;
-    individualTransformPropertiesEnabled = document.settings().cssIndividualTransformPropertiesEnabled();
-    aspectRatioEnabled = document.settings().aspectRatioEnabled();
+{
 }
 
@@ -88 +95 @@
         && a.charset == b.charset
         && a.mode == b.mode
+        && a.enclosingRuleType == b.enclosingRuleType
         && a.isHTMLDocument == b.isHTMLDocument
+        && a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin
+        && a.isContentOpaque == b.isContentOpaque
+        && a.useSystemAppearance == b.useSystemAppearance
+        && a.aspectRatioEnabled == b.aspectRatioEnabled
+        && a.colorFilterEnabled == b.colorFilterEnabled
+        && a.constantPropertiesEnabled == b.constantPropertiesEnabled
+        && a.deferredCSSParserEnabled == b.deferredCSSParserEnabled
+        && a.enforcesCSSMIMETypeInNoQuirksMode == b.enforcesCSSMIMETypeInNoQuirksMode
+        && a.individualTransformPropertiesEnabled == b.individualTransformPropertiesEnabled
+#if ENABLE(OVERFLOW_SCROLLING_TOUCH)
+        && a.legacyOverflowScrollingTouchEnabled == b.legacyOverflowScrollingTouchEnabled
+#endif
+        && a.overscrollBehaviorEnabled == b.overscrollBehaviorEnabled
+        && a.scrollBehaviorEnabled == b.scrollBehaviorEnabled
+        && a.springTimingFunctionEnabled == b.springTimingFunctionEnabled
 #if ENABLE(TEXT_AUTOSIZING)
         && a.textAutosizingEnabled == b.textAutosizingEnabled
 #endif
-#if ENABLE(OVERFLOW_SCROLLING_TOUCH)
-        && a.legacyOverflowScrollingTouchEnabled == b.legacyOverflowScrollingTouchEnabled
-#endif
-        && a.enforcesCSSMIMETypeInNoQuirksMode == b.enforcesCSSMIMETypeInNoQuirksMode
         && a.useLegacyBackgroundSizeShorthandBehavior == b.useLegacyBackgroundSizeShorthandBehavior
-        && a.springTimingFunctionEnabled == b.springTimingFunctionEnabled
-        && a.constantPropertiesEnabled == b.constantPropertiesEnabled
-        && a.colorFilterEnabled == b.colorFilterEnabled
 #if ENABLE(ATTACHMENT_ELEMENT)
         && a.attachmentEnabled == b.attachmentEnabled
 #endif
-        && a.deferredCSSParserEnabled == b.deferredCSSParserEnabled
-        && a.scrollBehaviorEnabled == b.scrollBehaviorEnabled
-        && a.individualTransformPropertiesEnabled == b.individualTransformPropertiesEnabled
-        && a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin
-        && a.useSystemAppearance == b.useSystemAppearance
-        && a.aspectRatioEnabled == b.aspectRatioEnabled
-        && a.overscrollBehaviorEnabled == b.overscrollBehaviorEnabled;
+    ;
 }
 

trunk/Source/WebCore/css/parser/CSSParserContext.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2018-2020 Apple Inc. All rights reserved.
+ * Copyright (C) 2018-2021 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -42 +42 @@
     WTF_MAKE_FAST_ALLOCATED;
 public:
-
     CSSParserContext(CSSParserMode, const URL& baseURL = URL());
     WEBCORE_EXPORT CSSParserContext(const Document&, const URL& baseURL = URL(), const String& charset = emptyString());
@@ -51 +50 @@
     Optional<StyleRuleType> enclosingRuleType;
     bool isHTMLDocument { false };
+
+    // This is only needed to support getMatchedCSSRules.
+    bool hasDocumentSecurityOrigin { false };
+
+    bool isContentOpaque { false };
+    bool useSystemAppearance { false };
+
+    // Settings.
+    bool aspectRatioEnabled { false };
+    bool colorFilterEnabled { false };
+    bool constantPropertiesEnabled { false };
+    bool deferredCSSParserEnabled { false };
+    bool enforcesCSSMIMETypeInNoQuirksMode { true };
+    bool individualTransformPropertiesEnabled { false };
+#if ENABLE(OVERFLOW_SCROLLING_TOUCH)
+    bool legacyOverflowScrollingTouchEnabled { false };
+#endif
+    bool overscrollBehaviorEnabled { false };
+    bool scrollBehaviorEnabled { false };
+    bool springTimingFunctionEnabled { false };
 #if ENABLE(TEXT_AUTOSIZING)
     bool textAutosizingEnabled { false };
 #endif
-#if ENABLE(OVERFLOW_SCROLLING_TOUCH)
-    bool legacyOverflowScrollingTouchEnabled { false };
-#endif
-    bool enforcesCSSMIMETypeInNoQuirksMode { true };
     bool useLegacyBackgroundSizeShorthandBehavior { false };
-    bool springTimingFunctionEnabled { false };
-    bool constantPropertiesEnabled { false };
-    bool colorFilterEnabled { false };
+
+    // RuntimeEnabledFeatures.
 #if ENABLE(ATTACHMENT_ELEMENT)
     bool attachmentEnabled { false };
 #endif
-    bool deferredCSSParserEnabled { false };
-    bool scrollBehaviorEnabled { false };
-    bool individualTransformPropertiesEnabled { false };
-
-    bool overscrollBehaviorEnabled { false };
-    
-    // This is only needed to support getMatchedCSSRules.
-    bool hasDocumentSecurityOrigin { false };
-    
-    bool useSystemAppearance { false };
 
     URL completeURL(const String& url) const;
-
-    bool isContentOpaque { false };
-
-    bool aspectRatioEnabled { false };
 };
 
@@ -91 +91 @@
     static unsigned hash(const CSSParserContext& key)
     {
+        // FIXME: Convert this to use WTF::Hasher.
+
         unsigned hash = 0;
         if (!key.baseURL.isNull())

trunk/Source/WebCore/css/parser/CSSPropertyParser.cpp

@@ -1727 +1727 @@
 }
 
-static RefPtr<CSSValue> consumeShadow(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool isBoxShadowProperty)
+static RefPtr<CSSValue> consumeShadow(CSSParserTokenRange& range, const CSSParserContext& context, bool isBoxShadowProperty)
 {
     if (range.peek().id() == CSSValueNone)
@@ -1734 +1734 @@
     RefPtr<CSSValueList> shadowValueList = CSSValueList::createCommaSeparated();
     do {
-        if (RefPtr<CSSShadowValue> shadowValue = consumeSingleShadow(range, cssParserMode, isBoxShadowProperty, isBoxShadowProperty))
-            shadowValueList->append(*shadowValue);
+        if (auto shadowValue = consumeSingleShadow(range, context, isBoxShadowProperty, isBoxShadowProperty))
+            shadowValueList->append(shadowValue.releaseNonNull());
         else
             return nullptr;
@@ -1814 +1814 @@
 }
 
-static RefPtr<CSSPrimitiveValue> consumeCaretColor(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static RefPtr<CSSPrimitiveValue> consumeCaretColor(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     if (range.peek().id() == CSSValueAuto)
         return consumeIdent(range);
-    return consumeColor(range, cssParserMode);
-}
-
-static RefPtr<CSSValue> consumeOutlineColor(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+    return consumeColor(range, context);
+}
+
+static RefPtr<CSSValue> consumeOutlineColor(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     // Allow the special focus color even in HTML Standard parsing mode.
     if (range.peek().id() == CSSValueWebkitFocusRingColor)
         return consumeIdent(range);
-    return consumeColor(range, cssParserMode);
+    return consumeColor(range, context);
 }
 
@@ -2229 +2229 @@
 }
 
-static RefPtr<CSSValue> consumePaintStroke(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static RefPtr<CSSValue> consumePaintStroke(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     if (range.peek().id() == CSSValueNone)
@@ -2239 +2239 @@
             parsedValue = consumeIdent(range);
         else
-            parsedValue = consumeColor(range, cssParserMode);
+            parsedValue = consumeColor(range, context);
         if (parsedValue) {
             RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
@@ -2248 +2248 @@
         return url;
     }
-    return consumeColor(range, cssParserMode);
+    return consumeColor(range, context);
 }
 
@@ -3259 +3259 @@
         return consumeBackgroundSize(property, range, context.mode);
     case CSSPropertyBackgroundColor:
-        return consumeColor(range, context.mode);
+        return consumeColor(range, context);
     default:
         break;
@@ -4242 +4242 @@
         return consumePositiveInteger(m_range);
     case CSSPropertyTextDecorationColor:
-        return consumeColor(m_range, m_context.mode);
+        return consumeColor(m_range, m_context);
     case CSSPropertyTextDecorationSkip:
         return consumeTextDecorationSkip(m_range);
@@ -4262 +4262 @@
     case CSSPropertyLightingColor:
     case CSSPropertyColumnRuleColor:
-        return consumeColor(m_range, m_context.mode);
+        return consumeColor(m_range, m_context);
     case CSSPropertyCaretColor:
-        return consumeCaretColor(m_range, m_context.mode);
+        return consumeCaretColor(m_range, m_context);
     case CSSPropertyColor:
     case CSSPropertyBackgroundColor:
-        return consumeColor(m_range, m_context.mode, inQuirksMode());
+        return consumeColor(m_range, m_context, inQuirksMode());
     case CSSPropertyBorderInlineStartWidth:
     case CSSPropertyBorderInlineEndWidth:
@@ -4279 +4279 @@
         bool allowQuirkyColors = inQuirksMode()
             && (currentShorthand == CSSPropertyInvalid || currentShorthand == CSSPropertyBorderColor);
-        return consumeColor(m_range, m_context.mode, allowQuirkyColors);
+        return consumeColor(m_range, m_context, allowQuirkyColors);
     }
     case CSSPropertyBorderBottomWidth:
@@ -4295 +4295 @@
     case CSSPropertyBoxShadow:
     case CSSPropertyWebkitBoxShadow:
-        return consumeShadow(m_range, m_context.mode, property == CSSPropertyBoxShadow || property == CSSPropertyWebkitBoxShadow);
+        return consumeShadow(m_range, m_context, property == CSSPropertyBoxShadow || property == CSSPropertyWebkitBoxShadow);
     case CSSPropertyFilter:
 #if ENABLE(FILTERS_LEVEL_2)
@@ -4343 +4343 @@
     case CSSPropertyFill:
     case CSSPropertyStroke:
-        return consumePaintStroke(m_range, m_context.mode);
+        return consumePaintStroke(m_range, m_context);
     case CSSPropertyGlyphOrientationVertical:
     case CSSPropertyGlyphOrientationHorizontal:
@@ -5094 +5094 @@
         }
         if (!color) {
-            color = consumeColor(m_range, m_context.mode);
+            color = consumeColor(m_range, m_context);
             if (color)
                 continue;

trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp

@@ -691 +691 @@
 }
 
-static uint8_t clampRGBComponent(double value, bool isPercentage)
-{
-    if (isPercentage)
+static Optional<double> consumeOptionalAlpha(CSSParserTokenRange& range)
+{
+    if (!consumeSlashIncludingWhitespace(range))
+        return 1.0;
+
+    if (auto alphaParameter = consumeNumberOrPercentDividedBy100Raw(range))
+        return clampTo(*alphaParameter, 0.0, 1.0);
+
+    return WTF::nullopt;
+}
+
+static Optional<double> consumeHue(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    if (auto angle = consumeAngleRaw(range, context.mode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Forbid))
+        return CSSPrimitiveValue::computeDegrees(angle->type, angle->value);
+
+    return consumeNumberRaw(range);
+}
+
+static double normalizeHue(double hue)
+{
+    return std::fmod(std::fmod(hue, 360.0) + 360.0, 360.0);
+}
+
+enum class RGBComponentType { Number, Percentage };
+
+static uint8_t clampRGBComponent(double value, RGBComponentType componentType)
+{
+    if (componentType == RGBComponentType::Percentage)
         value = value / 100.0 * 255.0;
 
@@ -699 +725 @@
 }
 
-static Color parseRGBParameters(CSSParserTokenRange& range)
+enum class RGBOrHSLSeparatorSyntax { Commas, WhitespaceSlash };
+
+static bool consumeRGBOrHSLSeparator(CSSParserTokenRange& args, RGBOrHSLSeparatorSyntax syntax)
+{
+    if (syntax == RGBOrHSLSeparatorSyntax::Commas)
+        return consumeCommaIncludingWhitespace(args);
+    return true;
+}
+
+static bool consumeRGBOrHSLAlphaSeparator(CSSParserTokenRange& args, RGBOrHSLSeparatorSyntax syntax)
+{
+    if (syntax == RGBOrHSLSeparatorSyntax::Commas)
+        return consumeCommaIncludingWhitespace(args);
+    return consumeSlashIncludingWhitespace(args);
+}
+
+static Optional<double> consumeRGBOrHSLOptionalAlpha(CSSParserTokenRange& args, RGBOrHSLSeparatorSyntax syntax)
+{
+    if (!consumeRGBOrHSLAlphaSeparator(args, syntax))
+        return 1.0;
+
+    return consumeNumberOrPercentDividedBy100Raw(args);
+}
+
+static Color parseRGBParameters(CSSParserTokenRange& range, const CSSParserContext&)
 {
     ASSERT(range.peek().functionId() == CSSValueRgb || range.peek().functionId() == CSSValueRgba);
     auto args = consumeFunction(range);
 
-    bool isPercentage = false;
-    double colorParameter;
-    if (auto number = consumeNumberRaw(args))
-        colorParameter = *number;
-    else if (auto percent = consumePercentRaw(args)) {
-        colorParameter = *percent;
-        isPercentage = true;
-    } else
-        return { };
-
-    enum class ColorSyntax {
-        Commas,
-        WhitespaceSlash,
+    struct InitialComponent {
+        double value;
+        RGBComponentType type;
     };
 
-    ColorSyntax syntax = ColorSyntax::Commas;
-    auto consumeSeparator = [&] {
-        if (syntax == ColorSyntax::Commas)
-            return consumeCommaIncludingWhitespace(args);
-        
-        return true;
+    auto consumeInitialComponent = [](auto& args) -> Optional<InitialComponent> {
+        if (auto number = consumeNumberRaw(args))
+            return { { *number, RGBComponentType::Number } };
+        if (auto percent = consumePercentRaw(args))
+            return { { *percent, RGBComponentType::Percentage } };
+        return WTF::nullopt;
     };
 
-    uint8_t colorArray[3];
-    colorArray[0] = clampRGBComponent(colorParameter, isPercentage);
-    for (int i = 1; i < 3; i++) {
-        if (i == 1)
-            syntax = consumeCommaIncludingWhitespace(args) ? ColorSyntax::Commas : ColorSyntax::WhitespaceSlash;
-        else if (!consumeSeparator())
-            return { };
-
-        if (isPercentage) {
-            auto percent = consumePercentRaw(args);
-            if (!percent)
-                return { };
-            colorArray[i] = clampRGBComponent(*percent, true);
-        } else {
-            auto number = consumeNumberRaw(args);
-            if (!number)
-                return { };
-            colorArray[i] = clampRGBComponent(*number, false);
-        }
-    }
-
-    // Historically, alpha was only parsed for rgba(), but css-color-4 specifies that rgba() is a simple alias for rgb().
-    auto consumeAlphaSeparator = [&] {
-        if (syntax == ColorSyntax::Commas)
-            return consumeCommaIncludingWhitespace(args);
-        
-        return consumeSlashIncludingWhitespace(args);
+    auto consumeComponent = [](auto& args, auto componentType) {
+        switch (componentType) {
+        case RGBComponentType::Percentage:
+            return consumePercentRaw(args);
+        case RGBComponentType::Number:
+            return consumeNumberRaw(args);
+        }
     };
 
-    uint8_t alphaComponent = 255;
-    if (consumeAlphaSeparator()) {
-        auto alpha = consumeNumberOrPercentDividedBy100Raw(args);
-        if (!alpha)
-            return { };
-        alphaComponent = convertFloatAlphaTo<uint8_t>(*alpha);
-    }
+    auto initialComponent = consumeInitialComponent(args);
+    if (!initialComponent)
+        return { };
+
+    auto componentType = initialComponent->type;
+    auto red = initialComponent->value;
+
+    auto syntax = consumeCommaIncludingWhitespace(args) ? RGBOrHSLSeparatorSyntax::Commas : RGBOrHSLSeparatorSyntax::WhitespaceSlash;
+    
+    auto green = consumeComponent(args, componentType);
+    if (!green)
+        return { };
+
+    if (!consumeRGBOrHSLSeparator(args, syntax))
+        return { };
+
+    auto blue = consumeComponent(args, componentType);
+    if (!blue)
+        return { };
+
+    auto alpha = consumeRGBOrHSLOptionalAlpha(args, syntax);
+    if (!alpha)
+        return { };
 
     if (!args.atEnd())
         return { };
 
-    return SRGBA<uint8_t> { colorArray[0], colorArray[1], colorArray[2], alphaComponent };
-}
-
-static Color parseHSLParameters(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+    auto normalizedRed = clampRGBComponent(red, componentType);
+    auto normalizedGreen = clampRGBComponent(*green, componentType);
+    auto normalizedBlue = clampRGBComponent(*blue, componentType);
+    auto normalizedAlpha = convertFloatAlphaTo<uint8_t>(*alpha);
+
+    return SRGBA<uint8_t> { normalizedRed, normalizedGreen, normalizedBlue, normalizedAlpha };
+}
+
+static Color parseHSLParameters(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     ASSERT(range.peek().functionId() == CSSValueHsl || range.peek().functionId() == CSSValueHsla);
     auto args = consumeFunction(range);
 
-    double hueAngleInDegrees;
-    if (auto angle = consumeAngleRaw(args, cssParserMode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Forbid))
-        hueAngleInDegrees = CSSPrimitiveValue::computeDegrees(angle->type, angle->value);
-    else if (auto number = consumeNumberRaw(args))
-        hueAngleInDegrees = *number;
-    else
-        return { };
-
-    double colorArray[3];
-    colorArray[0] = fmod(fmod(hueAngleInDegrees, 360.0) + 360.0, 360.0) / 360.0;
-
-    bool requiresCommas = false;
-    for (int i = 1; i < 3; i++) {
-        if (consumeCommaIncludingWhitespace(args)) {
-            if (i != 1 && !requiresCommas)
-                return { };
-            requiresCommas = true;
-        } else if (requiresCommas || args.atEnd() || (&args.peek() - 1)->type() != WhitespaceToken)
-            return { };
-        auto percent = consumePercentRaw(args);
-        if (!percent)
-            return { };
-        colorArray[i] = clampTo<double>(*percent, 0.0, 100.0) / 100.0; // Needs to be value between 0 and 1.0.
-    }
-
-    bool commaConsumed = consumeCommaIncludingWhitespace(args);
-    bool slashConsumed = consumeSlashIncludingWhitespace(args);
-    if ((commaConsumed && !requiresCommas) || (slashConsumed && requiresCommas))
-        return { };
-
-    double alpha = 1.0;
-    if (commaConsumed || slashConsumed) {
-        auto alphaParameter = consumeNumberOrPercentDividedBy100Raw(args);
-        if (!alphaParameter)
-            return { };
-        alpha = clampTo<double>(*alphaParameter, 0.0, 1.0);
-    }
+    auto hue = consumeHue(args, context);
+    if (!hue)
+        return { };
+
+    auto syntax = consumeCommaIncludingWhitespace(args) ? RGBOrHSLSeparatorSyntax::Commas : RGBOrHSLSeparatorSyntax::WhitespaceSlash;
+
+    auto saturation = consumePercentRaw(args);
+    if (!saturation)
+        return { };
+
+    if (!consumeRGBOrHSLSeparator(args, syntax))
+        return { };
+
+    auto lightness = consumePercentRaw(args);
+    if (!lightness)
+        return { };
+
+    auto alpha = consumeRGBOrHSLOptionalAlpha(args, syntax);
+    if (!alpha)
+        return { };
 
     if (!args.atEnd())
         return { };
 
-    return convertColor<SRGBA<uint8_t>>(HSLA<float> { static_cast<float>(colorArray[0]), static_cast<float>(colorArray[1]), static_cast<float>(colorArray[2]), static_cast<float>(alpha) });
-}
-
-static Optional<float> parseOptionalAlpha(CSSParserTokenRange& range)
-{
-    if (!consumeSlashIncludingWhitespace(range))
-        return 1.0f;
-
-    if (auto alphaParameter = consumeNumberOrPercentDividedBy100Raw(range))
-        return clampTo<float>(*alphaParameter, 0.0, 1.0);
-
-    return WTF::nullopt;
-}
-
-static Color parseHWBParameters(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    ASSERT(range.peek().functionId() == CSSValueHwb);
-    auto args = consumeFunction(range);
-
-    double hueAngleInDegrees;
-    if (auto angle = consumeAngleRaw(args, cssParserMode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Forbid))
-        hueAngleInDegrees = CSSPrimitiveValue::computeDegrees(angle->type, angle->value);
-    else if (auto number = consumeNumberRaw(args))
-        hueAngleInDegrees = *number;
-    else
-        return { };
-
-    auto whiteness = consumePercentRaw(args, ValueRangeAll);
-    if (!whiteness)
-        return { };
-
-    auto blackness = consumePercentRaw(args, ValueRangeAll);
-    if (!blackness)
-        return { };
-
-    auto alpha = parseOptionalAlpha(args);
-    if (!alpha)
-        return { };
-
-    if (!args.atEnd())
-        return { };
-
-    // Normalize hue.
-
-    hueAngleInDegrees = std::fmod(hueAngleInDegrees, 360.0);
-    if (hueAngleInDegrees < 0.0)
-        hueAngleInDegrees += 360.0;
-    
-    // Convert angle to normalized form from 0 - 1.
-    auto normalizedHue = hueAngleInDegrees / 360.0;
-
-    // Normalize whiteness/blackness.
+    auto normalizedHue = normalizeHue(*hue);
+    auto normalizedSaturation = clampTo<double>(*saturation, 0.0, 100.0);
+    auto normalizedLightness = clampTo<double>(*lightness, 0.0, 100.0);
+    auto normalizedAlpha = clampTo<double>(*alpha, 0.0, 1.0);
+
+    return convertColor<SRGBA<uint8_t>>(HSLA<float> { static_cast<float>(normalizedHue), static_cast<float>(normalizedSaturation), static_cast<float>(normalizedLightness), static_cast<float>(normalizedAlpha) });
+}
+
+struct WhitenessBlackness {
+    double whiteness;
+    double blackness;
+};
+static WhitenessBlackness normalizeWhitenessBlackness(double whiteness, double blackness)
+{
+    WhitenessBlackness result;
 
     //   Values outside of these ranges are not invalid, but are clamped to the
     //   ranges defined here at computed-value time.
-    auto nomalizedWhiteness = clampTo<double>(*whiteness, 0, 100);
-    auto nomalizedBlackness = clampTo<double>(*blackness, 0, 100);
+    result.whiteness = clampTo<double>(whiteness, 0, 100);
+    result.blackness = clampTo<double>(blackness, 0, 100);
 
     //   If the sum of these two arguments is greater than 100%, then at
     //   computed-value time they are further normalized to add up to 100%, with
     //   the same relative ratio.
-    if (auto sum = nomalizedWhiteness + nomalizedBlackness; sum >= 100) {
-        nomalizedWhiteness *= 100.0 / sum;
-        nomalizedBlackness *= 100.0 / sum;
-    }
-
-    // Convert to normalized form from 0 - 1.
-    nomalizedWhiteness /= 100.0;
-    nomalizedBlackness /= 100.0;
-
-    return convertColor<SRGBA<uint8_t>>(HWBA<float> { static_cast<float>(normalizedHue), static_cast<float>(nomalizedWhiteness), static_cast<float>(nomalizedBlackness), static_cast<float>(*alpha) });
-}
-
-static Color parseLabParameters(CSSParserTokenRange& range)
+    if (auto sum = result.whiteness + result.blackness; sum >= 100) {
+        result.whiteness *= 100.0 / sum;
+        result.blackness *= 100.0 / sum;
+    }
+
+    return result;
+}
+
+static Color parseHWBParameters(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    ASSERT(range.peek().functionId() == CSSValueHwb);
+    auto args = consumeFunction(range);
+
+    auto hue = consumeHue(args, context);
+    if (!hue)
+        return { };
+
+    auto whiteness = consumePercentRaw(args);
+    if (!whiteness)
+        return { };
+
+    auto blackness = consumePercentRaw(args);
+    if (!blackness)
+        return { };
+
+    auto alpha = consumeOptionalAlpha(args);
+    if (!alpha)
+        return { };
+
+    if (!args.atEnd())
+        return { };
+
+    auto normalizedHue = normalizeHue(*hue);
+    auto [normalizedWhitness, normalizedBlackness] = normalizeWhitenessBlackness(*whiteness, *blackness);
+
+    return convertColor<SRGBA<uint8_t>>(HWBA<float> { static_cast<float>(normalizedHue), static_cast<float>(normalizedWhitness), static_cast<float>(normalizedBlackness), static_cast<float>(*alpha) });
+}
+
+static Color parseLabParameters(CSSParserTokenRange& range, const CSSParserContext&)
 {
     ASSERT(range.peek().functionId() == CSSValueLab);
     auto args = consumeFunction(range);
 
-    auto lightness = consumePercentRaw(args, ValueRangeAll);
+    auto lightness = consumePercentRaw(args);
     if (!lightness)
         return { };
 
-    auto aValue = consumeNumberRaw(args, ValueRangeAll);
+    auto aValue = consumeNumberRaw(args);
     if (!aValue)
         return { };
 
-    auto bValue = consumeNumberRaw(args, ValueRangeAll);
+    auto bValue = consumeNumberRaw(args);
     if (!bValue)
         return { };
 
-    auto alpha = parseOptionalAlpha(args);
+    auto alpha = consumeOptionalAlpha(args);
     if (!alpha)
         return { };
@@ -913 +926 @@
         return { };
 
-    return Lab<float> { static_cast<float>(*lightness), static_cast<float>(*aValue), static_cast<float>(*bValue), *alpha };
-}
-
-static Color parseLCHParameters(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+    return Lab<float> { static_cast<float>(*lightness), static_cast<float>(*aValue), static_cast<float>(*bValue), static_cast<float>(*alpha) };
+}
+
+static Color parseLCHParameters(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     ASSERT(range.peek().functionId() == CSSValueLch);
     auto args = consumeFunction(range);
 
-    auto lightness = consumePercentRaw(args, ValueRangeAll);
+    auto lightness = consumePercentRaw(args);
     if (!lightness)
         return { };
 
-    auto chromaValue = consumeNumberRaw(args, ValueRangeAll);
-    if (!chromaValue)
-        return { };
-
-    double hueAngleInDegrees;
-    if (auto angle = consumeAngleRaw(args, cssParserMode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Forbid))
-        hueAngleInDegrees = CSSPrimitiveValue::computeDegrees(angle->type, angle->value);
-    else if (auto number = consumeNumberRaw(args, ValueRangeAll))
-        hueAngleInDegrees = *number;
-    else
-        return { };
-
-    hueAngleInDegrees = fmod(hueAngleInDegrees, 360.0);
-    if (hueAngleInDegrees < 0.0)
-        hueAngleInDegrees += 360.0;
-
-    auto alpha = parseOptionalAlpha(args);
+    auto chroma = consumeNumberRaw(args);
+    if (!chroma)
+        return { };
+
+    auto hue = consumeHue(args, context);
+    if (!hue)
+        return { };
+
+    auto alpha = consumeOptionalAlpha(args);
     if (!alpha)
         return { };
@@ -948 +953 @@
         return { };
 
-    return convertColor<Lab<float>>(LCHA<float> { static_cast<float>(*lightness), static_cast<float>(*chromaValue), static_cast<float>(hueAngleInDegrees), *alpha });
-}
-
-template<typename ColorType>
-static Color parseColorFunctionForRGBTypes(CSSParserTokenRange& args)
+    auto normalizedHue = normalizeHue(*hue);
+
+    return convertColor<Lab<float>>(LCHA<float> { static_cast<float>(*lightness), static_cast<float>(*chroma), static_cast<float>(normalizedHue), static_cast<float>(*alpha) });
+}
+
+template<typename ColorType> static Color parseColorFunctionForRGBTypes(CSSParserTokenRange& args)
 {
     ASSERT(args.peek().id() == CSSValueA98Rgb || args.peek().id() == CSSValueDisplayP3 || args.peek().id() == CSSValueProphotoRgb || args.peek().id() == CSSValueRec2020 || args.peek().id() == CSSValueSRGB);
@@ -965 +971 @@
     }
 
-    auto alpha = parseOptionalAlpha(args);
+    auto alpha = consumeOptionalAlpha(args);
     if (!alpha)
         return { };
 
-    return ColorType { clampTo<float>(channels[0], 0.0, 1.0), clampTo<float>(channels[1], 0.0, 1.0), clampTo<float>(channels[2], 0.0, 1.0), *alpha };
+    return ColorType { clampTo<float>(channels[0], 0.0, 1.0), clampTo<float>(channels[1], 0.0, 1.0), clampTo<float>(channels[2], 0.0, 1.0), static_cast<float>(*alpha) };
 }
 
@@ -979 +985 @@
     double channels[3] = { 0, 0, 0 };
     [&] {
-        auto lightness = consumePercentRaw(args, ValueRangeAll);
+        auto lightness = consumePercentRaw(args);
         if (!lightness)
             return;
         channels[0] = *lightness;
 
-        auto aValue = consumeNumberRaw(args, ValueRangeAll);
+        auto aValue = consumeNumberRaw(args);
         if (!aValue)
             return;
         channels[1] = *aValue;
 
-        auto bValue = consumeNumberRaw(args, ValueRangeAll);
+        auto bValue = consumeNumberRaw(args);
         if (!bValue)
             return;
@@ -995 +1001 @@
     }();
 
-    auto alpha = parseOptionalAlpha(args);
+    auto alpha = consumeOptionalAlpha(args);
     if (!alpha)
         return { };
 
-    return Lab<float> { static_cast<float>(channels[0]), static_cast<float>(channels[1]), static_cast<float>(channels[2]), *alpha };
+    return Lab<float> { static_cast<float>(channels[0]), static_cast<float>(channels[1]), static_cast<float>(channels[2]), static_cast<float>(*alpha) };
 }
 
@@ -1009 +1015 @@
     double channels[3] = { 0, 0, 0 };
     [&] {
-        auto x = consumeNumberRaw(args, ValueRangeAll);
+        auto x = consumeNumberRaw(args);
         if (!x)
             return;
         channels[0] = *x;
 
-        auto y = consumeNumberRaw(args, ValueRangeAll);
+        auto y = consumeNumberRaw(args);
         if (!y)
             return;
         channels[1] = *y;
 
-        auto z = consumeNumberRaw(args, ValueRangeAll);
+        auto z = consumeNumberRaw(args);
         if (!z)
             return;
@@ -1025 +1031 @@
     }();
 
-    auto alpha = parseOptionalAlpha(args);
+    auto alpha = consumeOptionalAlpha(args);
     if (!alpha)
         return { };
 
-    return XYZA<float, WhitePoint::D50> { static_cast<float>(channels[0]), static_cast<float>(channels[1]), static_cast<float>(channels[2]), *alpha };
+    return XYZA<float, WhitePoint::D50> { static_cast<float>(channels[0]), static_cast<float>(channels[1]), static_cast<float>(channels[2]), static_cast<float>(*alpha) };
 }
 
@@ -1112 +1118 @@
 }
 
-static Color parseColorFunction(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static Color parseColorFunction(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     CSSParserTokenRange colorRange = range;
@@ -1120 +1126 @@
     case CSSValueRgb:
     case CSSValueRgba:
-        color = parseRGBParameters(colorRange);
+        color = parseRGBParameters(colorRange, context);
         break;
     case CSSValueHsl:
     case CSSValueHsla:
-        color = parseHSLParameters(colorRange, cssParserMode);
+        color = parseHSLParameters(colorRange, context);
         break;
     case CSSValueHwb:
-        color = parseHWBParameters(colorRange, cssParserMode);
+        color = parseHWBParameters(colorRange, context);
         break;
     case CSSValueLab:
-        color = parseLabParameters(colorRange);
+        color = parseLabParameters(colorRange, context);
         break;
     case CSSValueLch:
-        color = parseLCHParameters(colorRange, cssParserMode);
+        color = parseLCHParameters(colorRange, context);
         break;
     case CSSValueColor:
@@ -1146 +1152 @@
 }
 
-Color consumeColorWorkerSafe(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+Color consumeColorWorkerSafe(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     Color result;
@@ -1155 +1161 @@
         if (StyleColor::isSystemColor(keyword))
             return { };
-        if (!isValueAllowedInMode(keyword, cssParserMode))
+        if (!isValueAllowedInMode(keyword, context.mode))
             return { };
         result = StyleColor::colorFromKeyword(keyword, { });
@@ -1164 +1170 @@
         result = *parsedColor;
     else
-        result = parseColorFunction(range, cssParserMode);
+        result = parseColorFunction(range, context);
 
     if (!range.atEnd())
@@ -1172 +1178 @@
 }
 
-RefPtr<CSSPrimitiveValue> consumeColor(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool acceptQuirkyColors)
+RefPtr<CSSPrimitiveValue> consumeColor(CSSParserTokenRange& range, const CSSParserContext& context, bool acceptQuirkyColors)
 {
     auto keyword = range.peek().id();
     if (StyleColor::isColorKeyword(keyword)) {
-        if (!isValueAllowedInMode(keyword, cssParserMode))
+        if (!isValueAllowedInMode(keyword, context.mode))
             return nullptr;
         return consumeIdent(range);
@@ -1184 +1190 @@
         color = *parsedColor;
     else {
-        color = parseColorFunction(range, cssParserMode);
+        color = parseColorFunction(range, context);
         if (!color.isValid())
             return nullptr;
@@ -1414 +1420 @@
 
 // Used to parse colors for -webkit-gradient(...).
-static RefPtr<CSSPrimitiveValue> consumeDeprecatedGradientStopColor(CSSParserTokenRange& args, CSSParserMode cssParserMode)
+static RefPtr<CSSPrimitiveValue> consumeDeprecatedGradientStopColor(CSSParserTokenRange& args, const CSSParserContext& context)
 {
     if (args.peek().id() == CSSValueCurrentcolor)
         return nullptr;
-    return consumeColor(args, cssParserMode);
-}
-
-static bool consumeDeprecatedGradientColorStop(CSSParserTokenRange& range, CSSGradientColorStop& stop, CSSParserMode cssParserMode)
+    return consumeColor(args, context);
+}
+
+static bool consumeDeprecatedGradientColorStop(CSSParserTokenRange& range, CSSGradientColorStop& stop, const CSSParserContext& context)
 {
     CSSValueID id = range.peek().functionId();
@@ -1443 +1449 @@
 
     stop.position = CSSValuePool::singleton().createValue(position, CSSUnitType::CSS_NUMBER);
-    stop.color = consumeDeprecatedGradientStopColor(args, cssParserMode);
+    stop.color = consumeDeprecatedGradientStopColor(args, context);
     return stop.color && args.atEnd();
 }
 
-static RefPtr<CSSValue> consumeDeprecatedGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode)
+static RefPtr<CSSValue> consumeDeprecatedGradient(CSSParserTokenRange& args, const CSSParserContext& context)
 {
     RefPtr<CSSGradientValue> result;
@@ -1500 +1506 @@
     CSSGradientColorStop stop;
     while (consumeCommaIncludingWhitespace(args)) {
-        if (!consumeDeprecatedGradientColorStop(args, stop, cssParserMode))
+        if (!consumeDeprecatedGradientColorStop(args, stop, context))
             return nullptr;
         result->addStop(WTFMove(stop));
@@ -1509 +1515 @@
 }
 
-static bool consumeGradientColorStops(CSSParserTokenRange& range, CSSParserMode mode, CSSGradientValue& gradient)
+static bool consumeGradientColorStops(CSSParserTokenRange& range, const CSSParserContext& context, CSSGradientValue& gradient)
 {
     bool supportsColorHints = gradient.gradientType() == CSSLinearGradient || gradient.gradientType() == CSSRadialGradient || gradient.gradientType() == CSSConicGradient;
@@ -1515 +1521 @@
     auto consumeStopPosition = [&] {
         return gradient.gradientType() == CSSConicGradient
-            ? consumeAngleOrPercent(range, mode, ValueRangeAll, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Allow)
-            : consumeLengthOrPercent(range, mode, ValueRangeAll);
+            ? consumeAngleOrPercent(range, context.mode, ValueRangeAll, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Allow)
+            : consumeLengthOrPercent(range, context.mode, ValueRangeAll);
     };
 
@@ -1522 +1528 @@
     bool previousStopWasColorHint = true;
     do {
-        CSSGradientColorStop stop { consumeColor(range, mode), consumeStopPosition(), { } };
+        CSSGradientColorStop stop { consumeColor(range, context), consumeStopPosition(), { } };
         if (!stop.color && !stop.position)
             return false;
@@ -1553 +1559 @@
 }
 
-static RefPtr<CSSValue> consumeDeprecatedRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
+static RefPtr<CSSValue> consumeDeprecatedRadialGradient(CSSParserTokenRange& args, const CSSParserContext& context, CSSGradientRepeat repeating)
 {
     auto result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
 
-    auto centerCoordinate = consumeOneOrTwoValuedPositionCoordinates(args, cssParserMode, UnitlessQuirk::Forbid);
+    auto centerCoordinate = consumeOneOrTwoValuedPositionCoordinates(args, context.mode, UnitlessQuirk::Forbid);
     if (centerCoordinate && !consumeCommaIncludingWhitespace(args))
         return nullptr;
@@ -1568 +1574 @@
     // Or, two lengths or percentages
     if (!shape && !sizeKeyword) {
-        auto horizontalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
+        auto horizontalSize = consumeLengthOrPercent(args, context.mode, ValueRangeNonNegative);
         RefPtr<CSSPrimitiveValue> verticalSize;
         if (horizontalSize) {
-            verticalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
+            verticalSize = consumeLengthOrPercent(args, context.mode, ValueRangeNonNegative);
             if (!verticalSize)
                 return nullptr;
@@ -1582 +1588 @@
     }
 
-    if (!consumeGradientColorStops(args, cssParserMode, result))
+    if (!consumeGradientColorStops(args, context, result))
         return nullptr;
 
@@ -1597 +1603 @@
 }
 
-static RefPtr<CSSValue> consumeRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
+static RefPtr<CSSValue> consumeRadialGradient(CSSParserTokenRange& args, const CSSParserContext& context, CSSGradientRepeat repeating)
 {
     RefPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
@@ -1625 +1631 @@
             }
         } else {
-            auto center = consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
+            auto center = consumeLengthOrPercent(args, context.mode, ValueRangeNonNegative);
             if (!center)
                 break;
@@ -1631 +1637 @@
                 return nullptr;
             horizontalSize = center;
-            center = consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
+            center = consumeLengthOrPercent(args, context.mode, ValueRangeNonNegative);
             if (center) {
                 verticalSize = center;
@@ -1660 +1666 @@
         args.consumeIncludingWhitespace();
         
-        auto centerCoordinate = consumePositionCoordinates(args, cssParserMode, UnitlessQuirk::Forbid, PositionSyntax::Position);
+        auto centerCoordinate = consumePositionCoordinates(args, context.mode, UnitlessQuirk::Forbid, PositionSyntax::Position);
         if (!centerCoordinate)
             return nullptr;
@@ -1677 +1683 @@
     if ((shape || sizeKeyword || horizontalSize || centerX || centerY) && !consumeCommaIncludingWhitespace(args))
         return nullptr;
-    if (!consumeGradientColorStops(args, cssParserMode, *result))
+    if (!consumeGradientColorStops(args, context, *result))
         return nullptr;
 
@@ -1688 +1694 @@
 }
 
-static RefPtr<CSSValue> consumeLinearGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating, CSSGradientType gradientType)
+static RefPtr<CSSValue> consumeLinearGradient(CSSParserTokenRange& args, const CSSParserContext& context, CSSGradientRepeat repeating, CSSGradientType gradientType)
 {
     RefPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, gradientType);
 
     bool expectComma = true;
-    RefPtr<CSSPrimitiveValue> angle = consumeAngle(args, cssParserMode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Allow);
+    RefPtr<CSSPrimitiveValue> angle = consumeAngle(args, context.mode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Allow);
     if (angle)
         result->setAngle(angle.releaseNonNull());
@@ -1716 +1722 @@
     if (expectComma && !consumeCommaIncludingWhitespace(args))
         return nullptr;
-    if (!consumeGradientColorStops(args, cssParserMode, *result))
+    if (!consumeGradientColorStops(args, context, *result))
         return nullptr;
     return result;
 }
 
-static RefPtr<CSSValue> consumeConicGradient(CSSParserTokenRange& args, CSSParserContext context, CSSGradientRepeat repeating)
+static RefPtr<CSSValue> consumeConicGradient(CSSParserTokenRange& args, const CSSParserContext& context, CSSGradientRepeat repeating)
 {
 #if ENABLE(CSS_CONIC_GRADIENTS)
@@ -1755 +1761 @@
     if (expectComma && !consumeCommaIncludingWhitespace(args))
         return nullptr;
-    if (!consumeGradientColorStops(args, context.mode, *result))
+    if (!consumeGradientColorStops(args, context, *result))
         return nullptr;
     return result;
@@ -1766 +1772 @@
 }
 
-RefPtr<CSSValue> consumeImageOrNone(CSSParserTokenRange& range, CSSParserContext context)
+RefPtr<CSSValue> consumeImageOrNone(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     if (range.peek().id() == CSSValueNone)
@@ -1773 +1779 @@
 }
 
-static RefPtr<CSSValue> consumeCrossFade(CSSParserTokenRange& args, CSSParserContext context, bool prefixed)
+static RefPtr<CSSValue> consumeCrossFade(CSSParserTokenRange& args, const CSSParserContext& context, bool prefixed)
 {
     auto fromImageValue = consumeImageOrNone(args, context);
@@ -1849 +1855 @@
 #endif
 
-static RefPtr<CSSValue> consumeGeneratedImage(CSSParserTokenRange& range, CSSParserContext context)
+static RefPtr<CSSValue> consumeGeneratedImage(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     CSSValueID id = range.peek().functionId();
@@ -1856 +1862 @@
     RefPtr<CSSValue> result;
     if (id == CSSValueRadialGradient)
-        result = consumeRadialGradient(args, context.mode, NonRepeating);
+        result = consumeRadialGradient(args, context, NonRepeating);
     else if (id == CSSValueRepeatingRadialGradient)
-        result = consumeRadialGradient(args, context.mode, Repeating);
+        result = consumeRadialGradient(args, context, Repeating);
     else if (id == CSSValueWebkitLinearGradient)
-        result = consumeLinearGradient(args, context.mode, NonRepeating, CSSPrefixedLinearGradient);
+        result = consumeLinearGradient(args, context, NonRepeating, CSSPrefixedLinearGradient);
     else if (id == CSSValueWebkitRepeatingLinearGradient)
-        result = consumeLinearGradient(args, context.mode, Repeating, CSSPrefixedLinearGradient);
+        result = consumeLinearGradient(args, context, Repeating, CSSPrefixedLinearGradient);
     else if (id == CSSValueRepeatingLinearGradient)
-        result = consumeLinearGradient(args, context.mode, Repeating, CSSLinearGradient);
+        result = consumeLinearGradient(args, context, Repeating, CSSLinearGradient);
     else if (id == CSSValueLinearGradient)
-        result = consumeLinearGradient(args, context.mode, NonRepeating, CSSLinearGradient);
+        result = consumeLinearGradient(args, context, NonRepeating, CSSLinearGradient);
     else if (id == CSSValueWebkitGradient)
-        result = consumeDeprecatedGradient(args, context.mode);
+        result = consumeDeprecatedGradient(args, context);
     else if (id == CSSValueWebkitRadialGradient)
-        result = consumeDeprecatedRadialGradient(args, context.mode, NonRepeating);
+        result = consumeDeprecatedRadialGradient(args, context, NonRepeating);
     else if (id == CSSValueWebkitRepeatingRadialGradient)
-        result = consumeDeprecatedRadialGradient(args, context.mode, Repeating);
+        result = consumeDeprecatedRadialGradient(args, context, Repeating);
     else if (id == CSSValueConicGradient)
         result = consumeConicGradient(args, context, NonRepeating);
@@ -2018 +2024 @@
 
     if (filterType == CSSValueDropShadow)
-        parsedValue = consumeSingleShadow(args, context.mode, false, false);
+        parsedValue = consumeSingleShadow(args, context, false, false);
     else {
         if (args.atEnd())
@@ -2065 +2071 @@
 }
 
-RefPtr<CSSShadowValue> consumeSingleShadow(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool allowInset, bool allowSpread)
+RefPtr<CSSShadowValue> consumeSingleShadow(CSSParserTokenRange& range, const CSSParserContext& context, bool allowInset, bool allowSpread)
 {
     RefPtr<CSSPrimitiveValue> style;
@@ -2090 +2096 @@
         }
         
-        auto maybeColor = consumeColor(range, cssParserMode);
+        auto maybeColor = consumeColor(range, context);
         if (maybeColor) {
             // If we just parsed a color but already had one, the given token range is not a valid <shadow>.
@@ -2104 +2110 @@
             return nullptr;
         }
-        horizontalOffset = consumeLength(range, cssParserMode, ValueRangeAll);
+        horizontalOffset = consumeLength(range, context.mode, ValueRangeAll);
         if (!horizontalOffset)
             return nullptr;
-        verticalOffset = consumeLength(range, cssParserMode, ValueRangeAll);
+        verticalOffset = consumeLength(range, context.mode, ValueRangeAll);
         if (!verticalOffset)
             return nullptr;
@@ -2114 +2120 @@
         // The explicit check for calc() is unfortunate. This is ensuring that we only fail parsing if there is a length, but it fails the range check.
         if (token.type() == DimensionToken || token.type() == NumberToken || (token.type() == FunctionToken && CSSCalcValue::isCalcFunction(token.functionId()))) {
-            blurRadius = consumeLength(range, cssParserMode, ValueRangeNonNegative);
+            blurRadius = consumeLength(range, context.mode, ValueRangeNonNegative);
             if (!blurRadius)
                 return nullptr;
@@ -2120 +2126 @@
 
         if (blurRadius && allowSpread)
-            spreadDistance = consumeLength(range, cssParserMode, ValueRangeAll);
+            spreadDistance = consumeLength(range, context.mode, ValueRangeAll);
     }
     
@@ -2129 +2135 @@
 }
 
-RefPtr<CSSValue> consumeImage(CSSParserTokenRange& range, CSSParserContext context, OptionSet<AllowedImageType> allowedImageTypes)
+RefPtr<CSSValue> consumeImage(CSSParserTokenRange& range, const CSSParserContext& context, OptionSet<AllowedImageType> allowedImageTypes)
 {
     if ((range.peek().type() == StringToken) && (allowedImageTypes.contains(AllowedImageType::RawStringAsURL))) {

trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.h

@@ -103 +103 @@
 RefPtr<CSSPrimitiveValue> consumeUrl(CSSParserTokenRange&);
 
-Color consumeColorWorkerSafe(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSPrimitiveValue> consumeColor(CSSParserTokenRange&, CSSParserMode, bool acceptQuirkyColors = false);
+Color consumeColorWorkerSafe(CSSParserTokenRange&, const CSSParserContext&);
+RefPtr<CSSPrimitiveValue> consumeColor(CSSParserTokenRange&, const CSSParserContext&, bool acceptQuirkyColors = false);
 
 enum class PositionSyntax {
@@ -127 +127 @@
 };
 
-RefPtr<CSSValue> consumeImage(CSSParserTokenRange&, CSSParserContext, OptionSet<AllowedImageType> = { AllowedImageType::URLFunction, AllowedImageType::ImageSet, AllowedImageType::GeneratedImage });
-
-RefPtr<CSSValue> consumeImageOrNone(CSSParserTokenRange&, CSSParserContext);
+RefPtr<CSSValue> consumeImage(CSSParserTokenRange&, const CSSParserContext&, OptionSet<AllowedImageType> = { AllowedImageType::URLFunction, AllowedImageType::ImageSet, AllowedImageType::GeneratedImage });
+RefPtr<CSSValue> consumeImageOrNone(CSSParserTokenRange&, const CSSParserContext&);
 
 enum class AllowedFilterFunctions {
@@ -137 +136 @@
 
 RefPtr<CSSValue> consumeFilter(CSSParserTokenRange&, const CSSParserContext&, AllowedFilterFunctions);
-RefPtr<CSSShadowValue> consumeSingleShadow(CSSParserTokenRange&, CSSParserMode, bool allowInset, bool allowSpread);
+RefPtr<CSSShadowValue> consumeSingleShadow(CSSParserTokenRange&, const CSSParserContext&, bool allowInset, bool allowSpread);
 
 struct FontStyleRaw {

trunk/Source/WebCore/editing/cocoa/DataDetection.mm

@@ -601 +601 @@
                         // Force the lightness of the underline color to the middle, and multiply the alpha by 38%,
                         // so the color will appear on light and dark backgrounds, since only one color can be specified.
-                        hsla.lightness = 0.5f;
+                        hsla.lightness = 50.0f;
                         hsla.alpha *= 0.38f;
                         

trunk/Source/WebCore/platform/graphics/ColorConversion.cpp

@@ -59 +59 @@
         hue -= 360.0f;
 
-    hue /= 360.0f;
-
     return { hue, min, max, chroma };
 }
@@ -70 +68 @@
     auto [hue, min, max, chroma] = calculateHSLHue(color);
 
-    float lightness = 0.5f * (max + min);
+    float lightness = (0.5f * (max + min)) * 100.0f;
     float saturation;
     if (!chroma)
         saturation = 0;
-    else if (lightness <= 0.5f)
-        saturation = (chroma / (max + min));
+    else if (lightness <= 50.0f)
+        saturation = (chroma / (max + min)) * 100.0f;
     else
-        saturation = (chroma / (2.0f - (max + min)));
+        saturation = (chroma / (2.0f - (max + min))) * 100.0f;
 
     return { hue, saturation, lightness, alpha };
@@ -87 +85 @@
     auto [hue, saturation, lightness, alpha] = color;
 
-    if (!saturation)
-        return { lightness, lightness, lightness, alpha };
-    
-    float temp2 = lightness <= 0.5f ? lightness * (1.0f + saturation) : lightness + saturation - lightness * saturation;
-    float temp1 = 2.0f * lightness - temp2;
+    if (!saturation) {
+        auto grey = lightness / 100.0f;
+        return { grey, grey, grey, alpha };
+    }
+
+    // hueToRGB() wants hue in the 0-6 range.
+    auto normalizedHue = (hue / 360.0f) * 6.0f;
+    auto normalizedLightness = lightness / 100.0f;
+    auto normalizedSaturation = saturation / 100.0f;
+
+    auto hueForRed = normalizedHue + 2.0f;
+    auto hueForGreen = normalizedHue;
+    auto hueForBlue = normalizedHue - 2.0f;
+    if (hueForRed > 6.0f)
+        hueForRed -= 6.0f;
+    else if (hueForBlue < 0.0f)
+        hueForBlue += 6.0f;
+
+    float temp2 = normalizedLightness <= 0.5f ? normalizedLightness * (1.0f + normalizedSaturation) : normalizedLightness + normalizedSaturation - normalizedLightness * normalizedSaturation;
+    float temp1 = 2.0f * normalizedLightness - temp2;
     
     // Hue is in the range 0-6, other args in 0-1.
@@ -104 +117 @@
     };
 
+    return {
+        hueToRGB(temp1, temp2, hueForRed),
+        hueToRGB(temp1, temp2, hueForGreen),
+        hueToRGB(temp1, temp2, hueForBlue),
+        alpha
+    };
+}
+
+// MARK: HWB conversions.
+
+HWBA<float> ColorConversion<HWBA<float>, SRGBA<float>>::convert(const SRGBA<float>& color)
+{
+    // https://drafts.csswg.org/css-color-4/#rgb-to-hwb
+    auto [hue, min, max, chroma] = calculateHSLHue(color);
+    auto whiteness = min * 100.0f;
+    auto blackness = (1.0f - max) * 100.0f;
+    
+    return { hue, whiteness, blackness, color.alpha };
+}
+
+SRGBA<float> ColorConversion<SRGBA<float>, HWBA<float>>::convert(const HWBA<float>& color)
+{
+    // https://drafts.csswg.org/css-color-4/#hwb-to-rgb
+    auto [hue, whiteness, blackness, alpha] = color;
+
+    if (whiteness + blackness == 100.0f) {
+        auto grey = whiteness / 100.0f;
+        return { grey, grey, grey, alpha };
+    }
+
     // hueToRGB() wants hue in the 0-6 range.
-    hue *= 6.0f;
-
-    auto hueForRed = hue + 2.0f;
-    auto hueForGreen = hue;
-    auto hueForBlue = hue - 2.0f;
+    auto normalizedHue = (hue / 360.0f) * 6.0f;
+
+    auto hueForRed = normalizedHue + 2.0f;
+    auto hueForGreen = normalizedHue;
+    auto hueForBlue = normalizedHue - 2.0f;
     if (hueForRed > 6.0f)
         hueForRed -= 6.0f;
@@ -115 +158 @@
         hueForBlue += 6.0f;
 
-    return {
-        hueToRGB(temp1, temp2, hueForRed),
-        hueToRGB(temp1, temp2, hueForGreen),
-        hueToRGB(temp1, temp2, hueForBlue),
-        alpha
-    };
-}
-
-// MARK: HWB conversions.
-
-HWBA<float> ColorConversion<HWBA<float>, SRGBA<float>>::convert(const SRGBA<float>& color)
-{
-    // https://drafts.csswg.org/css-color-4/#rgb-to-hwb
-    auto [hue, min, max, chroma] = calculateHSLHue(color);
-    auto whiteness = min;
-    auto blackness = 1.0f - max;
-    
-    return { hue, whiteness, blackness, color.alpha };
-}
-
-SRGBA<float> ColorConversion<SRGBA<float>, HWBA<float>>::convert(const HWBA<float>& color)
-{
-    // https://drafts.csswg.org/css-color-4/#hwb-to-rgb
-    auto [hue, whiteness, blackness, alpha] = color;
-
-    if (whiteness + blackness == 1.0f)
-        return { whiteness, whiteness, whiteness, alpha };
+    auto normalizedWhiteness = whiteness / 100.0f;
+    auto normalizedBlackness = blackness / 100.0f;
 
     // This is the hueToRGB function in convertColor<SRGBA<float>>(const HSLA&) with temp1 == 0
@@ -155 +173 @@
     };
 
-    auto applyWhitenessBlackness = [&](float component) {
-        return (component * (1.0f - color.whiteness - color.blackness)) + color.whiteness;
-    };
-
-    // hueToRGB() wants hue in the 0-6 range.
-    hue *= 6.0f;
-
-    auto hueForRed = hue + 2.0f;
-    auto hueForGreen = hue;
-    auto hueForBlue = hue - 2.0f;
-    if (hueForRed > 6.0f)
-        hueForRed -= 6.0f;
-    else if (hueForBlue < 0.0f)
-        hueForBlue += 6.0f;
-
-    return {
-        applyWhitenessBlackness(hueToRGB(hueForRed)),
-        applyWhitenessBlackness(hueToRGB(hueForGreen)),
-        applyWhitenessBlackness(hueToRGB(hueForBlue)),
+    auto applyWhitenessBlackness = [](float component, auto whiteness, auto blackness) {
+        return (component * (1.0f - whiteness - blackness)) + whiteness;
+    };
+
+    return {
+        applyWhitenessBlackness(hueToRGB(hueForRed), normalizedWhiteness, normalizedBlackness),
+        applyWhitenessBlackness(hueToRGB(hueForGreen), normalizedWhiteness, normalizedBlackness),
+        applyWhitenessBlackness(hueToRGB(hueForBlue), normalizedWhiteness, normalizedBlackness),
         alpha
     };

trunk/Source/WebCore/platform/graphics/ColorModels.h

@@ -68 +68 @@
 template<> struct HSLModel<float> {
     static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
-        { 0, 1 },
-        { 0, 1 },
-        { 0, 1 }
+        { 0, 360 },
+        { 0, 100 },
+        { 0, 100 }
     } };
     static constexpr bool isInvertible = false;
@@ -77 +77 @@
 template<> struct HWBModel<float> {
     static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
-        { 0, 1 },
-        { 0, 1 },
-        { 0, 1 }
+        { 0, 360 },
+        { 0, 100 },
+        { 0, 100 }
     } };
     static constexpr bool isInvertible = false;

trunk/Source/WebCore/rendering/RenderTheme.cpp

@@ -1423 +1423 @@
     auto hsla = textColor.toColorTypeLossy<HSLA<float>>();
     if (textColor.luminance() < backgroundColor.luminance())
-        hsla.lightness += datePlaceholderColorLightnessAdjustmentFactor * (1.0f - hsla.lightness);
+        hsla.lightness += datePlaceholderColorLightnessAdjustmentFactor * (100.0f - hsla.lightness);
     else
         hsla.lightness *= datePlaceholderColorLightnessAdjustmentFactor;

trunk/Tools/ChangeLog

@@ +1 @@
+2021-02-15  Sam Weinig  <weinig@apple.com>
+
+        Prepare for adding relative color support
+        https://bugs.webkit.org/show_bug.cgi?id=221881
+
+        Reviewed by Darin Adler.
+
+        * TestWebKitAPI/Tests/WebCore/ColorTests.cpp:
+        Update HSLA tests to account for HSLA now using 0-360, 0-100, 0-100 bounds rather than 0-1, 0-1, 0-1.
+
 2021-02-15  Adam Roben  <aroben@apple.com>
 

trunk/Tools/TestWebKitAPI/Tests/WebCore/ColorTests.cpp

@@ -43 +43 @@
     EXPECT_FLOAT_EQ(0, hslaColor.hue);
     EXPECT_FLOAT_EQ(0, hslaColor.saturation);
-    EXPECT_FLOAT_EQ(1, hslaColor.lightness);
+    EXPECT_FLOAT_EQ(100, hslaColor.lightness);
     
-    EXPECT_FLOAT_EQ(color.lightness(), hslaColor.lightness);
+    EXPECT_FLOAT_EQ(color.lightness() * 100, hslaColor.lightness);
     
     auto roundTrippedColor = convertColor<SRGBA<uint8_t>>(hslaColor);
@@ -61 +61 @@
     EXPECT_FLOAT_EQ(0, hslaColor.lightness);
 
-    EXPECT_FLOAT_EQ(color.lightness(), hslaColor.lightness);
+    EXPECT_FLOAT_EQ(color.lightness() * 100, hslaColor.lightness);
 
     auto roundTrippedColor = convertColor<SRGBA<uint8_t>>(hslaColor);
@@ -74 +74 @@
 
     EXPECT_FLOAT_EQ(0, hslaColor.hue);
-    EXPECT_FLOAT_EQ(1, hslaColor.saturation);
-    EXPECT_FLOAT_EQ(0.5, hslaColor.lightness);
-
-    EXPECT_FLOAT_EQ(color.lightness(), hslaColor.lightness);
+    EXPECT_FLOAT_EQ(100, hslaColor.saturation);
+    EXPECT_FLOAT_EQ(50, hslaColor.lightness);
+
+    EXPECT_FLOAT_EQ(color.lightness() * 100, hslaColor.lightness);
 
     auto roundTrippedColor = convertColor<SRGBA<uint8_t>>(hslaColor);
@@ -89 +89 @@
     auto hslaColor = color.toColorTypeLossy<HSLA<float>>();
 
-    EXPECT_FLOAT_EQ(0.33333334, hslaColor.hue);
-    EXPECT_FLOAT_EQ(1, hslaColor.saturation);
-    EXPECT_FLOAT_EQ(0.5, hslaColor.lightness);
-
-    EXPECT_FLOAT_EQ(color.lightness(), hslaColor.lightness);
+    EXPECT_FLOAT_EQ(120, hslaColor.hue);
+    EXPECT_FLOAT_EQ(100, hslaColor.saturation);
+    EXPECT_FLOAT_EQ(50, hslaColor.lightness);
+
+    EXPECT_FLOAT_EQ(color.lightness() * 100, hslaColor.lightness);
 
     auto roundTrippedColor = convertColor<SRGBA<uint8_t>>(hslaColor);
@@ -105 +105 @@
     auto hslaColor = color.toColorTypeLossy<HSLA<float>>();
 
-    EXPECT_FLOAT_EQ(0.66666669, hslaColor.hue);
-    EXPECT_FLOAT_EQ(1, hslaColor.saturation);
-    EXPECT_FLOAT_EQ(0.5, hslaColor.lightness);
-
-    EXPECT_FLOAT_EQ(color.lightness(), hslaColor.lightness);
+    EXPECT_FLOAT_EQ(240, hslaColor.hue);
+    EXPECT_FLOAT_EQ(100, hslaColor.saturation);
+    EXPECT_FLOAT_EQ(50, hslaColor.lightness);
+
+    EXPECT_FLOAT_EQ(color.lightness() * 100, hslaColor.lightness);
 
     auto roundTrippedColor = convertColor<SRGBA<uint8_t>>(hslaColor);
@@ -123 +123 @@
     EXPECT_FLOAT_EQ(0, hslaColor.hue);
     EXPECT_FLOAT_EQ(0, hslaColor.saturation);
-    EXPECT_FLOAT_EQ(0.50196078431372548, hslaColor.lightness);
+    EXPECT_FLOAT_EQ(50.196083, hslaColor.lightness);
     
-    EXPECT_FLOAT_EQ(color.lightness(), hslaColor.lightness);
+    EXPECT_FLOAT_EQ(color.lightness() * 100, hslaColor.lightness);
 
     auto roundTrippedColor = convertColor<SRGBA<uint8_t>>(hslaColor);
@@ -139 +139 @@
     EXPECT_FLOAT_EQ(0, hslaColor.hue);
     EXPECT_FLOAT_EQ(0, hslaColor.saturation);
-    EXPECT_FLOAT_EQ(0.62745098039215685, hslaColor.lightness);
-
-    EXPECT_FLOAT_EQ(color.lightness(), hslaColor.lightness);
+    EXPECT_FLOAT_EQ(62.745102, hslaColor.lightness);
+
+    EXPECT_FLOAT_EQ(color.lightness() * 100, hslaColor.lightness);
 
     auto roundTrippedColor = convertColor<SRGBA<uint8_t>>(hslaColor);
@@ -155 +155 @@
     EXPECT_FLOAT_EQ(0, hslaColor.hue);
     EXPECT_FLOAT_EQ(0, hslaColor.saturation);
-    EXPECT_FLOAT_EQ(0.75294117647058822, hslaColor.lightness);
-
-    EXPECT_FLOAT_EQ(color.lightness(), hslaColor.lightness);
+    EXPECT_FLOAT_EQ(75.294121, hslaColor.lightness);
+
+    EXPECT_FLOAT_EQ(color.lightness() * 100, hslaColor.lightness);
 
     auto roundTrippedColor = convertColor<SRGBA<uint8_t>>(hslaColor);