Parsing CSS properties for scroll snap points

Source/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 709 matching lines @@
                 addProperty(propId1, val1.release(), important);
                 if (val2)
                     addProperty(propId2, val2.release(), important);
             }
             result = true;
         }
         m_implicitShorthand = false;
         return result;
     }
     case CSSPropertyObjectPosition:
-        parsedValue = parseObjectPosition();
+        parsedValue = parsePosition();
         break;
     case CSSPropertyListStyleImage:     // <uri> | none | inherit
     case CSSPropertyBorderImageSource:
     case CSSPropertyWebkitMaskBoxImageSource:
         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();
@@ skipping 747 matching lines @@
     // Properties below are validated inside parseViewportProperty, because we
     // check for parser state. We need to invalidate if someone adds them outside
     // a @viewport rule.
     case CSSPropertyMaxZoom:
     case CSSPropertyMinZoom:
     case CSSPropertyOrientation:
     case CSSPropertyUserZoom:
         validPrimitive = false;
         break;
 
+    case CSSPropertyScrollSnapPointsX:
+    case CSSPropertyScrollSnapPointsY:
+        parsedValue = parseScrollSnapPoints();
+        break;
+    case CSSPropertyScrollSnapCoordinate:
+        parsedValue = parseScrollSnapCoordinate();
+        break;
+    case CSSPropertyScrollSnapDestination:
+        parsedValue = parsePosition();
+        break;
+
     default:
         return parseSVGValue(propId, important);
     }
 
     if (validPrimitive) {
         parsedValue = parseValidPrimitive(id, value);
         m_valueList->next();
     }
     ASSERT(!m_parsedCalculation);
     if (parsedValue) {
@@ skipping 493 matching lines @@
             break;
         }
         default: {
             return false;
         }
     }
 
     return true;
 }
 
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapPoints()
+{
+    CSSParserValue* value = m_valueList->current();
+
+    if (value->id == CSSValueNone) {
+        m_valueList->next();
+        return cssValuePool().createIdentifierValue(CSSValueNone);
+    }
+
+    if (value->unit == CSSParserValue::Function && value->function->id == CSSValueRepeat) {
+        // The spec defines the following grammar: repeat( <length>)
+        CSSParserValueList* arguments = value->function->args.get();
+        if (!arguments || arguments->size() != 1)
+            return nullptr;
+
+        CSSParserValue* repeatValue = arguments->valueAt(0);
+        if (!validUnit(repeatValue, FNonNeg | FLength | FPercent))
+            return nullptr;
+
+        RefPtrWillBeRawPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueRepeat);
+        result->append(parseValidPrimitive(repeatValue->id, repeatValue));
+        m_valueList->next();
+        return result.release();
+    }
+
+    return nullptr;
+}
+
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapCoordinate()
+{
+    if (m_valueList->current()->id == CSSValueNone) {
+        m_valueList->next();
+        return cssValuePool().createIdentifierValue(CSSValueNone);
+    }
+
+    return parsePositionList(m_valueList);
+}
+
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parsePage()
 {
     CSSParserValue* value = m_valueList->current();
     m_valueList->next();
     ASSERT(value);
 
     if (value->id == CSSValueAuto)
         return cssValuePool().createIdentifierValue(value->id);
     if (value->unit == CSSPrimitiveValue::CSS_IDENT)
         return createPrimitiveCustomIdentValue(value);
@@ skipping 3526 matching lines @@
         flexShrink = 1;
     if (!flexBasis)
         flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PERCENTAGE);
 
     addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(clampTo<float>(flexGrow), CSSPrimitiveValue::CSS_NUMBER), important);
     addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(clampTo<float>(flexShrink), CSSPrimitiveValue::CSS_NUMBER), important);
     addProperty(CSSPropertyFlexBasis, flexBasis, important);
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseObjectPosition()
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parsePosition()
 {
     RefPtrWillBeRawPtr<CSSValue> xValue = nullptr;
     RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
     parseFillPosition(m_valueList, xValue, yValue);
     if (!xValue || !yValue)
         return nullptr;
     return createPrimitiveValuePair(toCSSPrimitiveValue(xValue.get()), toCSSPrimitiveValue(yValue.get()), Pair::KeepIdenticalValues);
 }
 
+// Parses a list of comma separated positions. i.e., <position>#
+PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parsePositionList(CSSParserValueList* args)
+{
+    RefPtrWillBeRawPtr<CSSValueList> positions = CSSValueList::createCommaSeparated();
+    for (CSSParserValue* argument = args->current(); argument; argument = args->next()) {

[Timothy Loh, 2015/06/04 03:58:26]

I think this won't do exactly what you want (I think it'll allow "10px,",
"10px/", "10px banana", and so on). I think you'll want a loop like

    while (true) {
        RefPtrWillBeRawPtr<CSSValue> position = parsePosition();
        if (!position)
            return nullptr;
        list->append(position.release());
        if (!m_valueList->current())
            break;
        if (!consumeComma(m_valueList) || !m_valueList->current())
            return nullptr;
    }

[majidvp, 2015/06/04 22:41:40]

Done.

+        RefPtrWillBeRawPtr<CSSValue> xValue = nullptr;
+        RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
+        // parseFillPosition below should consume arguments until it reaches
+        // a comma or end of the list
+        parseFillPosition(args, xValue, yValue);
+
+        if (!xValue || !yValue)
+            return nullptr;
+
+        RefPtrWillBeRawPtr<CSSValue> position = createPrimitiveValuePair(toCSSPrimitiveValue(xValue.get()), toCSSPrimitiveValue(yValue.get()), Pair::KeepIdenticalValues);
+        positions->append(position);
+    }
+
+    return positions.release();
+}
+
 class BorderImageParseContext {
     STACK_ALLOCATED();
 public:
     BorderImageParseContext()
     : m_canAdvance(false)
     , m_allowCommit(true)
     , m_allowImage(true)
     , m_allowImageSlice(true)
     , m_allowRepeat(true)
     , m_allowForwardSlashOperator(false)
@@ skipping 1571 matching lines @@
             RefPtrWillBeRawPtr<CSSFunctionValue> filterValue = parseBuiltinFilterArguments(args, filterType);
             if (!filterValue)
                 return nullptr;
 
             list->append(filterValue);
         }
     }
 
     return list.release();
 }
+
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseTransformOrigin()
 {
     CSSParserValue* value = m_valueList->current();
     CSSValueID id = value->id;
     RefPtrWillBeRawPtr<CSSValue> xValue = nullptr;
     RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
     RefPtrWillBeRawPtr<CSSValue> zValue = nullptr;
     if (id == CSSValueLeft || id == CSSValueRight) {
         xValue = cssValuePool().createIdentifierValue(id);
     } else if (id == CSSValueTop || id == CSSValueBottom) {
@@ skipping 1232 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink