Cleanup <image> type handling

third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.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 270 matching lines @@
     valueList->next();
     return true;
 }
 
 static inline bool isForwardSlashOperator(CSSParserValue* value)
 {
     ASSERT(value);
     return value->m_unit == CSSParserValue::Operator && value->iValue == '/';
 }
 
-static bool isGeneratedImageValue(CSSParserValue* val)
+static bool isGeneratedImageValue(CSSValueID id)
 {
-    if (val->m_unit != CSSParserValue::Function)
-        return false;
-
-    CSSValueID id = val->function->id;
-    return id == CSSValueLinearGradient
-        || id == CSSValueRadialGradient
-        || id == CSSValueRepeatingLinearGradient
-        || id == CSSValueRepeatingRadialGradient
-        || id == CSSValueWebkitLinearGradient
-        || id == CSSValueWebkitRadialGradient
-        || id == CSSValueWebkitRepeatingLinearGradient
-        || id == CSSValueWebkitRepeatingRadialGradient
-        || id == CSSValueWebkitGradient
-        || id == CSSValueWebkitCrossFade;
+    return id == CSSValueLinearGradient || id == CSSValueRadialGradient
+        || id == CSSValueRepeatingLinearGradient || id == CSSValueRepeatingRadialGradient
+        || id == CSSValueWebkitLinearGradient || id == CSSValueWebkitRadialGradient
+        || id == CSSValueWebkitRepeatingLinearGradient || id == CSSValueWebkitRepeatingRadialGradient
+        || id == CSSValueWebkitGradient || id == CSSValueWebkitCrossFade;
 }
 
 inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseValidPrimitive(CSSValueID identifier, CSSParserValue* value)
 {
     if (identifier)
         return cssValuePool().createIdentifierValue(identifier);
     if (value->unit() >= CSSPrimitiveValue::UnitType::Number && value->unit() <= CSSPrimitiveValue::UnitType::Kilohertz)
         return createPrimitiveNumericValue(value);
     if (value->unit() >= CSSPrimitiveValue::UnitType::Turns && value->unit() <= CSSPrimitiveValue::UnitType::Chs)
         return createPrimitiveNumericValue(value);
@@ skipping 198 matching lines @@
                     addProperty(propId2, val2.release(), important);
             }
             result = true;
         }
         m_implicitShorthand = false;
         return result;
     }
     case CSSPropertyListStyleImage:     // <uri> | none | inherit
     case CSSPropertyBorderImageSource:
     case CSSPropertyWebkitMaskBoxImageSource:
-        if (id == CSSValueNone) {
-            parsedValue = cssValuePool().createIdentifierValue(CSSValueNone);
+        if (parseFillImage(m_valueList, parsedValue))
             m_valueList->next();
-        } else if (value->m_unit == CSSParserValue::URI) {
-            parsedValue = createCSSImageValueWithReferrer(value->string, completeURL(value->string));
-            m_valueList->next();
-        } else if (isGeneratedImageValue(value)) {
-            if (parseGeneratedImage(m_valueList, parsedValue))
-                m_valueList->next();
-            else
-                return false;
-        } else if (value->m_unit == CSSParserValue::Function && value->function->id == CSSValueWebkitImageSet) {
-            parsedValue = parseImageSet(m_valueList);
-            if (!parsedValue)
-                return false;
-            m_valueList->next();
-        }
         break;
 
     case CSSPropertyBorderTopWidth:     //// <border-width> | inherit
     case CSSPropertyBorderRightWidth:   //   Which is defined as
     case CSSPropertyBorderBottomWidth:  //   thin | medium | thick | <length>
     case CSSPropertyBorderLeftWidth:
         if (!inShorthand() || m_currentShorthand == CSSPropertyBorderWidth)
             unitless = FUnitlessQuirk;
         if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)
             validPrimitive = true;
@@ skipping 889 matching lines @@
             if (!args)
                 return nullptr;
             if (val->function->id == CSSValueAttr) {
                 parsedValue = parseAttr(args);
             } else if (val->function->id == CSSValueCounter) {
                 parsedValue = parseCounterContent(args, false);
             } else if (val->function->id == CSSValueCounters) {
                 parsedValue = parseCounterContent(args, true);
             } else if (val->function->id == CSSValueWebkitImageSet) {
                 parsedValue = parseImageSet(m_valueList);
-            } else if (isGeneratedImageValue(val)) {
+            } else if (isGeneratedImageValue(val->function->id)) {
                 if (!parseGeneratedImage(m_valueList, parsedValue))
                     return nullptr;
             }
         } else if (val->m_unit == CSSParserValue::Identifier) {
             switch (val->id) {
             case CSSValueOpenQuote:
             case CSSValueCloseQuote:
             case CSSValueNoOpenQuote:
             case CSSValueNoCloseQuote:
             case CSSValueNone:
@@ skipping 88 matching lines @@
 {
     if (valueList->current()->id == CSSValueNone) {
         value = cssValuePool().createIdentifierValue(CSSValueNone);
         return true;
     }
     if (valueList->current()->m_unit == CSSParserValue::URI) {
         value = createCSSImageValueWithReferrer(valueList->current()->string, completeURL(valueList->current()->string));
         return true;
     }
 
-    if (isGeneratedImageValue(valueList->current()))
-        return parseGeneratedImage(valueList, value);
+    if (valueList->current()->m_unit == CSSParserValue::Function) {
+        if (isGeneratedImageValue(valueList->current()->function->id))
+            return parseGeneratedImage(valueList, value);
 
-    if (valueList->current()->m_unit == CSSParserValue::Function && valueList->current()->function->id == CSSValueWebkitImageSet) {
-        value = parseImageSet(m_valueList);
-        if (value)
-            return true;
+        if (valueList->current()->function->id == CSSValueWebkitImageSet) {
+            value = parseImageSet(m_valueList);
+            if (value)
+                return true;
+        }
     }
 
     return false;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFillPositionX(CSSParserValueList* valueList)
 {
     int id = valueList->current()->id;
     if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueCenter) {
         int percent = 0;
@@ skipping 2311 matching lines @@
     CSSPropertyParser::ShorthandScope scope(this, propId);
     while (CSSParserValue* val = m_valueList->current()) {
         context.setCanAdvance(false);
 
         if (!context.canAdvance() && context.allowForwardSlashOperator() && isForwardSlashOperator(val))
             context.commitForwardSlashOperator();
 
         if (!context.canAdvance() && context.allowImage()) {
             if (val->m_unit == CSSParserValue::URI) {
                 context.commitImage(createCSSImageValueWithReferrer(val->string, m_context.completeURL(val->string)));
-            } else if (isGeneratedImageValue(val)) {
-                RefPtrWillBeRawPtr<CSSValue> value = nullptr;
-                if (parseGeneratedImage(m_valueList, value))
-                    context.commitImage(value.release());
-                else
-                    return false;
-            } else if (val->m_unit == CSSParserValue::Function && val->function->id == CSSValueWebkitImageSet) {
-                RefPtrWillBeRawPtr<CSSValue> value = parseImageSet(m_valueList);
-                if (value)
-                    context.commitImage(value.release());
-                else
-                    return false;
+            } else if (val->m_unit == CSSParserValue::Function) {
+                if (isGeneratedImageValue(val->function->id)) {
+                    RefPtrWillBeRawPtr<CSSValue> value = nullptr;
+                    if (parseGeneratedImage(m_valueList, value))
+                        context.commitImage(value.release());
+                    else
+                        return false;
+                } else if (val->function->id == CSSValueWebkitImageSet) {
+                    RefPtrWillBeRawPtr<CSSValue> value = parseImageSet(m_valueList);
+                    if (value)
+                        context.commitImage(value.release());
+                    else
+                        return false;
+                }
             } else if (val->id == CSSValueNone)
                 context.commitImage(cssValuePool().createIdentifierValue(CSSValueNone));
         }
 
         if (!context.canAdvance() && context.allowImageSlice()) {
             RefPtrWillBeRawPtr<CSSBorderImageSliceValue> imageSlice = nullptr;
             if (parseBorderImageSlice(propId, imageSlice))
                 context.commitImageSlice(imageSlice.release());
         }
 
@@ skipping 1344 matching lines @@
 
     return string.is8Bit() ? cssValueKeywordID(string.characters8(), length) : cssValueKeywordID(string.characters16(), length);
 }
 
 bool CSSPropertyParser::isSystemColor(CSSValueID id)
 {
     return (id >= CSSValueActiveborder && id <= CSSValueWindowtext) || id == CSSValueMenu;
 }
 
 } // namespace blink