Dissect and clean up instances of color parsing in CSSPropertyParser

Source/core/css/parser/CSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 545 matching lines @@
     case CSSPropertyWebkitBorderEndColor:
     case CSSPropertyWebkitBorderBeforeColor:
     case CSSPropertyWebkitBorderAfterColor:
     case CSSPropertyColor: // <color> | inherit
     case CSSPropertyTextDecorationColor: // CSS3 text decoration colors
     case CSSPropertyWebkitColumnRuleColor:
     case CSSPropertyWebkitTextEmphasisColor:
     case CSSPropertyWebkitTextFillColor:
     case CSSPropertyWebkitTextStrokeColor:
         ASSERT(propId != CSSPropertyTextDecorationColor || RuntimeEnabledFeatures::css3TextDecorationsEnabled());
-
-        if ((id >= CSSValueAqua && id <= CSSValueWebkitText) || id == CSSValueMenu) {
-            validPrimitive = isValueAllowedInMode(id, m_context.mode());
-        } else {
-            if (!inQuirksMode()) {
-                parsedValue = parseColor();
-                if (parsedValue)
-                    m_valueList->next();
-                break;
-            }
-
-            bool acceptQuirkyColors = false;
-            switch (propId) {
-            case CSSPropertyBackgroundColor:
-            case CSSPropertyBorderBottomColor:
-            case CSSPropertyBorderLeftColor:
-            case CSSPropertyBorderRightColor:
-            case CSSPropertyBorderTopColor:
-                if (!inShorthand() || m_currentShorthand == CSSPropertyBorderColor)
-                    acceptQuirkyColors = true;
-                break;
-            case CSSPropertyColor:
-                acceptQuirkyColors = true;
-                break;
-            default:
-                break;
-            }
-            parsedValue = parseColor(0, acceptQuirkyColors);
-            if (parsedValue)
-                m_valueList->next();
-        }
+        parsedValue = parseColor(m_valueList->current(), acceptQuirkyColors(propId));
+        if (parsedValue)
+            m_valueList->next();
         break;
 
     case CSSPropertyCursor: {
         // Grammar defined by CSS3 UI and modified by CSS4 images:
         // [ [<image> [<x> <y>]?,]*
         // [ auto | crosshair | default | pointer | progress | move | e-resize | ne-resize |
         // nw-resize | n-resize | se-resize | sw-resize | s-resize | w-resize | ew-resize |
         // ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | text | wait | help |
         // vertical-text | cell | context-menu | alias | copy | no-drop | not-allowed | all-scroll |
         // zoom-in | zoom-out | -webkit-grab | -webkit-grabbing | -webkit-zoom-in | -webkit-zoom-out ] ] | inherit
@@ skipping 760 matching lines @@
         break;
 
     // End Apple-specific properties
 
     case CSSPropertyWebkitAppRegion:
         if (id >= CSSValueDrag && id <= CSSValueNoDrag)
             validPrimitive = true;
         break;
 
     case CSSPropertyWebkitTapHighlightColor:
-        if ((id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu
-            || (id >= CSSValueWebkitFocusRingColor && id < CSSValueWebkitText && inQuirksMode())) {
-            validPrimitive = true;
-        } else {
-            parsedValue = parseColor();
-            if (parsedValue)
-                m_valueList->next();
-        }
+        parsedValue = parseTapHighlightColor(m_valueList->current());
+        if (parsedValue)
+            m_valueList->next();
         break;
 
         /* shorthand properties */
     case CSSPropertyBackground: {
         // Position must come before color in this array because a plain old "0" is a legal color
         // in quirks mode but it's usually the X coordinate of a position.
         const CSSPropertyID properties[] = { CSSPropertyBackgroundImage, CSSPropertyBackgroundRepeat,
                                    CSSPropertyBackgroundAttachment, CSSPropertyBackgroundPosition, CSSPropertyBackgroundOrigin,
                                    CSSPropertyBackgroundClip, CSSPropertyBackgroundColor, CSSPropertyBackgroundSize };
         return parseFillShorthand(propId, properties, WTF_ARRAY_LENGTH(properties), important);
@@ skipping 896 matching lines @@
     // even parse them inside attr().
     if (attrName[0] == '-')
         return nullptr;
 
     if (m_context.isHTMLDocument())
         attrName = attrName.lower();
 
     return cssValuePool().createValue(attrName, CSSPrimitiveValue::CSS_ATTR);
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBackgroundColor()
+bool CSSPropertyParser::acceptQuirkyColors(CSSPropertyID propertyId) const
 {
-    CSSValueID id = m_valueList->current()->id;
-    if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor ||
-        (id >= CSSValueGrey && id < CSSValueWebkitText && inQuirksMode()))
+    if (!inQuirksMode())
+        return false;
+    switch (propertyId) {
+    case CSSPropertyBackgroundColor:
+    case CSSPropertyBorderBottomColor:
+    case CSSPropertyBorderLeftColor:
+    case CSSPropertyBorderRightColor:
+    case CSSPropertyBorderTopColor:
+        return !inShorthand() || m_currentShorthand == CSSPropertyBorderColor;
+    case CSSPropertyColor:
+        return true;
+    default:
+        break;
+    }
+    return false;
+}
+
+bool CSSPropertyParser::isColorKeyword(CSSValueID id)
+{
+    // Named colors and color keywords:
+    //
+    // <named-color>
+    //   'aqua', 'black', 'blue', ..., 'yellow' (CSS3: "basic color keywords")
+    //   'aliceblue', ..., 'yellowgreen'        (CSS3: "extended color keywords")
+    //   'transparent'
+    //
+    // 'currentcolor'
+    //
+    // <deprecated-system-color>
+    //   'ActiveBorder', ..., 'WindowText'
+    //
+    // WebKit proprietary/internal:
+    //   '-webkit-link'
+    //   '-webkit-activelink'
+    //   '-internal-active-list-box-selection'
+    //   '-internal-active-list-box-selection-text'
+    //   '-internal-inactive-list-box-selection'
+    //   '-internal-inactive-list-box-selection-text'
+    //   '-webkit-focus-ring-color'
+    //
+    // TODO(fs): The "extended color keywords" are not included.
+    return (id >= CSSValueAqua && id <= CSSValueWebkitText) || id == CSSValueMenu;
+}
+
+PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseColor(const CSSParserValue* value, bool acceptQuirkyColors)
+{
+    CSSValueID id = value->id;
+    if (isColorKeyword(id)) {
+        if (!isValueAllowedInMode(id, m_context.mode()))
+            return nullptr;
         return cssValuePool().createIdentifierValue(id);
-    return parseColor();
+    }
+    RGBA32 c = Color::transparent;
+    if (!parseColorFromValue(value, c, acceptQuirkyColors))
+        return nullptr;
+    return cssValuePool().createColorValue(c);
+}
+
+// Used to parse background-color when part of a shorthand.
+PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseBackgroundColor(const CSSParserValue* value)
+{
+    CSSValueID id = value->id;
+    // Allow -webkit-text regardless of quirks.
+    if (id == CSSValueWebkitText)
+        return cssValuePool().createIdentifierValue(id);
+    return parseColor(value);
+}
+
+// Used to parse the '-webkit-tap-highlight-color' property.
+PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseTapHighlightColor(const CSSParserValue* value)
+{
+    CSSValueID id = value->id;
+    // Disallow -webkit-text regardless of quirks.
+    if (id == CSSValueWebkitText)
+        return nullptr;
+    // Allow currentcolor in quirks-mode only.
+    if (id == CSSValueCurrentcolor) {
+        if (!inQuirksMode())
+            return nullptr;
+        return cssValuePool().createIdentifierValue(id);
+    }
+    return parseColor(value);
+}
+
+// Used to parse <color> for CSS gradients.
+PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseGradientStopColor(const CSSParserValue* value)
+{
+    CSSValueID id = value->id;
+    // Allow -webkit-text regardless of quirks.
+    if (id == CSSValueWebkitText)
+        return cssValuePool().createIdentifierValue(id);
+    return parseColor(value);
+}
+
+// Used to parse colors for -webkit-gradient(...).
+PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseDeprecatedGradientStopColor(const CSSParserValue* value)
+{
+    // Disallow currentcolor.
+    if (value->id == CSSValueCurrentcolor)
+        return nullptr;
+    return parseGradientStopColor(value);
+}
+
+// Used to parse <color> for SVG properties.
+PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseSVGColor(const CSSParserValue* value)
+{
+    CSSValueID id = value->id;
+    if (id == CSSValueCurrentcolor)
+        return cssValuePool().createIdentifierValue(id);
+    if ((id >= CSSValueActiveborder && id <= CSSValueWindowtext) || id == CSSValueMenu)
+        return cssValuePool().createColorValue(LayoutTheme::theme().systemColor(id).rgb());
+    RGBA32 c = Color::transparent;
+    if (!parseColorFromValue(value, c))
+        return nullptr;
+    return cssValuePool().createColorValue(c);
 }
 
 bool CSSPropertyParser::parseFillImage(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value)
 {
     if (valueList->current()->id == CSSValueNone) {
         value = cssValuePool().createIdentifierValue(CSSValueNone);
         return true;
     }
     if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
         value = createCSSImageValueWithReferrer(valueList->current()->string, completeURL(valueList->current()->string));
@@ skipping 470 matching lines @@
     while (true) {
         RefPtrWillBeRawPtr<CSSValue> currValue = nullptr;
         RefPtrWillBeRawPtr<CSSValue> currValue2 = nullptr;
 
         Units unitless = FUnknown;
         CSSParserValue* val = m_valueList->current();
         ASSERT(val);
 
         switch (propId) {
         case CSSPropertyBackgroundColor:
-            currValue = parseBackgroundColor();
+            currValue = parseBackgroundColor(val);
             if (currValue)
                 m_valueList->next();
             break;
         case CSSPropertyBackgroundAttachment:
             if (val->id == CSSValueScroll || val->id == CSSValueFixed || val->id == CSSValueLocal) {
                 currValue = cssValuePool().createIdentifierValue(val->id);
                 m_valueList->next();
             }
             break;
         case CSSPropertyBackgroundImage:
@@ skipping 2156 matching lines @@
             return 255;
         return static_cast<int>(value * 256.0 / 100.0);
     }
 
     if (value >= 255.0)
         return 255;
 
     return static_cast<int>(value);
 }
 
-bool CSSPropertyParser::parseColorParameters(CSSParserValue* value, int* colorArray, bool parseAlpha)
+bool CSSPropertyParser::parseColorParameters(const CSSParserValue* value, int* colorArray, bool parseAlpha)
 {
     CSSParserValueList* args = value->function->args.get();
     CSSParserValue* v = args->current();
     Units unitType = FUnknown;
     // Get the first value and its type
     if (validUnit(v, FInteger))
         unitType = FInteger;
     else if (validUnit(v, FPercent))
         unitType = FPercent;
     else
@@ skipping 21 matching lines @@
         colorArray[3] = static_cast<int>(std::max(0.0, std::min(1.0, v->fValue)) * nextafter(256.0, 0.0));
     }
     return true;
 }
 
 // The CSS3 specification defines the format of a HSL color as
 // hsl(<number>, <percent>, <percent>)
 // and with alpha, the format is
 // hsla(<number>, <percent>, <percent>, <number>)
 // The first value, HUE, is in an angle with a value between 0 and 360
-bool CSSPropertyParser::parseHSLParameters(CSSParserValue* value, double* colorArray, bool parseAlpha)
+bool CSSPropertyParser::parseHSLParameters(const CSSParserValue* value, double* colorArray, bool parseAlpha)
 {
     CSSParserValueList* args = value->function->args.get();
     CSSParserValue* v = args->current();
     // Get the first value
     if (!validUnit(v, FNumber))
         return false;
     // normalize the Hue value and change it to be between 0 and 1.0
     colorArray[0] = (((static_cast<int>(v->fValue) % 360) + 360) % 360) / 360.0;
     for (int i = 1; i < 3; i++) {
         args->next();
@@ skipping 10 matching lines @@
         if (!consumeComma(args))
             return false;
         v = args->current();
         if (!validUnit(v, FNumber))
             return false;
         colorArray[3] = std::max(0.0, std::min(1.0, v->fValue));
     }
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseColor(CSSParserValue* value, bool acceptQuirkyColors)
-{
-    RGBA32 c = Color::transparent;
-    if (!parseColorFromValue(value ? value : m_valueList->current(), c, acceptQuirkyColors))
-        return nullptr;
-    return cssValuePool().createColorValue(c);
-}
-
-bool CSSPropertyParser::parseColorFromValue(CSSParserValue* value, RGBA32& result, bool acceptQuirkyColors)
+bool CSSPropertyParser::parseColorFromValue(const CSSParserValue* value, RGBA32& result, bool acceptQuirkyColors)
 {
     if (acceptQuirkyColors && value->unit == CSSPrimitiveValue::CSS_NUMBER
         && value->fValue >= 0. && value->fValue < 1000000. && value->isInt) {
         String str = String::format("%06d", static_cast<int>(value->fValue));
         return Color::parseHexColor(str, result);
     } else if (acceptQuirkyColors && value->unit == CSSParserValue::DimensionList) {
         CSSParserValue* numberToken = value->valueList->valueAt(0);
         CSSParserValue* unitToken = value->valueList->valueAt(1);
         ASSERT(numberToken->unit == CSSPrimitiveValue::CSS_NUMBER);
         ASSERT(unitToken->unit == CSSPrimitiveValue::CSS_IDENT);
@@ skipping 198 matching lines @@
 
             // A length is allowed here.  Construct the value and add it.
             RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(val);
             context.commitLength(length.release());
         } else if (val->id == CSSValueInset) {
             if (!context.allowStyle)
                 return nullptr;
 
             context.commitStyle(val);
         } else {
+            if (!context.allowColor)
+                return nullptr;
+
             // The only other type of value that's ok is a color value.
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedColor = nullptr;
-            bool isColor = ((val->id >= CSSValueAqua && val->id <= CSSValueWindowtext) || val->id == CSSValueMenu
-                            || (val->id >= CSSValueWebkitFocusRingColor && val->id <= CSSValueWebkitText && inQuirksMode())
-                            || val->id == CSSValueCurrentcolor);
-            if (isColor) {
-                if (!context.allowColor)
-                    return nullptr;
-                parsedColor = cssValuePool().createIdentifierValue(val->id);
-            }
-
+            RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedColor = parseColor(val);
             if (!parsedColor)
-                // It's not built-in. Try to parse it as a color.
-                parsedColor = parseColor(val);
-
-            if (!parsedColor || !context.allowColor)
-                return nullptr; // This value is not a color or length and is invalid or
-                          // it is a color, but a color isn't allowed at this point.
+                return nullptr;
 
             context.commitColor(parsedColor.release());
         }
     }
 
     if (context.allowBreak) {
         context.commitValue();
         if (context.values && context.values->length())
             return context.values.release();
     }
@@ skipping 732 matching lines @@
     if (a->function->id == CSSValueFrom || a->function->id == CSSValueTo) {
         // The "from" and "to" stops expect 1 argument.
         if (args->size() != 1)
             return false;
 
         if (a->function->id == CSSValueFrom)
             stop.m_position = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_NUMBER);
         else
             stop.m_position = cssValuePool().createValue(1, CSSPrimitiveValue::CSS_NUMBER);
 
-        CSSValueID id = args->current()->id;
-        if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu)
-            stop.m_color = cssValuePool().createIdentifierValue(id);
-        else
-            stop.m_color = parseColor(args->current());
+        stop.m_color = parseDeprecatedGradientStopColor(args->current());
         if (!stop.m_color)
             return false;
     }
 
     // The "color-stop" function expects 3 arguments.
     if (a->function->id == CSSValueColorStop) {
         if (args->size() != 3)
             return false;
 
         CSSParserValue* stopArg = args->current();
         if (stopArg->unit == CSSPrimitiveValue::CSS_PERCENTAGE)
             stop.m_position = cssValuePool().createValue(stopArg->fValue / 100, CSSPrimitiveValue::CSS_NUMBER);
         else if (stopArg->unit == CSSPrimitiveValue::CSS_NUMBER)
             stop.m_position = cssValuePool().createValue(stopArg->fValue, CSSPrimitiveValue::CSS_NUMBER);
         else
             return false;
 
         args->next();
         if (!consumeComma(args))
             return false;
 
-        stopArg = args->current();
-        CSSValueID id = stopArg->id;
-        if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu)
-            stop.m_color = cssValuePool().createIdentifierValue(id);
-        else
-            stop.m_color = parseColor(stopArg);
+        stop.m_color = parseDeprecatedGradientStopColor(args->current());
         if (!stop.m_color)
             return false;
     }
 
     return true;
 }
 
 bool CSSPropertyParser::parseDeprecatedGradient(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& gradient)
 {
     // Walk the arguments.
@@ skipping 544 matching lines @@
                 return false;
 
             a = valueList->next();
             if (!a)
                 return false;
         }
 
         // <color-stop> = <color> [ <percentage> | <length> ]?
         // <color-hint> = <length> | <percentage>
         CSSGradientColorStop stop;
-        CSSValueID id = a->id;
-        if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor)
-            stop.m_color = cssValuePool().createIdentifierValue(id);
-        else
-            stop.m_color = parseColor(a);
-
+        stop.m_color = parseGradientStopColor(a);
 
         // Two hints in a row are not allowed.
         if (!stop.m_color && (!supportsColorHints || previousStopWasColorHint))
             return false;
         previousStopWasColorHint = !stop.m_color;
 
         if (stop.m_color)
             a = valueList->next();
 
         if (a) {
@@ skipping 989 matching lines @@
 {
     unsigned length = string.length();
     if (!length)
         return CSSValueInvalid;
     if (length > maxCSSValueKeywordLength)
         return CSSValueInvalid;
 
     return string.is8Bit() ? cssValueKeywordID(string.characters8(), length) : cssValueKeywordID(string.characters16(), length);
 }
 
-bool CSSPropertyParser::isSystemColor(int id)
+bool CSSPropertyParser::isSystemColor(CSSValueID id)
 {
     return (id >= CSSValueActiveborder && id <= CSSValueWindowtext) || id == CSSValueMenu;
 }
 
 bool CSSPropertyParser::parseSVGValue(CSSPropertyID propId, bool important)
 {
     CSSParserValue* value = m_valueList->current();
     ASSERT(value);
 
     CSSValueID id = value->id;
@@ skipping 123 matching lines @@
             parsedValue = CSSPrimitiveValue::create(value->fValue, CSSPrimitiveValue::CSS_DEG);
 
             if (parsedValue)
                 m_valueList->next();
         }
         break;
 
     case CSSPropertyFill: // <paint> | inherit
     case CSSPropertyStroke: // <paint> | inherit
         {
-            if (id == CSSValueNone || id == CSSValueCurrentcolor) {
+            if (id == CSSValueNone) {
                 parsedValue = cssValuePool().createIdentifierValue(id);
-            } else if (isSystemColor(id)) {
-                parsedValue = cssValuePool().createColorValue(LayoutTheme::theme().systemColor(id).rgb());
             } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
-                RGBA32 c = Color::transparent;
                 if (m_valueList->next()) {
                     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
                     values->append(CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_URI));
-                    if (parseColorFromValue(m_valueList->current(), c))
-                        parsedValue = cssValuePool().createColorValue(c);
-                    else if (m_valueList->current()->id == CSSValueNone || m_valueList->current()->id == CSSValueCurrentcolor)
+                    if (m_valueList->current()->id == CSSValueNone)
                         parsedValue = cssValuePool().createIdentifierValue(m_valueList->current()->id);
+                    else
+                        parsedValue = parseSVGColor(m_valueList->current());
                     if (parsedValue) {
                         values->append(parsedValue);
                         parsedValue = values;
                     }
                 }
                 if (!parsedValue)
                     parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_URI);
             } else {
-                parsedValue = parseColor();
+                parsedValue = parseSVGColor(m_valueList->current());
             }
 
             if (parsedValue)
                 m_valueList->next();
         }
         break;
 
     case CSSPropertyStopColor: // TODO : icccolor
     case CSSPropertyFloodColor:
     case CSSPropertyLightingColor:
-        if (isSystemColor(id))
-            parsedValue = cssValuePool().createColorValue(LayoutTheme::theme().systemColor(id).rgb());
-        else if (id == CSSValueCurrentcolor)
-            parsedValue = cssValuePool().createIdentifierValue(id);
-        else // TODO : svgcolor (iccColor)
-            parsedValue = parseColor();
-
+        parsedValue = parseSVGColor(m_valueList->current());
         if (parsedValue)
             m_valueList->next();
 
         break;
 
     case CSSPropertyPaintOrder:
         if (m_valueList->size() == 1 && id == CSSValueNormal)
             validPrimitive = true;
         else if ((parsedValue = parsePaintOrder()))
             m_valueList->next();
@@ skipping 397 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink