Don't check implicit flag for serializing background and -webkit-mask

third_party/WebKit/Source/core/css/StylePropertySerializer.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2011 Research In Motion Limited. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 135 matching lines @@
 const CSSValue*
 StylePropertySerializer::StylePropertySetForSerializer::getPropertyCSSValue(
     CSSPropertyID propertyID) const {
   int index = findPropertyIndex(propertyID);
   if (index == -1)
     return nullptr;
   StylePropertySerializer::PropertyValueForSerializer value = propertyAt(index);
   return value.value();
 }
 
-bool StylePropertySerializer::StylePropertySetForSerializer::isPropertyImplicit(
-    CSSPropertyID propertyID) const {
-  int index = findPropertyIndex(propertyID);
-  if (index == -1)
-    return false;
-  StylePropertySerializer::PropertyValueForSerializer value = propertyAt(index);
-  return value.isImplicit();
-}
-
 StylePropertySerializer::StylePropertySerializer(
     const StylePropertySet& properties)
     : m_propertySet(properties) {}
 
 String StylePropertySerializer::getCustomPropertyText(
     const PropertyValueForSerializer& property,
     bool isNotFirstDecl) const {
   DCHECK_EQ(property.id(), CSSPropertyVariable);
   StringBuilder result;
   if (isNotFirstDecl)
@@ skipping 137 matching lines @@
 // setting "missing" sub-properties to their initial values. This means
 // that a shorthand can never represent a list of subproperties where
 // some are "initial" and some are not, and so serialization should
 // always fail in these cases (as per cssom). However we currently use
 // "initial" instead of the initial values for certain shorthands, so
 // these are special-cased here.
 // TODO(timloh): Don't use "initial" in shorthands and remove this
 // special-casing
 static bool allowInitialInShorthand(CSSPropertyID propertyID) {
   switch (propertyID) {
+    case CSSPropertyBackground:
     case CSSPropertyBorder:
     case CSSPropertyBorderTop:
     case CSSPropertyBorderRight:
     case CSSPropertyBorderBottom:
     case CSSPropertyBorderLeft:
     case CSSPropertyOutline:
     case CSSPropertyColumnRule:
     case CSSPropertyColumns:
     case CSSPropertyFlex:
     case CSSPropertyFlexFlow:
     case CSSPropertyGridColumn:
     case CSSPropertyGridRow:
     case CSSPropertyGridArea:
     case CSSPropertyGridGap:
+    case CSSPropertyListStyle:
     case CSSPropertyMotion:
     case CSSPropertyOffset:
+    case CSSPropertyTextDecoration:
     case CSSPropertyWebkitMarginCollapse:
-    case CSSPropertyListStyle:
-    case CSSPropertyTextDecoration:
+    case CSSPropertyWebkitMask:
     case CSSPropertyWebkitTextEmphasis:
     case CSSPropertyWebkitTextStroke:
       return true;
     default:
       return false;
   }
 }
 
-// TODO(timloh): This should go away eventually, see crbug.com/471917
-static bool allowImplicitInitialInShorthand(CSSPropertyID propertyID) {
-  return propertyID == CSSPropertyBackground ||
-         propertyID == CSSPropertyWebkitMask;
-}
-
 String StylePropertySerializer::commonShorthandChecks(
     const StylePropertyShorthand& shorthand) const {
   int longhandCount = shorthand.length();
   DCHECK_LE(longhandCount, 17);
   const CSSValue* longhands[17] = {};
 
   bool hasImportant = false;
   bool hasNonImportant = false;
 
   for (int i = 0; i < longhandCount; i++) {
@@ skipping 24 matching lines @@
     if (success) {
       if (longhands[0]->isPendingSubstitutionValue())
         return toCSSPendingSubstitutionValue(longhands[0])
             ->shorthandValue()
             ->cssText();
       return longhands[0]->cssText();
     }
   }
 
   bool allowInitial = allowInitialInShorthand(shorthand.id());
-  bool allowImplicitInitial =
-      allowInitial || allowImplicitInitialInShorthand(shorthand.id());
   for (int i = 0; i < longhandCount; i++) {
     const CSSValue& value = *longhands[i];
-    if (value.isImplicitInitialValue()) {
-      if (allowImplicitInitial)
-        continue;
-      return emptyString();
-    }
     if (!allowInitial && value.isInitialValue())
       return emptyString();
     if (value.isInheritedValue() || value.isUnsetValue() ||
         value.isPendingSubstitutionValue())
       return emptyString();
     if (value.isVariableReferenceValue())
       return emptyString();
   }
 
   return String();
@@ skipping 288 matching lines @@
 
 String StylePropertySerializer::getLayeredShorthandValue(
     const StylePropertyShorthand& shorthand) const {
   const unsigned size = shorthand.length();
 
   // Begin by collecting the properties into a vector.
   HeapVector<Member<const CSSValue>> values(size);
   // If the below loop succeeds, there should always be at minimum 1 layer.
   size_t numLayers = 1U;
 
+  // TODO(timloh): Shouldn't we fail if the lists are differently sized, with
+  // the exception of background-color?
   for (size_t i = 0; i < size; i++) {
     values[i] = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
     if (values[i]->isBaseValueList()) {
       const CSSValueList* valueList = toCSSValueList(values[i]);
       numLayers = std::max(numLayers, valueList->length());
     }
   }
 
   StringBuilder result;
 
-  // Now stitch the properties together. Implicit initial values are flagged as
-  // such and
-  // can safely be omitted.
+  // Now stitch the properties together.
   for (size_t layer = 0; layer < numLayers; layer++) {
     StringBuilder layerResult;
     bool useRepeatXShorthand = false;
     bool useRepeatYShorthand = false;
     bool useSingleWordShorthand = false;
     bool foundPositionXCSSProperty = false;
     bool foundPositionYCSSProperty = false;
 
     for (unsigned propertyIndex = 0; propertyIndex < size; propertyIndex++) {
       const CSSValue* value = nullptr;
@@ skipping 10 matching lines @@
                                 property == CSSPropertyBackgroundColor)) {
         // Singletons except background color belong in the 0th layer.
         // Background color belongs in the last layer.
         value = values[propertyIndex];
       }
       // No point proceeding if there's not a value to look at.
       if (!value)
         continue;
 
       // Special case for background-repeat.
-      if ((propertyIndex < size - 1 &&
-           m_propertySet.isPropertyImplicit(property)) &&
-          (property == CSSPropertyBackgroundRepeatX ||
-           property == CSSPropertyWebkitMaskRepeatX)) {
+      if (property == CSSPropertyBackgroundRepeatX ||
+          property == CSSPropertyWebkitMaskRepeatX) {
         DCHECK(shorthand.properties()[propertyIndex + 1] ==
                    CSSPropertyBackgroundRepeatY ||
                shorthand.properties()[propertyIndex + 1] ==
                    CSSPropertyWebkitMaskRepeatY);
         const CSSValue& yValue =
             values[propertyIndex + 1]->isValueList()
                 ? toCSSValueList(values[propertyIndex + 1])->item(layer)
                 : *values[propertyIndex + 1];
 
         // FIXME: At some point we need to fix this code to avoid returning an
@@ skipping 11 matching lines @@
           property = shorthand.properties()[++propertyIndex];
         } else if (xId == CSSValueRepeat && yId == CSSValueNoRepeat) {
           useRepeatXShorthand = true;
           property = shorthand.properties()[++propertyIndex];
         } else if (xId == CSSValueNoRepeat && yId == CSSValueRepeat) {
           useRepeatYShorthand = true;
           property = shorthand.properties()[++propertyIndex];
         }
       }
 
-      if (!(value->isInitialValue() &&
-            toCSSInitialValue(value)->isImplicit())) {
+      if (!value->isInitialValue()) {
         if (property == CSSPropertyBackgroundSize ||
             property == CSSPropertyWebkitMaskSize) {
           if (foundPositionYCSSProperty || foundPositionXCSSProperty)
             layerResult.append(" / ");
           else
             layerResult.append(" 0% 0% / ");
         } else if (!layerResult.isEmpty()) {
           // Do this second to avoid ending up with an extra space in the output
           // if we hit the continue above.
           layerResult.append(' ');
@@ skipping 144 matching lines @@
     const CSSValue& xValue =
         repeatXList ? repeatXList->item(i % repeatXList->length()) : repeatX;
     const CSSValue& yValue =
         repeatYList ? repeatYList->item(i % repeatYList->length()) : repeatY;
     appendBackgroundRepeatValue(builder, xValue, yValue);
   }
   return builder.toString();
 }
 
 }  // namespace blink