Only allow the -webkit-text color keyword in quirks/UA-sheet mode

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 1330 matching lines @@
         break;
 
     // End Apple-specific properties
 
     case CSSPropertyWebkitAppRegion:
         if (id >= CSSValueDrag && id <= CSSValueNoDrag)
             validPrimitive = true;
         break;
 
     case CSSPropertyWebkitTapHighlightColor:
-        parsedValue = parseTapHighlightColor(m_valueList->current());
+        parsedValue = parseColor(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,
@@ skipping 957 matching lines @@
         if (!isValueAllowedInMode(id, m_context.mode()))
             return nullptr;
         return cssValuePool().createIdentifierValue(id);
     }
     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;
-    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);
-}
-
 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));
         return true;
     }
@@ skipping 468 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(val);
+            currValue = parseColor(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 3183 matching lines @@
             || (a->id == CSSValueBottom && !horizontal))
             result = cssValuePool().createValue(100., CSSPrimitiveValue::CSS_PERCENTAGE);
         else if (a->id == CSSValueCenter)
             result = cssValuePool().createValue(50., CSSPrimitiveValue::CSS_PERCENTAGE);
     } else if (a->unit == CSSPrimitiveValue::CSS_NUMBER || a->unit == CSSPrimitiveValue::CSS_PERCENTAGE) {
         result = cssValuePool().createValue(a->fValue, static_cast<CSSPrimitiveValue::UnitType>(a->unit));
     }
     return result;
 }
 
+// Used to parse colors for -webkit-gradient(...).
+PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseDeprecatedGradientStopColor(const CSSParserValue* value)
+{
+    // Disallow currentcolor.
+    if (value->id == CSSValueCurrentcolor)
+        return nullptr;
+    return parseColor(value);
+}
+
 bool CSSPropertyParser::parseDeprecatedGradientColorStop(CSSParserValue* a, CSSGradientColorStop& stop)
 {
     if (a->unit != CSSParserValue::Function)
         return false;
 
     if (a->function->id != CSSValueFrom
         && a->function->id != CSSValueTo
         && a->function->id != CSSValueColorStop)
         return false;
 
@@ skipping 591 matching lines @@
                 return false;
 
             a = valueList->next();
             if (!a)
                 return false;
         }
 
         // <color-stop> = <color> [ <percentage> | <length> ]?
         // <color-hint> = <length> | <percentage>
         CSSGradientColorStop stop;
-        stop.m_color = parseGradientStopColor(a);
+        stop.m_color = parseColor(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 1580 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink