Parse motion shorthand in CSSPropertyParser with CSSParserTokens

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSFontFaceSrcValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
+#include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSQuadValue.h"
 #include "core/css/CSSSVGDocumentValue.h"
 #include "core/css/CSSShadowValue.h"
 #include "core/css/CSSStringValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/CSSURIValue.h"
 #include "core/css/CSSUnicodeRangeValue.h"
 #include "core/css/CSSValuePair.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/FontFace.h"
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/frame/UseCounter.h"
 #include "core/layout/LayoutTheme.h"
+#include "core/svg/SVGPathUtilities.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 CSSPropertyParser::CSSPropertyParser(CSSParserValueList* valueList, const CSSParserTokenRange& range,
     const CSSParserContext& context, WillBeHeapVector<CSSProperty, 256>& parsedProperties,
     StyleRule::Type ruleType)
     : m_valueList(valueList)
     , m_range(range)
     , m_context(context)
@@ skipping 1376 matching lines @@
     RefPtrWillBeRawPtr<CSSValueList> shadowValueList = CSSValueList::createCommaSeparated();
     do {
         if (RefPtrWillBeRawPtr<CSSShadowValue> shadowValue = parseSingleShadow(range, context, isBoxShadowProperty, isBoxShadowProperty))
             shadowValueList->append(shadowValue.release());
         else
             return nullptr;
     } while (consumeCommaIncludingWhitespace(range));
     return shadowValueList;
 }
 
-static PassRefPtrWillBeRawPtr<CSSFunctionValue> consumeFilterFunction(CSSParserTokenRange& range,  const CSSParserContext& context)
+static PassRefPtrWillBeRawPtr<CSSFunctionValue> consumeFilterFunction(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     CSSValueID filterType = range.peek().functionId();
     if (filterType < CSSValueInvert || filterType > CSSValueDropShadow)
         return nullptr;
     CSSParserTokenRange args = consumeFunction(range);
     RefPtrWillBeRawPtr<CSSFunctionValue> filterValue = CSSFunctionValue::create(filterType);
     RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
 
     if (filterType == CSSValueDropShadow) {
         parsedValue = parseSingleShadow(args, context, false, false);
@@ skipping 21 matching lines @@
                     return nullptr;
             }
         }
     }
     if (!parsedValue || !args.atEnd())
         return nullptr;
     filterValue->append(parsedValue.release());
     return filterValue.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSValue> consumeFilter(CSSParserTokenRange& range,  const CSSParserContext& context)
+static PassRefPtrWillBeRawPtr<CSSValue> consumeFilter(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     if (range.peek().id() == CSSValueNone)
         return consumeIdent(range);
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     do {
         String url = consumeUrl(range);
         RefPtrWillBeRawPtr<CSSFunctionValue> filterValue = nullptr;
         if (!url.isNull()) {
             filterValue = CSSFunctionValue::create(CSSValueUrl);
             filterValue->append(CSSSVGDocumentValue::create(url));
         } else {
             filterValue = consumeFilterFunction(range, context);
             if (!filterValue)
                 return nullptr;
         }
         list->append(filterValue.release());
     } while (!range.atEnd());
 
     return list.release();
 }
 
+static PassRefPtrWillBeRawPtr<CSSValue> consumeMotionPath(CSSParserTokenRange& range)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueNone)
+        return consumeIdent(range);
+
+    // FIXME: Add support for <url>, <basic-shape>, <geometry-box>.
+    if (range.peek().functionId() != CSSValuePath)
+        return nullptr;
+
+    // FIXME: Add support for <fill-rule>.
+    CSSParserTokenRange functionRange = range;
+    CSSParserTokenRange functionArgs = consumeFunction(functionRange);
+
+    if (functionArgs.peek().type() != StringToken)
+        return nullptr;
+    String pathString = functionArgs.consumeIncludingWhitespace().value();
+    Path path;
+    if (!buildPathFromString(pathString, path) || !functionArgs.atEnd())
+        return nullptr;
+
+    range = functionRange;
+    return CSSPathValue::create(pathString);
+}
+
+static bool consumeMotionKeywordOrAngle(CSSParserTokenRange& range, CSSParserMode cssParserMode, RefPtrWillBeRawPtr<CSSValue>& keyword, RefPtrWillBeRawPtr<CSSValue>& angle)
+{
+    CSSValueID id = range.peek().id();
+    if ((id == CSSValueAuto || id == CSSValueReverse) && !keyword)
+        keyword = consumeIdent(range);
+    else if (!angle)
+        angle = consumeAngle(range, cssParserMode);
+    else
+        return false;

[Timothy Loh, 2015/11/04 04:18:28]

btw we'd never actually get here on the first call ;-)

+    return true;
+}
+
+static PassRefPtrWillBeRawPtr<CSSValue> consumeMotionRotation(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

[Timothy Loh, 2015/11/04 04:18:27]

let's define this where it's used instead of at the top here

+
+    RefPtrWillBeRawPtr<CSSValue> keyword = nullptr;

[Timothy Loh, 2015/11/04 04:18:27]

Another option, WDYT?

RefPtrWillBeRawPtr<CSSValue> angle = consumeAngle(range, cssParserMode);
RefPtrWillBeRawPtr<CSSValue> keyword = consumeIdent<CSSValueAuto,
CSSValueReverse>(range);
if (!angle)
    angle = consumeAngle(range, cssParserMode);

if (!angle && !keyword)
    return nullptr;

+    RefPtrWillBeRawPtr<CSSValue> angle = nullptr;
+    if (!consumeMotionKeywordOrAngle(range, cssParserMode, keyword, angle))
+        return nullptr;
+    consumeMotionKeywordOrAngle(range, cssParserMode, keyword, angle);
+
+    if (keyword)
+        list->append(keyword.release());
+    if (angle)
+        list->append(angle.release());
+    return list.release();
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID unresolvedProperty)
 {
     CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
     m_range.consumeWhitespace();
     switch (property) {
     case CSSPropertyWillChange:
         return consumeWillChange(m_range);
     case CSSPropertyPage:
         return consumePage(m_range);
     case CSSPropertyQuotes:
@@ skipping 90 matching lines @@
     case CSSPropertyColor:
         return consumeColor(m_range, m_context, inQuirksMode());
     case CSSPropertyZIndex:
         return consumeZIndex(m_range);
     case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
     case CSSPropertyBoxShadow:
         return consumeShadow(m_range, m_context, property == CSSPropertyBoxShadow);
     case CSSPropertyWebkitFilter:
     case CSSPropertyBackdropFilter:
         return consumeFilter(m_range, m_context);
+    case CSSPropertyMotionPath:
+        ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());
+        return consumeMotionPath(m_range);
+    case CSSPropertyMotionOffset:
+        ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());
+        return consumeLengthOrPercent(m_range, m_context.mode(), ValueRangeAll);
+    case CSSPropertyMotionRotation:
+        ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());
+        return consumeMotionRotation(m_range, m_context.mode());
     default:
         return nullptr;
     }
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
 
     do {
@@ skipping 406 matching lines @@
         return consumeBorderSpacing(important);
     case CSSPropertyWebkitColumns: {
         // TODO(rwlbuis): investigate if this shorthand hack can be removed.
         m_currentShorthand = oldShorthand;
         return consumeColumns(important);
     }
     case CSSPropertyAnimation:
         return consumeAnimationShorthand(animationShorthandForParsing(), unresolvedProperty == CSSPropertyAliasWebkitAnimation, important);
     case CSSPropertyTransition:
         return consumeAnimationShorthand(transitionShorthandForParsing(), false, important);
+    case CSSPropertyMotion:
+        ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());
+        return consumeShorthandGreedily(motionShorthand(), important);
     default:
         m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink