Added CSSPropertyBackgroundComponentUtils which holds background component parsing methods.

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/CSSContentDistributionValue.h"
@@ skipping 24 matching lines @@
 #include "core/css/CSSValuePair.h"
 #include "core/css/CSSVariableReferenceValue.h"
 #include "core/css/FontFace.h"
 #include "core/css/HashTools.h"
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserIdioms.h"
 #include "core/css/parser/CSSPropertyParserHelpers.h"
 #include "core/css/parser/CSSVariableParser.h"
 #include "core/css/parser/FontVariantLigaturesParser.h"
 #include "core/css/properties/CSSPropertyAlignmentUtils.h"
+#include "core/css/properties/CSSPropertyBackgroundComponentUtils.h"
 #include "core/css/properties/CSSPropertyColumnUtils.h"
 #include "core/css/properties/CSSPropertyDescriptor.h"
 #include "core/css/properties/CSSPropertyLengthUtils.h"
 #include "core/css/properties/CSSPropertyPositionUtils.h"
 #include "core/css/properties/CSSPropertyShapeUtils.h"
 #include "core/frame/UseCounter.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/svg/SVGPathUtilities.h"
 #include "wtf/text/StringBuilder.h"
 #include <memory>
@@ skipping 1573 matching lines @@
   if (range.peek().id() == CSSValueFromImage)
     return consumeIdent(range);
   if (range.peek().type() != NumberToken) {
     CSSPrimitiveValue* angle = consumeAngle(range);
     if (angle && angle->getDoubleValue() == 0)
       return angle;
   }
   return nullptr;
 }
 
-static CSSValue* consumeBackgroundBlendMode(CSSParserTokenRange& range) {
-  CSSValueID id = range.peek().id();
-  if (id == CSSValueNormal || id == CSSValueOverlay ||
-      (id >= CSSValueMultiply && id <= CSSValueLuminosity))
-    return consumeIdent(range);
-  return nullptr;
-}
-
-static CSSValue* consumeBackgroundAttachment(CSSParserTokenRange& range) {
-  return consumeIdent<CSSValueScroll, CSSValueFixed, CSSValueLocal>(range);
-}
-
-static CSSValue* consumeBackgroundBox(CSSParserTokenRange& range) {
-  return consumeIdent<CSSValueBorderBox, CSSValuePaddingBox,
-                      CSSValueContentBox>(range);
-}
-
-static CSSValue* consumeBackgroundComposite(CSSParserTokenRange& range) {
-  return consumeIdentRange(range, CSSValueClear, CSSValuePlusLighter);
-}
-
-static CSSValue* consumeMaskSourceType(CSSParserTokenRange& range) {
-  ASSERT(RuntimeEnabledFeatures::cssMaskSourceTypeEnabled());
-  return consumeIdent<CSSValueAuto, CSSValueAlpha, CSSValueLuminance>(range);
-}
-
-static CSSValue* consumePrefixedBackgroundBox(CSSPropertyID property,
-                                              CSSParserTokenRange& range,
-                                              const CSSParserContext* context) {
-  // The values 'border', 'padding' and 'content' are deprecated and do not
-  // apply to the version of the property that has the -webkit- prefix removed.
-  if (CSSValue* value =
-          consumeIdentRange(range, CSSValueBorder, CSSValuePaddingBox))
-    return value;
-  if ((property == CSSPropertyWebkitBackgroundClip ||
-       property == CSSPropertyWebkitMaskClip) &&
-      range.peek().id() == CSSValueText)
-    return consumeIdent(range);
-  return nullptr;
-}
-
-static CSSValue* consumeBackgroundSize(CSSPropertyID unresolvedProperty,
-                                       CSSParserTokenRange& range,
-                                       CSSParserMode cssParserMode) {
-  if (identMatches<CSSValueContain, CSSValueCover>(range.peek().id()))
-    return consumeIdent(range);
-
-  CSSValue* horizontal = consumeIdent<CSSValueAuto>(range);
-  if (!horizontal)
-    horizontal = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll,
-                                        UnitlessQuirk::Forbid);
-
-  CSSValue* vertical = nullptr;
-  if (!range.atEnd()) {
-    if (range.peek().id() == CSSValueAuto)  // `auto' is the default
-      range.consumeIncludingWhitespace();
-    else
-      vertical = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll,
-                                        UnitlessQuirk::Forbid);
-  } else if (unresolvedProperty == CSSPropertyAliasWebkitBackgroundSize) {
-    // Legacy syntax: "-webkit-background-size: 10px" is equivalent to
-    // "background-size: 10px 10px".
-    vertical = horizontal;
-  }
-  if (!vertical)
-    return horizontal;
-  return CSSValuePair::create(horizontal, vertical,
-                              CSSValuePair::KeepIdenticalValues);
-}
-
-static CSSValue* consumeBackgroundComponent(CSSPropertyID unresolvedProperty,
-                                            CSSParserTokenRange& range,
-                                            const CSSParserContext* context) {
-  switch (unresolvedProperty) {
-    case CSSPropertyBackgroundClip:
-      return consumeBackgroundBox(range);
-    case CSSPropertyBackgroundBlendMode:
-      return consumeBackgroundBlendMode(range);
-    case CSSPropertyBackgroundAttachment:
-      return consumeBackgroundAttachment(range);
-    case CSSPropertyBackgroundOrigin:
-      return consumeBackgroundBox(range);
-    case CSSPropertyWebkitMaskComposite:
-      return consumeBackgroundComposite(range);
-    case CSSPropertyMaskSourceType:
-      return consumeMaskSourceType(range);
-    case CSSPropertyWebkitBackgroundClip:
-    case CSSPropertyWebkitBackgroundOrigin:
-    case CSSPropertyWebkitMaskClip:
-    case CSSPropertyWebkitMaskOrigin:
-      return consumePrefixedBackgroundBox(unresolvedProperty, range, context);
-    case CSSPropertyBackgroundImage:
-    case CSSPropertyWebkitMaskImage:
-      return consumeImageOrNone(range, context);
-    case CSSPropertyBackgroundPositionX:
-    case CSSPropertyWebkitMaskPositionX:
-      return CSSPropertyPositionUtils::consumePositionLonghand<CSSValueLeft,
-                                                               CSSValueRight>(
-          range, context->mode());
-    case CSSPropertyBackgroundPositionY:
-    case CSSPropertyWebkitMaskPositionY:
-      return CSSPropertyPositionUtils::consumePositionLonghand<CSSValueTop,
-                                                               CSSValueBottom>(
-          range, context->mode());
-    case CSSPropertyBackgroundSize:
-    case CSSPropertyAliasWebkitBackgroundSize:
-    case CSSPropertyWebkitMaskSize:
-      return consumeBackgroundSize(unresolvedProperty, range, context->mode());
-    case CSSPropertyBackgroundColor:
-      return consumeColor(range, context->mode());
-    default:
-      break;
-  };
-  return nullptr;
-}
-
-static void addBackgroundValue(CSSValue*& list, CSSValue* value) {
-  if (list) {
-    if (!list->isBaseValueList()) {
-      CSSValue* firstValue = list;
-      list = CSSValueList::createCommaSeparated();
-      toCSSValueList(list)->append(*firstValue);
-    }
-    toCSSValueList(list)->append(*value);
-  } else {
-    // To conserve memory we don't actually wrap a single value in a list.
-    list = value;
-  }
-}
-
 static CSSValue* consumeCommaSeparatedBackgroundComponent(
     CSSPropertyID unresolvedProperty,
     CSSParserTokenRange& range,
     const CSSParserContext* context) {
   CSSValue* result = nullptr;
   do {
     CSSValue* value =
-        consumeBackgroundComponent(unresolvedProperty, range, context);
+        CSSPropertyBackgroundComponentUtils::consumeBackgroundComponent(
+            unresolvedProperty, range, context);
     if (!value)
       return nullptr;
-    addBackgroundValue(result, value);
+    CSSPropertyBackgroundComponentUtils::addBackgroundValue(result, value);
   } while (consumeCommaIncludingWhitespace(range));
   return result;
 }
 
 static CSSValue* consumeAlignItems(CSSParserTokenRange& range) {
   // align-items property does not allow the 'auto' value.
   if (identMatches<CSSValueAuto>(range.peek().id()))
     return nullptr;
   return CSSPropertyAlignmentUtils::consumeSelfPositionOverflowPosition(range);
 }
@@ skipping 1589 matching lines @@
                                       const CSSParserContext* context,
                                       UnitlessQuirk unitless,
                                       CSSValue*& resultX,
                                       CSSValue*& resultY) {
   do {
     CSSValue* positionX = nullptr;
     CSSValue* positionY = nullptr;
     if (!consumePosition(range, context->mode(), unitless, positionX,
                          positionY))
       return false;
-    addBackgroundValue(resultX, positionX);
-    addBackgroundValue(resultY, positionY);
+    CSSPropertyBackgroundComponentUtils::addBackgroundValue(resultX, positionX);
+    CSSPropertyBackgroundComponentUtils::addBackgroundValue(resultY, positionY);
   } while (consumeCommaIncludingWhitespace(range));
   return true;
 }
 
 static bool consumeRepeatStyleComponent(CSSParserTokenRange& range,
                                         CSSValue*& value1,
                                         CSSValue*& value2,
                                         bool& implicit) {
   if (consumeIdent<CSSValueRepeatX>(range)) {
     value1 = CSSIdentifierValue::create(CSSValueRepeat);
@@ skipping 23 matching lines @@
 
 static bool consumeRepeatStyle(CSSParserTokenRange& range,
                                CSSValue*& resultX,
                                CSSValue*& resultY,
                                bool& implicit) {
   do {
     CSSValue* repeatX = nullptr;
     CSSValue* repeatY = nullptr;
     if (!consumeRepeatStyleComponent(range, repeatX, repeatY, implicit))
       return false;
-    addBackgroundValue(resultX, repeatX);
-    addBackgroundValue(resultY, repeatY);
+    CSSPropertyBackgroundComponentUtils::addBackgroundValue(resultX, repeatX);
+    CSSPropertyBackgroundComponentUtils::addBackgroundValue(resultY, repeatY);
   } while (consumeCommaIncludingWhitespace(range));
   return true;
 }
 
 // Note: consumeBackgroundShorthand assumes y properties (for example
 // background-position-y) follow the x properties in the shorthand array.
 bool CSSPropertyParser::consumeBackgroundShorthand(
     const StylePropertyShorthand& shorthand,
     bool important) {
   const unsigned longhandCount = shorthand.length();
@@ skipping 18 matching lines @@
           consumeRepeatStyleComponent(m_range, value, valueY, implicit);
         } else if (property == CSSPropertyBackgroundPositionX ||
                    property == CSSPropertyWebkitMaskPositionX) {
           if (!consumePosition(m_range, m_context->mode(),
                                UnitlessQuirk::Forbid, value, valueY))
             continue;
         } else if (property == CSSPropertyBackgroundSize ||
                    property == CSSPropertyWebkitMaskSize) {
           if (!consumeSlashIncludingWhitespace(m_range))
             continue;
-          value = consumeBackgroundSize(property, m_range, m_context->mode());
+          value = CSSPropertyBackgroundComponentUtils::consumeBackgroundSize(
+              property, m_range, m_context->mode());
           if (!value || !parsedLonghand[i - 1])  // Position must have been
                                                  // parsed in the current layer.
             return false;
         } else if (property == CSSPropertyBackgroundPositionY ||
                    property == CSSPropertyBackgroundRepeatY ||
                    property == CSSPropertyWebkitMaskPositionY ||
                    property == CSSPropertyWebkitMaskRepeatY) {
           continue;
         } else {
-          value = consumeBackgroundComponent(property, m_range, m_context);
+          value =
+              CSSPropertyBackgroundComponentUtils::consumeBackgroundComponent(
+                  property, m_range, m_context);
         }
         if (value) {
           if (property == CSSPropertyBackgroundOrigin ||
               property == CSSPropertyWebkitMaskOrigin)
             originValue = value;
           parsedLonghand[i] = true;
           foundProperty = true;
-          addBackgroundValue(longhands[i], value);
+          CSSPropertyBackgroundComponentUtils::addBackgroundValue(longhands[i],
+                                                                  value);
           if (valueY) {
             parsedLonghand[i + 1] = true;
-            addBackgroundValue(longhands[i + 1], valueY);
+            CSSPropertyBackgroundComponentUtils::addBackgroundValue(
+                longhands[i + 1], valueY);
           }
         }
       }
       if (!foundProperty)
         return false;
     } while (!m_range.atEnd() && m_range.peek().type() != CommaToken);
 
     // TODO(timloh): This will make invalid longhands, see crbug.com/386459
     for (size_t i = 0; i < longhandCount; ++i) {
       CSSPropertyID property = shorthand.properties()[i];
       if (property == CSSPropertyBackgroundColor && !m_range.atEnd()) {
         if (parsedLonghand[i])
           return false;  // Colors are only allowed in the last layer.
         continue;
       }
       if ((property == CSSPropertyBackgroundClip ||
            property == CSSPropertyWebkitMaskClip) &&
           !parsedLonghand[i] && originValue) {
-        addBackgroundValue(longhands[i], originValue);
+        CSSPropertyBackgroundComponentUtils::addBackgroundValue(longhands[i],
+                                                                originValue);
         continue;
       }
-      if (!parsedLonghand[i])
-        addBackgroundValue(longhands[i], CSSInitialValue::create());
+      if (!parsedLonghand[i]) {
+        CSSPropertyBackgroundComponentUtils::addBackgroundValue(
+            longhands[i], CSSInitialValue::create());
+      }
     }
   } while (consumeCommaIncludingWhitespace(m_range));
   if (!m_range.atEnd())
     return false;
 
   for (size_t i = 0; i < longhandCount; ++i) {
     CSSPropertyID property = shorthand.properties()[i];
     if (property == CSSPropertyBackgroundSize && longhands[i] &&
         m_context->useLegacyBackgroundSizeShorthandBehavior())
       continue;
@@ skipping 545 matching lines @@
     case CSSPropertyGridTemplate:
       return consumeGridTemplateShorthand(CSSPropertyGridTemplate, important);
     case CSSPropertyGrid:
       return consumeGridShorthand(important);
     default:
       return false;
   }
 }
 
 }  // namespace blink