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 4306 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 && RuntimeEnabledFeatures::webAnimationsAPIEnabled()))
         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)
+            switch (v->id) {
+            case CSSValueMiddle:
+                if (RuntimeEnabledFeatures::webAnimationsAPIEnabled())
+                    stepAtPosition = StepsTimingFunction::StepAtMiddle;
+                else
+                    return 0;

[alancutter (OOO until 2018), 2014/02/19 03:17:45]

Avoiding else branches by returning earlier is preferred.
Example:
if (...)
    return 0;
a = b;
...

[rjwright, 2014/02/24 11:17:46]

Done.

+                break;
+            case CSSValueStart:
+                stepAtPosition = StepsTimingFunction::StepAtStart;
+                break;
+            case CSSValueEnd:
+                stepAtPosition = StepsTimingFunction::StepAtEnd;
+                break;
+            default:
                 return 0;
-            stepAtStart = v->id == CSSValueStart;
+            }
         }
 
-        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 5849 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");
 }
 
 }