Remove CSS clients of ImageResource

sky/engine/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 16 matching lines @@
 #include "sky/engine/core/css/parser/CSSPropertyParser.h"
 
 // FIXME: Way too many!
 #include <limits.h>
 #include "gen/sky/core/CSSValueKeywords.h"
 #include "gen/sky/core/StylePropertyShorthand.h"
 #include "gen/sky/platform/RuntimeEnabledFeatures.h"
 #include "sky/engine/core/css/CSSAspectRatioValue.h"
 #include "sky/engine/core/css/CSSBasicShapes.h"
 #include "sky/engine/core/css/CSSBorderImage.h"
-#include "sky/engine/core/css/CSSCrossfadeValue.h"
 #include "sky/engine/core/css/CSSFontFaceSrcValue.h"
 #include "sky/engine/core/css/CSSFontFeatureValue.h"
 #include "sky/engine/core/css/CSSFunctionValue.h"
 #include "sky/engine/core/css/CSSGradientValue.h"
-#include "sky/engine/core/css/CSSImageSetValue.h"
-#include "sky/engine/core/css/CSSImageValue.h"
 #include "sky/engine/core/css/CSSInheritedValue.h"
 #include "sky/engine/core/css/CSSInitialValue.h"
 #include "sky/engine/core/css/CSSLineBoxContainValue.h"
 #include "sky/engine/core/css/CSSPrimitiveValue.h"
 #include "sky/engine/core/css/CSSPropertyMetadata.h"
 #include "sky/engine/core/css/CSSPropertySourceData.h"
 #include "sky/engine/core/css/CSSSelector.h"
 #include "sky/engine/core/css/CSSShadowValue.h"
 #include "sky/engine/core/css/CSSTimingFunctionValue.h"
 #include "sky/engine/core/css/CSSTransformValue.h"
@@ skipping 243 matching lines @@
         || (value->unit >= CSSPrimitiveValue::CSS_DPPX && value->unit <= CSSPrimitiveValue::CSS_DPCM));
     return cssValuePool().createValue(value->fValue, static_cast<CSSPrimitiveValue::UnitType>(value->unit));
 }
 
 inline PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value)
 {
     ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT);
     return cssValuePool().createValue(value->string, CSSPrimitiveValue::CSS_STRING);
 }
 
-inline PassRefPtr<CSSValue> CSSPropertyParser::createCSSImageValueWithReferrer(const String& rawValue, const KURL& url)
-{
-    RefPtr<CSSValue> imageValue = CSSImageValue::create(rawValue, url);
-    toCSSImageValue(imageValue.get())->setReferrer(m_context.referrer());
-    return imageValue;
-}
-
 static inline bool isComma(CSSParserValue* value)
 {
     return value && value->unit == CSSParserValue::Operator && value->iValue == ',';
 }
 
 static bool consumeComma(CSSParserValueList* valueList)
 {
     if (!isComma(valueList->current()))
         return false;
     valueList->next();
@@ skipping 250 matching lines @@
         return result;
     }
     case CSSPropertyObjectPosition:
         ASSERT(RuntimeEnabledFeatures::objectFitPositionEnabled());
         parsedValue = parseObjectPosition();
         break;
     case CSSPropertyBorderImageSource:
         if (id == CSSValueNone) {
             parsedValue = cssValuePool().createIdentifierValue(CSSValueNone);
             m_valueList->next();
-        } else if (value->unit == CSSPrimitiveValue::CSS_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->unit == CSSParserValue::Function && equalIgnoringCase(value->function->name, "-webkit-image-set(")) {
-            parsedValue = parseImageSet(m_valueList);
-            if (!parsedValue)
-                return false;
-            m_valueList->next();
-        }
         break;
 
     case CSSPropertyWebkitTextStrokeWidth:
     case CSSPropertyOutlineWidth:        // <border-width> | inherit
     case CSSPropertyBorderTopWidth:     //// <border-width> | inherit
     case CSSPropertyBorderRightWidth:   //   Which is defined as
     case CSSPropertyBorderBottomWidth:  //   thin | medium | thick | <length>
     case CSSPropertyBorderLeftWidth:
     case CSSPropertyWebkitBorderStartWidth:
     case CSSPropertyWebkitBorderEndWidth:
@@ skipping 966 matching lines @@
         return cssValuePool().createIdentifierValue(id);
     return parseColor();
 }
 
 bool CSSPropertyParser::parseFillImage(CSSParserValueList* valueList, RefPtr<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;
-    }
 
     if (isGeneratedImageValue(valueList->current()))
         return parseGeneratedImage(valueList, value);
 
-    if (valueList->current()->unit == CSSParserValue::Function && equalIgnoringCase(valueList->current()->function->name, "-webkit-image-set(")) {
-        value = parseImageSet(m_valueList);
-        if (value)
-            return true;
-    }
-
     return false;
 }
 
 PassRefPtr<CSSValue> CSSPropertyParser::parseFillPositionX(CSSParserValueList* valueList)
 {
     int id = valueList->current()->id;
     if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueCenter) {
         int percent = 0;
         if (id == CSSValueRight)
             percent = 100;
@@ skipping 2625 matching lines @@
 bool BorderImageParseContext::buildFromParser(CSSPropertyParser& parser, CSSPropertyID propId, BorderImageParseContext& context)
 {
     CSSPropertyParser::ShorthandScope scope(&parser, propId);
     while (CSSParserValue* val = parser.m_valueList->current()) {
         context.setCanAdvance(false);
 
         if (!context.canAdvance() && context.allowForwardSlashOperator() && isForwardSlashOperator(val))
             context.commitForwardSlashOperator();
 
         if (!context.canAdvance() && context.allowImage()) {
-            if (val->unit == CSSPrimitiveValue::CSS_URI) {
-                context.commitImage(parser.createCSSImageValueWithReferrer(val->string, parser.m_context.completeURL(val->string)));
-            } else if (isGeneratedImageValue(val)) {
+            if (isGeneratedImageValue(val)) {
                 RefPtr<CSSValue> value = nullptr;
                 if (parser.parseGeneratedImage(parser.m_valueList, value))
                     context.commitImage(value.release());
                 else
                     return false;
-            } else if (val->unit == CSSParserValue::Function && equalIgnoringCase(val->function->name, "-webkit-image-set(")) {
-                RefPtr<CSSValue> value = parser.parseImageSet(parser.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()) {
             RefPtr<CSSBorderImageSliceValue> imageSlice = nullptr;
             if (parser.parseBorderImageSlice(propId, imageSlice))
                 context.commitImageSlice(imageSlice.release());
         }
 
@@ skipping 671 matching lines @@
 
     if (equalIgnoringCase(val->function->name, "repeating-linear-gradient("))
         return parseLinearGradient(valueList, value, Repeating);
 
     if (equalIgnoringCase(val->function->name, "radial-gradient("))
         return parseRadialGradient(valueList, value, NonRepeating);
 
     if (equalIgnoringCase(val->function->name, "repeating-radial-gradient("))
         return parseRadialGradient(valueList, value, Repeating);
 
-    if (equalIgnoringCase(val->function->name, "-webkit-cross-fade("))
-        return parseCrossfade(valueList, value);
-
     return false;
 }
 
-bool CSSPropertyParser::parseCrossfade(CSSParserValueList* valueList, RefPtr<CSSValue>& crossfade)
-{
-    // Walk the arguments.
-    CSSParserValueList* args = valueList->current()->function->args.get();
-    if (!args || args->size() != 5)
-        return false;
-    RefPtr<CSSValue> fromImageValue = nullptr;
-    RefPtr<CSSValue> toImageValue = nullptr;
-
-    // The first argument is the "from" image. It is a fill image.
-    if (!args->current() || !parseFillImage(args, fromImageValue))
-        return false;
-    args->next();
-
-    if (!consumeComma(args))
-        return false;
-
-    // The second argument is the "to" image. It is a fill image.
-    if (!args->current() || !parseFillImage(args, toImageValue))
-        return false;
-    args->next();
-
-    if (!consumeComma(args))
-        return false;
-
-    // The third argument is the crossfade value. It is a percentage or a fractional number.
-    RefPtr<CSSPrimitiveValue> percentage = nullptr;
-    CSSParserValue* value = args->current();
-    if (!value)
-        return false;
-
-    if (value->unit == CSSPrimitiveValue::CSS_PERCENTAGE)
-        percentage = cssValuePool().createValue(clampTo<double>(value->fValue / 100, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
-    else if (value->unit == CSSPrimitiveValue::CSS_NUMBER)
-        percentage = cssValuePool().createValue(clampTo<double>(value->fValue, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
-    else
-        return false;
-
-    RefPtr<CSSCrossfadeValue> result = CSSCrossfadeValue::create(fromImageValue, toImageValue);
-    result->setPercentage(percentage);
-
-    crossfade = result;
-
-    return true;
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseImageSet(CSSParserValueList* valueList)
-{
-    CSSParserValue* function = valueList->current();
-
-    if (function->unit != CSSParserValue::Function)
-        return nullptr;
-
-    CSSParserValueList* functionArgs = valueList->current()->function->args.get();
-    if (!functionArgs || !functionArgs->size() || !functionArgs->current())
-        return nullptr;
-
-    RefPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
-
-    while (functionArgs->current()) {
-        CSSParserValue* arg = functionArgs->current();
-        if (arg->unit != CSSPrimitiveValue::CSS_URI)
-            return nullptr;
-
-        RefPtr<CSSValue> image = createCSSImageValueWithReferrer(arg->string, completeURL(arg->string));
-        imageSet->append(image);
-
-        arg = functionArgs->next();
-        if (!arg || arg->unit != CSSPrimitiveValue::CSS_DIMENSION)
-            return nullptr;
-
-        double imageScaleFactor = 0;
-        const String& string = arg->string;
-        unsigned length = string.length();
-        if (!length)
-            return nullptr;
-        if (string.is8Bit()) {
-            const LChar* start = string.characters8();
-            parseDouble(start, start + length, 'x', imageScaleFactor);
-        } else {
-            const UChar* start = string.characters16();
-            parseDouble(start, start + length, 'x', imageScaleFactor);
-        }
-        if (imageScaleFactor <= 0)
-            return nullptr;
-        imageSet->append(cssValuePool().createValue(imageScaleFactor, CSSPrimitiveValue::CSS_NUMBER));
-        functionArgs->next();
-
-        // If there are no more arguments, we're done.
-        if (!functionArgs->current())
-            break;
-
-        // If there are more arguments, they should be after a comma.
-        if (!consumeComma(functionArgs))
-            return nullptr;
-    }
-
-    return imageSet.release();
-}
-
 PassRefPtr<CSSValue> CSSPropertyParser::parseWillChange()
 {
     RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
     if (m_valueList->current()->id == CSSValueAuto) {
         // FIXME: This will be read back as an empty string instead of auto
         return values.release();
     }
 
     // Every comma-separated list of CSS_IDENTs is a valid will-change value,
     // unless the list includes an explicitly disallowed CSS_IDENT.
@@ skipping 759 matching lines @@
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 bool CSSPropertyParser::isSystemColor(int id)
 {
     // FIXME(sky): remove
     return false;
 }
 
 } // namespace blink