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 1477 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 = parseScrollSnapDestination();
+        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(createPrimitiveNumericValue(repeatValue));
+        m_valueList->next();
+        return result.release();
+    }
+
+    return nullptr;
+}
+
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapDestination()
+{
+    return parseScrollSnapPosition();
+}
+
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapCoordinate()
+{
+    if (m_valueList->current()->id == CSSValueNone) {
+        m_valueList->next();
+        return cssValuePool().createIdentifierValue(CSSValueNone);
+    }
+
+    RefPtrWillBeRawPtr<CSSValueList> positions = CSSValueList::createSpaceSeparated();
+    // TODO(majidvp): parse comma separated position lists correctly

[Timothy Loh, 2015/05/28 07:09:26]

Can we just do this properly in this patch? Should only be a few extra lines. (I
need to make a helper function for this at some point...)

[majidvp, 2015/06/01 20:06:37]

Done. I added a parsePositionList which can be used as a generic utility.

+    while (m_valueList->current()) {
+        // parseScrollSnapPosition advances the value list
+        RefPtrWillBeRawPtr<CSSValue> position = parseScrollSnapPosition();
+        if (!position)
+            return nullptr;
+
+        positions->append(position);
+    }
+
+    if (positions->length()) {

[Timothy Loh, 2015/05/28 07:09:27]

Pretty sure this is unnecessary

[majidvp, 2015/06/01 20:06:37]

Done.

+        return positions.release();
+    }
+    return nullptr;
+}
+
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapPosition()
+{
+    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);
+}
+
+// auto | <identifier>

[Timothy Loh, 2015/05/28 07:09:27]

I wouldn't bother with these sorts of comments (especially for unrelated
functions :-)

[majidvp, 2015/06/01 20:06:37]

Done.

 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 5127 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