Remove Animations and Transitions.

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 27 matching lines @@
 #include "sky/engine/core/css/CSSFunctionValue.h"
 #include "sky/engine/core/css/CSSGradientValue.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"
 #include "sky/engine/core/css/CSSUnicodeRangeValue.h"
 #include "sky/engine/core/css/CSSValueList.h"
 #include "sky/engine/core/css/CSSValuePool.h"
 #include "sky/engine/core/css/HashTools.h"
 #include "sky/engine/core/css/Pair.h"
 #include "sky/engine/core/css/Rect.h"
 #include "sky/engine/core/css/parser/BisonCSSParser.h"
 #include "sky/engine/core/css/parser/CSSParserIdioms.h"
 #include "sky/engine/core/css/parser/CSSParserValues.h"
@@ skipping 857 matching lines @@
             return false;
         RefPtr<CSSValue> originX = nullptr;
         RefPtr<CSSValue> originY = nullptr;
         parse2ValuesFillPosition(m_valueList, originX, originY);
         if (!originX)
             return false;
         addProperty(CSSPropertyWebkitPerspectiveOriginX, originX.release());
         addProperty(CSSPropertyWebkitPerspectiveOriginY, originY.release());
         return true;
     }
-    case CSSPropertyAnimationDelay:
-    case CSSPropertyAnimationDirection:
-    case CSSPropertyAnimationDuration:
-    case CSSPropertyAnimationFillMode:
-    case CSSPropertyAnimationName:
-    case CSSPropertyAnimationPlayState:
-    case CSSPropertyAnimationIterationCount:
-    case CSSPropertyAnimationTimingFunction:
-    case CSSPropertyTransitionDelay:
-    case CSSPropertyTransitionDuration:
-    case CSSPropertyTransitionTimingFunction:
-    case CSSPropertyTransitionProperty: {
-        if (RefPtr<CSSValueList> val = parseAnimationPropertyList(propId)) {
-            addProperty(propId, val.release());
-            return true;
-        }
-        return false;
-    }
-
-    case CSSPropertyWillChange:
-        parsedValue = parseWillChange();
-        break;
     // End of CSS3 properties
 
     // Apple specific properties.  These will never be standardized and are purely to
     // support custom WebKit-based Apple applications.
     case CSSPropertyWebkitFontSizeDelta:           // <length>
         validPrimitive = validUnit(value, FLength);
         break;
 
     case CSSPropertyWebkitHighlight:
         if (id == CSSValueNone || value->unit == CSSPrimitiveValue::CSS_STRING)
@@ skipping 77 matching lines @@
         // <padding-width>{1,4} | inherit
         return parse4Values(propId, paddingShorthand().properties());
     case CSSPropertyFlexFlow:
         return parseShorthand(propId, flexFlowShorthand());
     case CSSPropertyFont:
         // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]?
         // 'font-family' ] | inherit
         return parseFont();
     case CSSPropertyWebkitTextStroke:
         return parseShorthand(propId, webkitTextStrokeShorthand());
-    case CSSPropertyAnimation:
-        return parseAnimationShorthand(propId);
-    case CSSPropertyTransition:
-        return parseTransitionShorthand(propId);
     case CSSPropertyInvalid:
         return false;
     // CSS Text Layout Module Level 3: Vertical writing support
     case CSSPropertyWebkitTextEmphasis:
         return parseShorthand(propId, webkitTextEmphasisShorthand());
 
     case CSSPropertyWebkitTextEmphasisStyle:
         return parseTextEmphasisStyle();
 
     case CSSPropertyWebkitTextOrientation:
@@ skipping 224 matching lines @@
 
         // Add in clip values when we hit the corresponding origin property.
         if (properties[i] == CSSPropertyBackgroundOrigin && !foundClip)
             addProperty(CSSPropertyBackgroundClip, clipValue.release());
     }
 
     m_implicitShorthand = false;
     return true;
 }
 
-static bool isValidTransitionPropertyList(CSSValueList* value)
-{
-    if (value->length() < 2)
-        return true;
-    for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
-        // FIXME: Shorthand parsing shouldn't add initial to the list since it won't round-trip
-        if (i.value()->isInitialValue())
-            continue;
-        CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(i.value());
-        if (primitiveValue->isValueID() && primitiveValue->getValueID() == CSSValueNone)
-            return false;
-    }
-    return true;
-}
-
-bool CSSPropertyParser::parseAnimationShorthand(CSSPropertyID propId)
-{
-    const StylePropertyShorthand& animationProperties = parsingShorthandForProperty(propId);
-    const unsigned numProperties = 8;
-
-    // The list of properties in the shorthand should be the same
-    // length as the list with animation name in last position, even though they are
-    // in a different order.
-    ASSERT(numProperties == animationProperties.length());
-    ASSERT(numProperties == shorthandForProperty(propId).length());
-
-    ShorthandScope scope(this, propId);
-
-    bool parsedProperty[numProperties] = { false };
-    RefPtr<CSSValueList> values[numProperties];
-    for (size_t i = 0; i < numProperties; ++i)
-        values[i] = CSSValueList::createCommaSeparated();
-
-    while (m_valueList->current()) {
-        if (consumeComma(m_valueList)) {
-            // We hit the end. Fill in all remaining values with the initial value.
-            for (size_t i = 0; i < numProperties; ++i) {
-                if (!parsedProperty[i])
-                    values[i]->append(cssValuePool().createImplicitInitialValue());
-                parsedProperty[i] = false;
-            }
-            if (!m_valueList->current())
-                break;
-        }
-
-        bool found = false;
-        for (size_t i = 0; i < numProperties; ++i) {
-            if (parsedProperty[i])
-                continue;
-            if (RefPtr<CSSValue> val = parseAnimationProperty(animationProperties.properties()[i])) {
-                parsedProperty[i] = found = true;
-                values[i]->append(val.release());
-                break;
-            }
-        }
-
-        // if we didn't find at least one match, this is an
-        // invalid shorthand and we have to ignore it
-        if (!found)
-            return false;
-    }
-
-    for (size_t i = 0; i < numProperties; ++i) {
-        // If we didn't find the property, set an intial value.
-        if (!parsedProperty[i])
-            values[i]->append(cssValuePool().createImplicitInitialValue());
-
-        addProperty(animationProperties.properties()[i], values[i].release());
-    }
-
-    return true;
-}
-
-bool CSSPropertyParser::parseTransitionShorthand(CSSPropertyID propId)
-{
-    const unsigned numProperties = 4;
-    const StylePropertyShorthand& shorthand = parsingShorthandForProperty(propId);
-    ASSERT(numProperties == shorthand.length());
-
-    ShorthandScope scope(this, propId);
-
-    bool parsedProperty[numProperties] = { false };
-    RefPtr<CSSValueList> values[numProperties];
-    for (size_t i = 0; i < numProperties; ++i)
-        values[i] = CSSValueList::createCommaSeparated();
-
-    while (m_valueList->current()) {
-        if (consumeComma(m_valueList)) {
-            // We hit the end. Fill in all remaining values with the initial value.
-            for (size_t i = 0; i < numProperties; ++i) {
-                if (!parsedProperty[i])
-                    values[i]->append(cssValuePool().createImplicitInitialValue());
-                parsedProperty[i] = false;
-            }
-            if (!m_valueList->current())
-                break;
-        }
-
-        bool found = false;
-        for (size_t i = 0; i < numProperties; ++i) {
-            if (parsedProperty[i])
-                continue;
-            if (RefPtr<CSSValue> val = parseAnimationProperty(shorthand.properties()[i])) {
-                parsedProperty[i] = found = true;
-                values[i]->append(val.release());
-                break;
-            }
-        }
-
-        // if we didn't find at least one match, this is an
-        // invalid shorthand and we have to ignore it
-        if (!found)
-            return false;
-    }
-
-    ASSERT(shorthand.properties()[3] == CSSPropertyTransitionProperty);
-    if (!isValidTransitionPropertyList(values[3].get()))
-        return false;
-
-    // Fill in any remaining properties with the initial value and add
-    for (size_t i = 0; i < numProperties; ++i) {
-        if (!parsedProperty[i])
-            values[i]->append(cssValuePool().createImplicitInitialValue());
-        addProperty(shorthand.properties()[i], values[i].release());
-    }
-
-    return true;
-}
-
 bool CSSPropertyParser::parseShorthand(CSSPropertyID propId, const StylePropertyShorthand& shorthand)
 {
     // We try to match as many properties as possible
     // We set up an array of booleans to mark which property has been found,
     // and we try to search for properties until it makes no longer any sense.
     ShorthandScope scope(this, propId);
 
     bool found = false;
     unsigned propertiesParsed = 0;
     bool propertyFound[6] = { false, false, false, false, false, false }; // 6 is enough size.
@@ skipping 712 matching lines @@
         return true;
     }
     if (value) {
         retValue1 = value.release();
         retValue2 = value2.release();
         return true;
     }
     return false;
 }
 
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationDelay()
-{
-    CSSParserValue* value = m_valueList->current();
-    if (validUnit(value, FTime))
-        return createPrimitiveNumericValue(value);
-    return nullptr;
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationDirection()
-{
-    CSSParserValue* value = m_valueList->current();
-    if (value->id == CSSValueNormal || value->id == CSSValueAlternate || value->id == CSSValueReverse || value->id == CSSValueAlternateReverse)
-        return cssValuePool().createIdentifierValue(value->id);
-    return nullptr;
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationDuration()
-{
-    CSSParserValue* value = m_valueList->current();
-    if (validUnit(value, FTime | FNonNeg))
-        return createPrimitiveNumericValue(value);
-    return nullptr;
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationFillMode()
-{
-    CSSParserValue* value = m_valueList->current();
-    if (value->id == CSSValueNone || value->id == CSSValueForwards || value->id == CSSValueBackwards || value->id == CSSValueBoth)
-        return cssValuePool().createIdentifierValue(value->id);
-    return nullptr;
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationIterationCount()
-{
-    CSSParserValue* value = m_valueList->current();
-    if (value->id == CSSValueInfinite)
-        return cssValuePool().createIdentifierValue(value->id);
-    if (validUnit(value, FNumber | FNonNeg))
-        return createPrimitiveNumericValue(value);
-    return nullptr;
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationName()
-{
-    CSSParserValue* value = m_valueList->current();
-    if (value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT) {
-        if (value->id == CSSValueNone || (value->unit == CSSPrimitiveValue::CSS_STRING && equalIgnoringCase(value, "none"))) {
-            return cssValuePool().createIdentifierValue(CSSValueNone);
-        } else {
-            return createPrimitiveStringValue(value);
-        }
-    }
-    return nullptr;
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationPlayState()
-{
-    CSSParserValue* value = m_valueList->current();
-    if (value->id == CSSValueRunning || value->id == CSSValuePaused)
-        return cssValuePool().createIdentifierValue(value->id);
-    return nullptr;
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationProperty()
-{
-    CSSParserValue* value = m_valueList->current();
-    if (value->unit != CSSPrimitiveValue::CSS_IDENT)
-        return nullptr;
-    // Since all is valid css property keyword, cssPropertyID for all
-    // returns non-null value. We need to check "all" before
-    // cssPropertyID check.
-    if (value->id == CSSValueAll)
-        return cssValuePool().createIdentifierValue(CSSValueAll);
-    CSSPropertyID property = cssPropertyID(value->string);
-    if (property) {
-        ASSERT(CSSPropertyMetadata::isEnabledProperty(property));
-        return cssValuePool().createIdentifierValue(property);
-    }
-    if (value->id == CSSValueNone)
-        return cssValuePool().createIdentifierValue(CSSValueNone);
-    if (value->id == CSSValueInitial || value->id == CSSValueInherit)
-        return nullptr;
-    return createPrimitiveStringValue(value);
-}
-
 bool CSSPropertyParser::parseWebkitTransformOriginShorthand()
 {
     RefPtr<CSSValue> originX = nullptr;
     RefPtr<CSSValue> originY = nullptr;
     RefPtr<CSSValue> originZ = nullptr;
 
     parse2ValuesFillPosition(m_valueList, originX, originY);
 
     if (m_valueList->current()) {
         if (!validUnit(m_valueList->current(), FLength))
             return false;
         originZ = createPrimitiveNumericValue(m_valueList->current());
         m_valueList->next();
     } else {
         originZ = cssValuePool().createImplicitInitialValue();
     }
 
     addProperty(CSSPropertyWebkitTransformOriginX, originX.release());
     addProperty(CSSPropertyWebkitTransformOriginY, originY.release());
     addProperty(CSSPropertyWebkitTransformOriginZ, originZ.release());
 
     return true;
 }
 
-bool CSSPropertyParser::parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result)
-{
-    CSSParserValue* v = args->current();
-    if (!validUnit(v, FNumber))
-        return false;
-    result = v->fValue;
-    v = args->next();
-    if (!v)
-        // The last number in the function has no comma after it, so we're done.
-        return true;
-    return consumeComma(args);
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationTimingFunction()
-{
-    CSSParserValue* value = m_valueList->current();
-    if (value->id == CSSValueEase || value->id == CSSValueLinear || value->id == CSSValueEaseIn || value->id == CSSValueEaseOut
-        || value->id == CSSValueEaseInOut || value->id == CSSValueStepStart || value->id == CSSValueStepEnd
-        || value->id == CSSValueStepMiddle)
-        return cssValuePool().createIdentifierValue(value->id);
-
-    // We must be a function.
-    if (value->unit != CSSParserValue::Function)
-        return nullptr;
-
-    CSSParserValueList* args = value->function->args.get();
-
-    if (equalIgnoringCase(value->function->name, "steps(")) {
-        // For steps, 1 or 2 params must be specified (comma-separated)
-        if (!args || (args->size() != 1 && args->size() != 3))
-            return nullptr;
-
-        // There are two values.
-        int numSteps;
-        StepsTimingFunction::StepAtPosition stepAtPosition = StepsTimingFunction::StepAtEnd;
-
-        CSSParserValue* v = args->current();
-        if (!validUnit(v, FInteger))
-            return nullptr;
-        numSteps = clampToInteger(v->fValue);
-        if (numSteps < 1)
-            return nullptr;
-
-        if (args->next()) {
-            // There is a comma so we need to parse the second value
-            if (!consumeComma(args))
-                return nullptr;
-            switch (args->current()->id) {
-            case CSSValueMiddle:
-                stepAtPosition = StepsTimingFunction::StepAtMiddle;
-                break;
-            case CSSValueStart:
-                stepAtPosition = StepsTimingFunction::StepAtStart;
-                break;
-            case CSSValueEnd:
-                stepAtPosition = StepsTimingFunction::StepAtEnd;
-                break;
-            default:
-                return nullptr;
-            }
-        }
-
-        return CSSStepsTimingFunctionValue::create(numSteps, stepAtPosition);
-    }
-
-    if (equalIgnoringCase(value->function->name, "cubic-bezier(")) {
-        // For cubic bezier, 4 values must be specified.
-        if (!args || args->size() != 7)
-            return nullptr;
-
-        // There are two points specified. The x values must be between 0 and 1 but the y values can exceed this range.
-        double x1, y1, x2, y2;
-
-        if (!parseCubicBezierTimingFunctionValue(args, x1))
-            return nullptr;
-        if (x1 < 0 || x1 > 1)
-            return nullptr;
-        if (!parseCubicBezierTimingFunctionValue(args, y1))
-            return nullptr;
-        if (!parseCubicBezierTimingFunctionValue(args, x2))
-            return nullptr;
-        if (x2 < 0 || x2 > 1)
-            return nullptr;
-        if (!parseCubicBezierTimingFunctionValue(args, y2))
-            return nullptr;
-
-        return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
-    }
-
-    return nullptr;
-}
-
-PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationProperty(CSSPropertyID propId)
-{
-    RefPtr<CSSValue> value = nullptr;
-    switch (propId) {
-    case CSSPropertyAnimationDelay:
-    case CSSPropertyTransitionDelay:
-        value = parseAnimationDelay();
-        break;
-    case CSSPropertyAnimationDirection:
-        value = parseAnimationDirection();
-        break;
-    case CSSPropertyAnimationDuration:
-    case CSSPropertyTransitionDuration:
-        value = parseAnimationDuration();
-        break;
-    case CSSPropertyAnimationFillMode:
-        value = parseAnimationFillMode();
-        break;
-    case CSSPropertyAnimationIterationCount:
-        value = parseAnimationIterationCount();
-        break;
-    case CSSPropertyAnimationName:
-        value = parseAnimationName();
-        break;
-    case CSSPropertyAnimationPlayState:
-        value = parseAnimationPlayState();
-        break;
-    case CSSPropertyTransitionProperty:
-        value = parseAnimationProperty();
-        break;
-    case CSSPropertyAnimationTimingFunction:
-    case CSSPropertyTransitionTimingFunction:
-        value = parseAnimationTimingFunction();
-        break;
-    default:
-        ASSERT_NOT_REACHED();
-        return nullptr;
-    }
-
-    if (value)
-        m_valueList->next();
-    return value.release();
-}
-
-PassRefPtr<CSSValueList> CSSPropertyParser::parseAnimationPropertyList(CSSPropertyID propId)
-{
-    RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
-    while (m_valueList->current()) {
-        RefPtr<CSSValue> value = parseAnimationProperty(propId);
-        if (!value)
-            return nullptr;
-        list->append(value.release());
-        if (CSSParserValue* parserValue = m_valueList->current()) {
-            if (!isComma(parserValue))
-                return nullptr;
-            m_valueList->next();
-            ASSERT(m_valueList->current());
-        }
-    }
-    if (propId == CSSPropertyTransitionProperty && !isValidTransitionPropertyList(list.get()))
-        return nullptr;
-    ASSERT(list->length());
-    return list.release();
-}
-
 static inline bool isCSSWideKeyword(CSSParserValue& value)
 {
     return value.id == CSSValueInitial || value.id == CSSValueInherit || value.id == CSSValueDefault;
 }
 
 bool CSSPropertyParser::parseClipShape(CSSPropertyID propId)
 {
     CSSParserValue* value = m_valueList->current();
     CSSParserValueList* args = value->function->args.get();
 
@@ skipping 2388 matching lines @@
 
     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);
 
     return false;
 }
 
-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.
-    while (true) {
-        CSSParserValue* currentValue = m_valueList->current();
-        if (!currentValue || currentValue->unit != CSSPrimitiveValue::CSS_IDENT)
-            return nullptr;
-
-        CSSPropertyID property = cssPropertyID(currentValue->string);
-        if (property) {
-            ASSERT(CSSPropertyMetadata::isEnabledProperty(property));
-            // Now "all" is used by both CSSValue and CSSPropertyValue.
-            // Need to return nullptr when currentValue is CSSPropertyAll.
-            if (property == CSSPropertyWillChange)
-                return nullptr;
-            values->append(cssValuePool().createIdentifierValue(property));
-        } else {
-            switch (currentValue->id) {
-            case CSSValueNone:
-            case CSSValueAll:
-            case CSSValueAuto:
-            case CSSValueDefault:
-            case CSSValueInitial:
-            case CSSValueInherit:
-                return nullptr;
-            case CSSValueContents:
-                values->append(cssValuePool().createIdentifierValue(currentValue->id));
-                break;
-            default:
-                break;
-            }
-        }
-
-        if (!m_valueList->next())
-            break;
-        if (!consumeComma(m_valueList))
-            return nullptr;
-    }
-
-    return values.release();
-}
-
 static void filterInfoForName(const CSSParserString& name, CSSFilterValue::FilterOperationType& filterType, unsigned& maximumArgumentCount)
 {
     if (equalIgnoringCase(name, "grayscale("))
         filterType = CSSFilterValue::GrayscaleFilterOperation;
     else if (equalIgnoringCase(name, "sepia("))
         filterType = CSSFilterValue::SepiaFilterOperation;
     else if (equalIgnoringCase(name, "saturate("))
         filterType = CSSFilterValue::SaturateFilterOperation;
     else if (equalIgnoringCase(name, "hue-rotate("))
         filterType = CSSFilterValue::HueRotateFilterOperation;
@@ skipping 710 matching lines @@
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 bool CSSPropertyParser::isSystemColor(int id)
 {
     // FIXME(sky): remove
     return false;
 }
 
 } // namespace blink