Web Animations API: Implement step-middle and steps(x, middle) timing functions.

Source/core/css/parser/BisonCSSParser-in.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 181 matching lines @@
     , m_supportsCondition(false)
     , m_selectorListForParseSelector(0)
     , m_numParsedPropertiesBeforeMarginBox(INVALID_NUM_PARSED_PROPERTIES)
     , m_inParseShorthand(0)
     , m_currentShorthand(CSSPropertyInvalid)
     , m_implicitShorthand(false)
     , m_hasFontFaceOnlyValues(false)
     , m_hadSyntacticallyValidCSSRule(false)
     , m_logErrors(false)
     , m_ignoreErrors(false)
+    , m_parseStepMiddleTimingFunction(false)
     , m_defaultNamespace(starAtom)
     , m_observer(0)
     , m_source(0)
     , m_ruleHeaderType(CSSRuleSourceData::UNKNOWN_RULE)
     , m_allowImportRules(true)
     , m_allowNamespaceDeclarations(true)
     , m_inViewport(false)
     , m_useCounter(counter)
     , m_tokenizer(*this)
 {
@@ skipping 895 matching lines @@
     if (!parseValue(dummyStyle.get(), CSSPropertyFontFamily, string, false, HTMLQuirksMode, 0))
         return 0;
 
     RefPtr<CSSValue> fontFamily = dummyStyle->getPropertyCSSValue(CSSPropertyFontFamily);
     if (!fontFamily->isValueList())
         return 0;
 
     return toCSSValueList(dummyStyle->getPropertyCSSValue(CSSPropertyFontFamily).get());
 }
 
-PassRefPtr<CSSValue> BisonCSSParser::parseAnimationTimingFunctionValue(const String& string)
+PassRefPtr<CSSValue> BisonCSSParser::parseAnimationTimingFunctionValue(const String& string, bool parseStepMiddleTimingFunction)
 {
     if (string.isEmpty())
         return 0;
     RefPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
-    if (!parseValue(style.get(), CSSPropertyAnimationTimingFunction, string, false, HTMLStandardMode, 0))
+    if (!parseValue(style.get(), CSSPropertyAnimationTimingFunction, string, false, HTMLStandardMode, 0, parseStepMiddleTimingFunction))
         return 0;
 
     return style->getPropertyCSSValue(CSSPropertyAnimationTimingFunction);
 }
 
 bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, const Document& document)
 {
     ASSERT(!string.isEmpty());
 
     CSSParserContext context(document);
 
     if (parseSimpleLengthValue(declaration, propertyID, string, important, context.mode()))
         return true;
     if (parseColorValue(declaration, propertyID, string, important, context.mode()))
         return true;
     if (parseKeywordValue(declaration, propertyID, string, important, context))
         return true;
 
     BisonCSSParser parser(context, UseCounter::getFrom(&document));
     return parser.parseValue(declaration, propertyID, string, important, static_cast<StyleSheetContents*>(0));
 }
 
-bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, CSSParserMode cssParserMode, StyleSheetContents* contextStyleSheet)
+bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, CSSParserMode cssParserMode, StyleSheetContents* contextStyleSheet, bool parseStepMiddleTimingFunction)
 {
     ASSERT(!string.isEmpty());
     if (parseSimpleLengthValue(declaration, propertyID, string, important, cssParserMode))
         return true;
     if (parseColorValue(declaration, propertyID, string, important, cssParserMode))
         return true;
 
     CSSParserContext context(cssParserMode);
     if (contextStyleSheet) {
         context = contextStyleSheet->parserContext();
         context.setMode(cssParserMode);
     }
 
     if (parseKeywordValue(declaration, propertyID, string, important, context))
         return true;
     if (parseTranslateTransform(declaration, propertyID, string, important))
         return true;
 
     BisonCSSParser parser(context);
+    parser.m_parseStepMiddleTimingFunction = parseStepMiddleTimingFunction;
     return parser.parseValue(declaration, propertyID, string, important, contextStyleSheet);
 }
 
 bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, StyleSheetContents* contextStyleSheet)
 {
     // FIXME: Check RuntimeCSSEnabled::isPropertyEnabled or isValueEnabledForProperty.
 
     if (m_useCounter)
         m_useCounter->count(m_context, propertyID);
 
@@ skipping 3240 matching lines @@
     if (!isComma(v))
         return false;
     args->next();
     return true;
 }
 
 PassRefPtr<CSSValue> BisonCSSParser::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 == CSSValueEaseInOut || value->id == CSSValueStepStart || value->id == CSSValueStepEnd
+        || (value->id == CSSValueStepMiddle && m_parseStepMiddleTimingFunction))
         return cssValuePool().createIdentifierValue(value->id);
 
     // We must be a function.
     if (value->unit != CSSParserValue::Function)
         return 0;
 
     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 0;
 
         // There are two values.
         int numSteps;
-        bool stepAtStart = false;
+        StepsTimingFunction::StepAtPosition stepAtPosition = StepsTimingFunction::StepAtEnd;
 
         CSSParserValue* v = args->current();
         if (!validUnit(v, FInteger))
             return 0;
         numSteps = clampToInteger(v->fValue);
         if (numSteps < 1)
             return 0;
         v = args->next();
 
         if (v) {
             // There is a comma so we need to parse the second value
             if (!isComma(v))
                 return 0;
             v = args->next();
-            if (v->id != CSSValueStart && v->id != CSSValueEnd)
+            if (!m_parseStepMiddleTimingFunction && v->id == CSSValueMiddle)
                 return 0;
-            stepAtStart = v->id == CSSValueStart;
+            if (v->id != CSSValueStart && v->id != CSSValueEnd && v->id != CSSValueMiddle)
+                return 0;
+            if (v->id == CSSValueStart) {
+                stepAtPosition = StepsTimingFunction::StepAtStart;
+            } else if (v->id == CSSValueMiddle) {
+                stepAtPosition = StepsTimingFunction::StepAtMiddle;
+            }
         }
 
-        return CSSStepsTimingFunctionValue::create(numSteps, stepAtStart);
+        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 0;
 
         // 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;
 
@@ skipping 5822 matching lines @@
 {
     // The tokenizer checks for the construct of an+b.
     // However, since the {ident} rule precedes the {nth} rule, some of those
     // tokens are identified as string literal. Furthermore we need to accept
     // "odd" and "even" which does not match to an+b.
     return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even")
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 }