border-foo WIP

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
  * version 2 of the License, or (at your option) any later version.
@@ skipping 307 matching lines @@
     case CSSPropertyWebkitMarginCollapse:
     case CSSPropertyListStyle:
     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 21 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)
+        if (value.isImplicit())
                 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 309 matching lines @@
             if ((propertyIndex < size - 1 && m_propertySet.isPropertyImplicit(property))
                 && (property == CSSPropertyBackgroundRepeatX || property == CSSPropertyWebkitMaskRepeatX)) {
                 ASSERT(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 invalid shorthand,
                 // since some longhand combinations are not serializable into a single shorthand.
-                if (!value->isPrimitiveValue() || !yValue.isPrimitiveValue())
+                if (!value->isPrimitiveValue() || !yValue.isPrimitiveValue() || value->isImplicit() || yValue.isImplicit())
                     continue;
 
                 CSSValueID xId = toCSSPrimitiveValue(value)->getValueID();
                 CSSValueID yId = toCSSPrimitiveValue(yValue).getValueID();
                 // Maybe advance propertyIndex to look at the next CSSValue in the list for the checks below.
                 if (xId == yId) {
                     useSingleWordShorthand = true;
                     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->isImplicit())) {
                 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 41 matching lines @@
     }
     return result.toString();
 }
 
 // only returns a non-null value if all properties have the same, non-null value
 String StylePropertySerializer::getCommonValue(const StylePropertyShorthand& shorthand) const
 {
     String res;
     for (unsigned i = 0; i < shorthand.length(); ++i) {
         const CSSValue* value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
-        // FIXME: CSSInitialValue::cssText should generate the right value.
         String text = value->cssText();
+        if (value->isImplicit())
+            text = "initial";
         if (res.isNull())
             res = text;
         else if (res != text)
             return String();
     }
     return res;
 }
 
 String StylePropertySerializer::borderPropertyValue() const
 {
@@ skipping 63 matching lines @@
             builder.append(", ");
 
         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