Move size property 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 "config.h"
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSCustomIdentValue.h"
@@ skipping 623 matching lines @@
     for (unsigned i = 0; i < 3; i++) { // 3 dimensions of rotation
         RefPtrWillBeRawPtr<CSSValue> dimension = consumeNumber(range, ValueRangeAll);
         if (!dimension)
             return nullptr;
         list->append(dimension.release());
     }
 
     return list.release();
 }
 
+enum class SizeParameter {
+    None,
+    Auto,
+    Length,
+    PageSize,
+    Orientation,
+};
+
+static SizeParameter parseSizeParameter(CSSParserTokenRange& range, CSSParserMode cssParserMode, CSSValueList* parsedValues, SizeParameter prevParamType)
+{
+    switch (range.peek().id()) {
+    case CSSValueAuto:
+        if (prevParamType == SizeParameter::None) {
+            parsedValues->append(consumeIdent(range));
+            return SizeParameter::Auto;
+        }
+        return SizeParameter::None;
+    case CSSValueLandscape:
+    case CSSValuePortrait:
+        if (prevParamType == SizeParameter::None || prevParamType == SizeParameter::PageSize) {
+            parsedValues->append(consumeIdent(range));
+            return SizeParameter::Orientation;
+        }
+        return SizeParameter::None;
+    case CSSValueA3:
+    case CSSValueA4:
+    case CSSValueA5:
+    case CSSValueB4:
+    case CSSValueB5:
+    case CSSValueLedger:
+    case CSSValueLegal:
+    case CSSValueLetter:
+        if (prevParamType == SizeParameter::None || prevParamType == SizeParameter::Orientation) {
+            // Normalize to Page Size then Orientation order by prepending for simpler StyleBuilder handling
+            parsedValues->prepend(consumeIdent(range));
+            return SizeParameter::PageSize;
+        }
+        return SizeParameter::None;
+    case 0: {
+        RefPtrWillBeRawPtr<CSSValue> parsedValue = consumeLength(range, cssParserMode, ValueRangeNonNegative);
+        if (parsedValue && (prevParamType == SizeParameter::None || prevParamType == SizeParameter::Length)) {
+            parsedValues->append(parsedValue.release());
+            return SizeParameter::Length;
+        }
+        return SizeParameter::None;
+    }
+    default:
+        return SizeParameter::None;
+    }
+}
+
+static PassRefPtrWillBeRawPtr<CSSValueList> consumeSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    RefPtrWillBeRawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
+
+    // First parameter.

[Timothy Loh, 2015/10/08 23:36:38]

This can be lots simpler I think. Sorry for code dump, I wasn't sure how to word
this in text.

if (range.peek().id() == CSSValueAuto) {
    result->append(consumeIdent(range));
    return result.release();
}

if (RefPtrWillBeRawPtr<CSSValue> width = consumeLength(range, cssParserMode,
ValueRangeNonNegative)) {
    RefPtrWillBeRawPtr<CSSValue> height = consumeLength(range, cssParserMode,
ValueRangeNonNegative);
    if (!height)
        height = width;
    result->append(width.release());
    result->append(height.release());
}

RefPtrWillBeRawPtr<CSSValue> pageSize = consumePageSize(range);
RefPtrWillBeRawPtr<CSSValue> orientation = nullptr;
if (range.peek().id() == CSSValuePortrait || range.peek().id() ==
CSSValueLandscape)
    orientation = consumeIdent(range);
if (!pageSize)
    pageSize = consumePageSize(range);

if (!orientation && !pageSize)
    return nullptr;
if (pageSize)
    result->append(pageSize.release());
if (orientation)
    result->append(orientation.release());
return result.release();


(I'm thinking of making a templated consumeIdent which will make a whole bunch
of code a little nicer, e.g. consumeIdent<CSSValuePortrait, CSSValueLandscape>)

[rwlbuis, 2015/10/12 17:13:19]

I like it! But the part where height is set to width in case only one length is
given leads to a test difference. Also I think if we'd do that, then we could
remove some code in applyValueCSSPropertySize, so it sounds like a bigger
change...

+    SizeParameter paramType = parseSizeParameter(range, cssParserMode, parsedValues.get(), SizeParameter::None);
+    if (paramType == SizeParameter::None)
+        return nullptr;
+
+    // Second parameter, if any.
+    if (!range.atEnd()) {
+        paramType = parseSizeParameter(range, cssParserMode, parsedValues.get(), paramType);
+        if (paramType == SizeParameter::None)
+            return nullptr;
+    }
+
+    return parsedValues.release();
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID propId)
 {
     m_range.consumeWhitespace();
     switch (propId) {
     case CSSPropertyWillChange:
         return consumeWillChange(m_range);
     case CSSPropertyPage:
         return consumePage(m_range);
     case CSSPropertyQuotes:
         return consumeQuotes(m_range);
@@ skipping 16 matching lines @@
         return consumeTabSize(m_range, m_context.mode());
     case CSSPropertyFontSize:
         return consumeFontSize(m_range, m_context.mode(), UnitlessQuirk::Allow);
     case CSSPropertyLineHeight:
         return consumeLineHeight(m_range, m_context.mode());
     case CSSPropertyRotate:
         return consumeRotation(m_range);
     case CSSPropertyWebkitBorderHorizontalSpacing:
     case CSSPropertyWebkitBorderVerticalSpacing:
         return consumeLength(m_range, m_context.mode(), ValueRangeNonNegative);
+    case CSSPropertySize:
+        return consumeSize(m_range, m_context.mode());
     default:
         return nullptr;
     }
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
 
     do {
@@ skipping 374 matching lines @@
     }
     case CSSPropertyBorderSpacing:
         return consumeBorderSpacing(important);
     default:
         m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink