Parse text-decoration shorthand 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 1465 matching lines @@
         if (!url.isNull()) {
             filterValue = CSSFunctionValue::create(CSSValueUrl);
             filterValue->append(CSSSVGDocumentValue::create(url));
         } else {
             filterValue = consumeFilterFunction(range, context);
             if (!filterValue)
                 return nullptr;
         }
         list->append(filterValue.release());
     } while (!range.atEnd());
-
     return list.release();
 }
 
+static bool matchKeywords(CSSValueID target, const HashSet<int>& ids)
+{
+    for (const auto& id : ids) {
+        if (id == target)
+            return true;
+    }
+    return false;
+}
+
+static PassRefPtrWillBeRawPtr<CSSValue> consumeTextDecorationLine(CSSParserTokenRange& range)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueNone)
+        return consumeIdent(range);
+
+    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    HashSet<int> ids;
+    ids.add(CSSValueUnderline);
+    ids.add(CSSValueOverline);
+    ids.add(CSSValueLineThrough);
+    ids.add(CSSValueBlink);
+    while (matchKeywords(id, ids)) {
+        list->append(consumeIdent(range));
+        ids.remove(id);
+        id = range.peek().id();
+    }
+
+    // Values are either valid or in shorthand scope.
+    if (!list->length())
+        return nullptr;
+    return list.release();
+}
+
 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 79 matching lines @@
     case CSSPropertyAnimationPlayState:
     case CSSPropertyTransitionProperty:
     case CSSPropertyAnimationTimingFunction:
     case CSSPropertyTransitionTimingFunction:
         return consumeAnimationPropertyList(property, m_range, m_context, unresolvedProperty == CSSPropertyAliasWebkitAnimationName);
     case CSSPropertyOrphans:
     case CSSPropertyWidows:
         return consumeWidowsOrOrphans(m_range);
     case CSSPropertyWebkitTextFillColor:
     case CSSPropertyWebkitTapHighlightColor:
+    case CSSPropertyTextDecorationColor:
+        ASSERT(property != CSSPropertyTextDecorationColor || RuntimeEnabledFeatures::css3TextDecorationsEnabled());
         return consumeColor(m_range, m_context);
     case CSSPropertyColor:
         return consumeColor(m_range, m_context, inQuirksMode());
     case CSSPropertyZIndex:
         return consumeZIndex(m_range);
     case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
     case CSSPropertyBoxShadow:
         return consumeShadow(m_range, m_context, property == CSSPropertyBoxShadow);
     case CSSPropertyWebkitFilter:
     case CSSPropertyBackdropFilter:
         return consumeFilter(m_range, m_context);
+    case CSSPropertyWebkitTextDecorationsInEffect:
+    case CSSPropertyTextDecorationLine:
+        return consumeTextDecorationLine(m_range);
     default:
         return nullptr;
     }
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
 
     do {
@@ skipping 342 matching lines @@
         return false;
     if (!columnWidth)
         columnWidth = cssValuePool().createIdentifierValue(CSSValueAuto);
     if (!columnCount)
         columnCount = cssValuePool().createIdentifierValue(CSSValueAuto);
     addProperty(CSSPropertyWebkitColumnWidth, columnWidth.release(), important);
     addProperty(CSSPropertyWebkitColumnCount, columnCount.release(), important);
     return true;
 }
 
+bool CSSPropertyParser::consumeShorthandGreedily(const StylePropertyShorthand& shorthand, bool important)
+{
+    ASSERT(shorthand.length() <= 6); // Existing shorthands have at most 6 longhands.
+    RefPtrWillBeRawPtr<CSSValue> longhands[6] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
+    do {
+        bool foundLonghand = false;
+        for (unsigned propertyIndex = 0; !foundLonghand && propertyIndex < shorthand.length(); ++propertyIndex) {

[Timothy Loh, 2015/11/03 05:50:58]

Can we be consistent with the loop below (which uses "size_t i")?

[rwlbuis, 2015/11/03 20:51:09]

Done.

+            if (longhands[propertyIndex])
+                continue;
+            // TODO: parseSingleValue needs to handle fastpath keywords.
+            if (CSSParserFastPaths::isKeywordPropertyID(shorthand.properties()[propertyIndex])) {

[Timothy Loh, 2015/11/03 05:50:58]

Would be nice to have a variable for shorthand.properties() instead of writing
it out five times

[rwlbuis, 2015/11/03 20:51:09]

Done.

+                if (CSSParserFastPaths::isValidKeywordPropertyAndValue(shorthand.properties()[propertyIndex], m_range.peek().id()))
+                    longhands[propertyIndex] = consumeIdent(m_range);
+            } else {
+                longhands[propertyIndex] = parseSingleValue(shorthand.properties()[propertyIndex]);
+            }
+            if (longhands[propertyIndex])
+                foundLonghand = true;
+        }
+        if (!foundLonghand)
+            return false;
+    } while (!m_range.atEnd());
+
+    ImplicitScope implicitScope(this);
+    for (size_t i = 0; i < shorthand.length(); ++i) {
+        if (longhands[i])
+            addProperty(shorthand.properties()[i], longhands[i].release(), important);
+        else
+            addProperty(shorthand.properties()[i], cssValuePool().createImplicitInitialValue(), 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 44 matching lines @@
         return consumeBorderSpacing(important);
     case CSSPropertyWebkitColumns: {
         // TODO(rwlbuis): investigate if this shorthand hack can be removed.
         m_currentShorthand = oldShorthand;
         return consumeColumns(important);
     }
     case CSSPropertyAnimation:
         return consumeAnimationShorthand(animationShorthandForParsing(), unresolvedProperty == CSSPropertyAliasWebkitAnimation, important);
     case CSSPropertyTransition:
         return consumeAnimationShorthand(transitionShorthandForParsing(), false, important);
+    case CSSPropertyTextDecoration: {
+        // Fall through 'text-decoration-line' parsing if CSS 3 Text Decoration
+        // is disabled to match CSS 2.1 rules for parsing 'text-decoration'.
+        if (RuntimeEnabledFeatures::css3TextDecorationsEnabled())
+            return consumeShorthandGreedily(textDecorationShorthand(), important);
+        RefPtrWillBeRawPtr<CSSValue> textDecoration = consumeTextDecorationLine(m_range);
+        if (!textDecoration || !m_range.atEnd())
+            return false;
+        addProperty(CSSPropertyTextDecoration, textDecoration.release(), important);
+        return true;
+    }
     default:
         m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink