Move border-image related longhands into CSSPropertyParser

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 "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
+#include "core/css/CSSBorderImage.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSContentDistributionValue.h"
 #include "core/css/CSSCounterValue.h"
 #include "core/css/CSSCrossfadeValue.h"
 #include "core/css/CSSCursorImageValue.h"
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSFontFaceSrcValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSImageSetValue.h"
@@ skipping 2980 matching lines @@
         if (!xLength)
             return nullptr;
         RefPtrWillBeRawPtr<CSSPrimitiveValue> yLength = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
         if (!yLength)
             return nullptr;
         shape->appendPoint(xLength.release(), yLength.release());
     } while (consumeCommaIncludingWhitespace(args));
     return shape.release();
 }
 
-static void completeBorderRadii(RefPtrWillBeRawPtr<CSSPrimitiveValue> radii[4])
+static void complete4Sides(RefPtrWillBeRawPtr<CSSPrimitiveValue> side[4])
 {
-    if (radii[3])
+    if (side[3])
         return;
-    if (!radii[2]) {
-        if (!radii[1])
-            radii[1] = radii[0];
-        radii[2] = radii[0];
+    if (!side[2]) {
+        if (!side[1])
+            side[1] = side[0];
+        side[2] = side[0];
     }
-    radii[3] = radii[1];
+    side[3] = side[1];
 }
 
 static bool consumeRadii(RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalRadii[4], RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalRadii[4], CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
 {
 #if ENABLE(OILPAN)
     // Unconditionally zero initialize the arrays of raw pointers.
     memset(horizontalRadii, 0, 4 * sizeof(horizontalRadii[0]));
     memset(verticalRadii, 0, 4 * sizeof(verticalRadii[0]));
 #endif
     unsigned i = 0;
     for (; i < 4 && !range.atEnd() && range.peek().type() != DelimiterToken; ++i) {
         horizontalRadii[i] = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
         if (!horizontalRadii[i])
             return false;
     }
     if (!horizontalRadii[0])
         return false;
     if (range.atEnd()) {
         // Legacy syntax: -webkit-border-radius: l1 l2; is equivalent to border-radius: l1 / l2;
         if (useLegacyParsing && i == 2) {
             verticalRadii[0] = horizontalRadii[1];
             horizontalRadii[1] = nullptr;
         } else {
-            completeBorderRadii(horizontalRadii);
+            complete4Sides(horizontalRadii);
             for (unsigned i = 0; i < 4; ++i)
                 verticalRadii[i] = horizontalRadii[i];
             return true;
         }
     } else {
         if (range.peek().type() != DelimiterToken || range.peek().delimiter() != '/')
             return false;
         range.consumeIncludingWhitespace();
         for (i = 0; i < 4 && !range.atEnd(); ++i) {
             verticalRadii[i] = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
             if (!verticalRadii[i])
                 return false;
         }
         if (!verticalRadii[0] || !range.atEnd())
             return false;
     }
-    completeBorderRadii(horizontalRadii);
-    completeBorderRadii(verticalRadii);
+    complete4Sides(horizontalRadii);
+    complete4Sides(verticalRadii);
     return true;
 }
 
 static PassRefPtrWillBeRawPtr<CSSBasicShapeInsetValue> consumeBasicShapeInset(CSSParserTokenRange& args, const CSSParserContext& context)
 {
     RefPtrWillBeRawPtr<CSSBasicShapeInsetValue> shape = CSSBasicShapeInsetValue::create();
     RefPtrWillBeRawPtr<CSSPrimitiveValue> top = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
     if (!top)
         return nullptr;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> right = nullptr;
@@ skipping 110 matching lines @@
     if (position == CSSValueInvalid && distribution == CSSValueInvalid)
         return nullptr;
 
     // The grammar states that <overflow-position> must be associated to <content-position>.
     if (overflow != CSSValueInvalid && position == CSSValueInvalid)
         return nullptr;
 
     return CSSContentDistributionValue::create(distribution, position, overflow);
 }
 
+static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageRepeat(CSSParserTokenRange& range)
+{
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> firstValue = nullptr;

[Timothy Loh, 2016/02/02 10:57:36]

first -> horizontal, second -> vertical

Why not just (and similar for the vertical)

horizontalValue = consumeIdent<...reallylongline...>(range);
if (!horizontalValue)
    return nullptr;

Also maybe nicer to define a consumeBorderImageRepeatKeyword?

+    if (!identMatches<CSSValueStretch, CSSValueRepeat, CSSValueSpace, CSSValueRound>(range.peek().id()))
+        return nullptr;
+    firstValue = consumeIdent(range);
+
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> secondValue = nullptr;
+    if (identMatches<CSSValueStretch, CSSValueRepeat, CSSValueSpace, CSSValueRound>(range.peek().id()))
+        secondValue = consumeIdent(range);
+    else
+        secondValue = firstValue;
+
+    return CSSValuePair::create(firstValue.release(), secondValue.release(), CSSValuePair::DropIdenticalValues);
+}
+
+static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageSlice(CSSPropertyID property, CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    bool fill = consumeIdent<CSSValueFill>(range);
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> slices[4];
+#if ENABLE(OILPAN)
+    // Unconditionally zero initialize the arrays of raw pointers.
+    memset(slices, 0, 4 * sizeof(slices[0]));
+#endif
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> value = nullptr;

[Timothy Loh, 2016/02/02 10:57:36]

Better to declare this inside the loop since it's only used there (also in the
next two functions)

+    for (size_t index = 0; index < 4; ++index) {
+        value = consumePercent(range, ValueRangeNonNegative);
+        if (!value)
+            value = consumeNumber(range, ValueRangeNonNegative);
+        if (!value)
+            break;
+        slices[index] = value;
+    }
+    if (!slices[0])
+        return nullptr;
+    if (consumeIdent<CSSValueFill>(range)) {

[Timothy Loh, 2016/02/02 10:57:36]

Maybe nicer as follows:

if (!fill && consumeIdent<CSSValueFill>(range))
    fill = true;

+        if (fill)
+            return nullptr;
+        fill = true;
+    }
+    complete4Sides(slices);
+    // FIXME: For backwards compatibility, -webkit-border-image, -webkit-mask-box-image and -webkit-box-reflect have to do a fill by default.
+    // FIXME: What do we do with -webkit-box-reflect and -webkit-mask-box-image? Probably just have to leave them filling...
+    if (property == CSSPropertyWebkitBorderImage || property == CSSPropertyWebkitMaskBoxImage || property == CSSPropertyWebkitBoxReflect)
+        fill = true;
+    return CSSBorderImageSliceValue::create(CSSQuadValue::create(slices[0].release(), slices[1].release(), slices[2].release(), slices[3].release(), CSSQuadValue::SerializeAsQuad), fill);
+}
+
+static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageOutset(CSSParserTokenRange& range)
+{
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> outsets[4];
+#if ENABLE(OILPAN)
+    // Unconditionally zero initialize the arrays of raw pointers.
+    memset(outsets, 0, 4 * sizeof(outsets[0]));
+#endif
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> value = nullptr;
+    for (size_t index = 0; index < 4; ++index) {
+        value = consumeNumber(range, ValueRangeNonNegative);
+        if (!value)
+            value = consumeLength(range, HTMLStandardMode, ValueRangeNonNegative);
+        if (!value)
+            break;
+        outsets[index] = value;
+    }
+    if (!outsets[0])
+        return nullptr;
+    complete4Sides(outsets);
+    return CSSQuadValue::create(outsets[0].release(), outsets[1].release(), outsets[2].release(), outsets[3].release(), CSSQuadValue::SerializeAsQuad);
+}
+
+static PassRefPtrWillBeRawPtr<CSSValue> consumeBorderImageWidth(CSSParserTokenRange& range)
+{
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> widths[4];
+#if ENABLE(OILPAN)
+    // Unconditionally zero initialize the arrays of raw pointers.
+    memset(widths, 0, 4 * sizeof(widths[0]));
+#endif
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> value = nullptr;
+    for (size_t index = 0; index < 4; ++index) {
+        value = consumeNumber(range, ValueRangeNonNegative);
+        if (!value)
+            value = consumeLengthOrPercent(range, HTMLStandardMode, ValueRangeNonNegative, UnitlessQuirk::Forbid);
+        if (!value && range.peek().id() == CSSValueAuto)

[Timothy Loh, 2016/02/02 10:57:36]

How about

if (!value)
    value = consumeIdent<CSSValueAuto>(range);

+            value = consumeIdent(range);
+        if (!value)
+            break;
+        widths[index] = value;
+    }
+    if (!widths[0])
+        return nullptr;
+    complete4Sides(widths);
+    return CSSQuadValue::create(widths[0].release(), widths[1].release(), widths[2].release(), widths[3].release(), CSSQuadValue::SerializeAsQuad);
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID unresolvedProperty)
 {
     CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
     if (CSSParserFastPaths::isKeywordPropertyID(property)) {
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(property, m_range.peek().id()))
             return nullptr;
         return consumeIdent(m_range);
     }
     switch (property) {
     case CSSPropertyWillChange:
@@ skipping 284 matching lines @@
     case CSSPropertyVerticalAlign:
         return consumeVerticalAlign(m_range, m_context.mode());
     case CSSPropertyShapeOutside:
         return consumeShapeOutside(m_range, m_context);
     case CSSPropertyWebkitClipPath:
         return consumeClipPath(m_range, m_context);
     case CSSPropertyJustifyContent:
     case CSSPropertyAlignContent:
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         return consumeContentDistributionOverflowPosition(m_range);
+    case CSSPropertyBorderImageRepeat:
+    case CSSPropertyWebkitMaskBoxImageRepeat:
+        return consumeBorderImageRepeat(m_range);
+    case CSSPropertyBorderImageSlice:
+    case CSSPropertyWebkitMaskBoxImageSlice:
+        return consumeBorderImageSlice(property, m_range, m_context.mode());
+    case CSSPropertyBorderImageOutset:
+    case CSSPropertyWebkitMaskBoxImageOutset:
+        return consumeBorderImageOutset(m_range);
+    case CSSPropertyBorderImageWidth:
+    case CSSPropertyWebkitMaskBoxImageWidth:
+        return consumeBorderImageWidth(m_range);
     default:
         CSSParserValueList valueList(m_range);
         if (valueList.size()) {
             m_valueList = &valueList;
             if (RefPtrWillBeRawPtr<CSSValue> result = legacyParseValue(unresolvedProperty)) {
                 while (!m_range.atEnd())
                     m_range.consume();
                 return result.release();
             }
         }
@@ skipping 640 matching lines @@
         m_currentShorthand = oldShorthand;
         CSSParserValueList valueList(m_range);
         if (!valueList.size())
             return false;
         m_valueList = &valueList;
         return legacyParseShorthand(unresolvedProperty, important);
     }
 }
 
 } // namespace blink