Parse flex/flex-flow shorthands 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"
@@ skipping 1807 matching lines @@
                 paintOrderList->append(stroke.release());
         }
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     return paintOrderList.release();
 }
 
+static PassRefPtrWillBeRawPtr<CSSValue> consumeFlexBasis(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    // FIXME: Support intrinsic dimensions too.
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
+}
+
 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 136 matching lines @@
         return consumeLength(m_range, m_context.mode(), ValueRangeAll);
     case CSSPropertyOutlineWidth:
         return consumeLineWidth(m_range, m_context.mode());
     case CSSPropertyTransform:
         return consumeTransform(m_range, m_context.mode(), unresolvedProperty == CSSPropertyAliasWebkitTransform);
     case CSSPropertyFill:
     case CSSPropertyStroke:
         return consumePaint(m_range, m_context);
     case CSSPropertyPaintOrder:
         return consumePaintOrder(m_range);
+    case CSSPropertyFlexBasis:
+        return consumeFlexBasis(m_range, m_context.mode());
+    case CSSPropertyFlexGrow:
+    case CSSPropertyFlexShrink:
+        return consumeNumber(m_range, ValueRangeNonNegative);
     default:
         return nullptr;
     }
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
 
     do {
@@ skipping 376 matching lines @@
     ImplicitScope implicitScope(this);
     for (size_t i = 0; i < shorthand.length(); ++i) {
         if (longhands[i])
             addProperty(shorthandProperties[i], longhands[i].release(), important);
         else
             addProperty(shorthandProperties[i], cssValuePool().createImplicitInitialValue(), important);
     }
     return true;
 }
 
+bool CSSPropertyParser::consumeFlex(bool important)
+{
+    ShorthandScope scope(this, CSSPropertyFlex);
+    static const double unsetValue = -1;
+    double flexGrow = unsetValue;
+    double flexShrink = unsetValue;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> flexBasis = nullptr;
+
+    if (m_range.peek().id() == CSSValueNone) {
+        flexGrow = flexShrink = 0;

[Timothy Loh, 2015/11/19 05:36:59]

Isn't this against the style guide? At least I never see it around, let's just
put them on separate lines.

+        flexBasis = cssValuePool().createIdentifierValue(CSSValueAuto);
+        m_range.consumeIncludingWhitespace();
+    } else {
+        unsigned index = 0;
+        while (!m_range.atEnd() && index++ < 3) {

[Timothy Loh, 2015/11/19 05:36:59]

I'd prefer a regular for loop here. I got a bit confused by the index==2 check
at the bottom (I thought it meant the third value). Feel free to change or leave
it as is depending on what you prefer.

+            double num;
+            if (consumeNumberRaw(m_range, num)) {
+                if (num < 0)
+                    return false;
+                if (flexGrow == unsetValue)
+                    flexGrow = num;
+                else if (flexShrink == unsetValue)
+                    flexShrink = num;
+                else if (!num) // flex only allows a basis of 0 (sans units) if flex-grow and flex-shrink values have already been set.
+                    flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels);
+                else
+                    return false;
+            } else if (!flexBasis) {
+                if (m_range.peek().id() == CSSValueAuto)
+                    flexBasis = consumeIdent(m_range);
+                if (!flexBasis)

[Timothy Loh, 2015/11/19 05:36:59]

Better to just write "else"

+                    flexBasis = consumeLengthOrPercent(m_range, m_context.mode(), ValueRangeNonNegative);
+                if (flexBasis && index == 2 && !m_range.atEnd())

[Timothy Loh, 2015/11/19 05:36:59]

I guess this doesn't need to check flexBasis, I think it's a tiny bit clearer
without it.

+                    return false;
+            }
+        }
+    }
+    if (!m_range.atEnd())
+        return false;
+
+    if (flexGrow == unsetValue)
+        flexGrow = 1;
+    if (flexShrink == unsetValue)
+        flexShrink = 1;
+    if (!flexBasis)
+        flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Percentage);
+
+    addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(clampTo<float>(flexGrow), CSSPrimitiveValue::UnitType::Number), important);
+    addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(clampTo<float>(flexShrink), CSSPrimitiveValue::UnitType::Number), important);
+    addProperty(CSSPropertyFlexBasis, flexBasis, important);
+    return true;
+}
+
 bool CSSPropertyParser::parseShorthand(CSSPropertyID unresolvedProperty, bool important)
 {
     CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
 
     m_range.consumeWhitespace();
     CSSPropertyID oldShorthand = m_currentShorthand;
     // TODO(rob.buis): Remove this when the legacy property parser is gone
     m_currentShorthand = property;
     switch (property) {
     case CSSPropertyWebkitMarginCollapse: {
@@ skipping 74 matching lines @@
     case CSSPropertyWebkitBorderStart:
         return consumeShorthandGreedily(webkitBorderStartShorthand(), important);
     case CSSPropertyWebkitBorderEnd:
         return consumeShorthandGreedily(webkitBorderEndShorthand(), important);
     case CSSPropertyWebkitBorderBefore:
         return consumeShorthandGreedily(webkitBorderBeforeShorthand(), important);
     case CSSPropertyWebkitBorderAfter:
         return consumeShorthandGreedily(webkitBorderAfterShorthand(), important);
     case CSSPropertyWebkitTextStroke:
         return consumeShorthandGreedily(webkitTextStrokeShorthand(), important);
+    case CSSPropertyFlex:
+        return consumeFlex(important);
+    case CSSPropertyFlexFlow:
+        return consumeShorthandGreedily(flexFlowShorthand(), important);
     default:
         m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink