Implement all shorthand property.

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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "config.h"
 #include "core/css/StylePropertySerializer.h"
 
 #include "CSSValueKeywords.h"
 #include "StylePropertyShorthand.h"
+#include "core/css/CSSValuePool.h"
 #include "core/css/RuntimeCSSEnabled.h"
 #include "wtf/BitArray.h"
 #include "wtf/text/StringBuilder.h"
 
 using namespace std;
 
 namespace WebCore {
 
 static bool isInitialOrInherit(const String& value)
 {
     DEFINE_STATIC_LOCAL(String, initial, ("initial"));
     DEFINE_STATIC_LOCAL(String, inherit, ("inherit"));
     return value.length() == 7 && (value == initial || value == inherit);
 }
 
+static bool shouldExpandAll(const StylePropertySet& properties)
+{
+    int allIndex = properties.findPropertyIndex(CSSPropertyAll);
+    if (allIndex == -1)
+        return false;
+
+    for (unsigned i = 0; i < properties.propertyCount(); ++i) {
+        StylePropertySet::PropertyReference property = properties.propertyAt(i);
+        if (CSSProperty::isAffectedByAllProperty(property.id()))
+            return true;
+    }
+    return false;
+}
+
+static bool canAllOverwriteProperty(const StylePropertySet::PropertyReference& all, unsigned allIndex, const StylePropertySet::PropertyReference& property, unsigned propertyIndex)

[esprehn, 2014/06/12 00:36:45]

Can you explain the purpose of this?

+{
+    if (allIndex == propertyIndex)
+        return true;
+    if (!CSSProperty::isAffectedByAllProperty(property.id()))
+        return false;
+    if (all.isImportant() != property.isImportant())
+        return all.isImportant();
+    return propertyIndex < allIndex;
+}
+
+void StylePropertySerializer::expandAll()
+{
+    unsigned allIndex = m_propertySet.findPropertyIndex(CSSPropertyAll);
+    StylePropertySet::PropertyReference all = m_propertySet.propertyAt(allIndex);
+    BitArray<numCSSProperties> shorthandPropertyAppeared;
+
+    unsigned position = 0;
+    for (unsigned i = 0; i < m_propertySet.propertyCount(); ++i) {
+        StylePropertySet::PropertyReference property = m_propertySet.propertyAt(i);
+        CSSPropertyID propertyId = property.id();
+
+        if (propertyId == CSSPropertyAll)
+            position = m_propertyVector.size();
+
+        if (!canAllOverwriteProperty(all, allIndex, property, i)) {
+            m_propertyVector.append(CSSPropertyInternal(property));
+
+            unsigned shortPropertyIndex = property.id() - firstCSSProperty;
+            shorthandPropertyAppeared.set(shortPropertyIndex);
+        }
+    }
+
+    bool allIsUnset = !all.value()->isInitialValue() && !all.value()->isInheritedValue();
+    CSSValue* value = all.value();
+
+    for (int i = firstCSSProperty; i <= lastCSSProperty; ++i) {
+        CSSPropertyID propertyId = static_cast<CSSPropertyID>(i);
+
+        if (isExpandedShorthandForAll(propertyId))
+            continue;
+        if (!CSSProperty::isAffectedByAllProperty(propertyId))
+            continue;
+        if (shorthandPropertyAppeared.get(i - firstCSSProperty))
+            continue;
+
+        if (allIsUnset) {
+            if (CSSProperty::isInheritedProperty(propertyId))
+                value = cssValuePool().createInheritedValue().get();
+            else
+                value = cssValuePool().createExplicitInitialValue().get();
+        }
+        m_propertyVector.insert(position++, CSSPropertyInternal(propertyId, value, all.isImportant(), value->isInheritedValue(), all.isImplicit()));

[esprehn, 2014/06/12 00:36:44]

All these vector inserts are going to be really expensive.

+    }
+}
+
 StylePropertySerializer::StylePropertySerializer(const StylePropertySet& properties)
     : m_propertySet(properties)
 {
+    if (shouldExpandAll(properties))
+        expandAll();
+}
+
+unsigned StylePropertySerializer::propertyCount() const
+{
+    if (m_propertyVector.isEmpty())
+        return m_propertySet.propertyCount();
+
+    return m_propertyVector.size();
+}
+
+StylePropertySerializer::CSSPropertyInternal StylePropertySerializer::propertyAt(unsigned index) const
+{
+    if (m_propertyVector.isEmpty())
+        return CSSPropertyInternal(m_propertySet.propertyAt(index));
+
+    return m_propertyVector.at(index);

[esprehn, 2014/06/12 00:36:45]

m_propertyVector[index] ?

+}
+
+String StylePropertySerializer::propertyValue(CSSPropertyID propertyId) const
+{
+    if (m_propertyVector.isEmpty())
+        return m_propertySet.getPropertyValue(propertyId);
+
+    int index = findPropertyIndex(propertyId);
+    if (index == -1)
+        return String();
+    if (CSSValue* value = m_propertyVector.at(index).value())

[esprehn, 2014/06/12 00:36:45]

ditto

+        return value->cssText();
+    return String();
+}
+
+CSSValue* StylePropertySerializer::getPropertyCSSValue(CSSPropertyID propertyId) const
+{
+    if (m_propertyVector.isEmpty())
+        return m_propertySet.getPropertyCSSValue(propertyId).get();
+
+    int index = findPropertyIndex(propertyId);
+    if (index == -1)
+        return 0;
+    return m_propertyVector.at(index).value();

[esprehn, 2014/06/12 00:36:45]

ditto

+}
+
+int StylePropertySerializer::findPropertyIndex(CSSPropertyID propertyId) const
+{
+    if (m_propertyVector.isEmpty())
+        return m_propertySet.findPropertyIndex(propertyId);
+
+    for (unsigned i = 0; i < m_propertyVector.size(); ++i) {
+        if (m_propertyVector.at(i).id() == propertyId)

[esprehn, 2014/06/12 00:36:45]

m_propertyVector[i].id()

+            return i;
+    }
+    return -1;
+}
+
+bool StylePropertySerializer::isPropertyImplicit(CSSPropertyID propertyId) const
+{
+    if (m_propertyVector.isEmpty())
+        return m_propertySet.isPropertyImplicit(propertyId);
+
+    int index = findPropertyIndex(propertyId);
+    if (index == -1)
+        return false;
+    return m_propertyVector.at(index).isImplicit();
+}
+
+bool StylePropertySerializer::propertyIsImportant(CSSPropertyID propertyId) const
+{
+    if (m_propertyVector.isEmpty())
+        return m_propertySet.propertyIsImportant(propertyId);
+
+    int index = findPropertyIndex(propertyId);
+    if (index == -1)
+        return false;
+    return m_propertyVector.at(index).isImportant();
 }
 
 String StylePropertySerializer::getPropertyText(CSSPropertyID propertyID, const String& value, bool isImportant, bool isNotFirstDecl) const
 {
     StringBuilder result;
     if (isNotFirstDecl)
         result.append(' ');
     result.append(getPropertyName(propertyID));
     result.appendLiteral(": ");
     result.append(value);
     if (isImportant)
         result.appendLiteral(" !important");
     result.append(';');
     return result.toString();
 }
 
 String StylePropertySerializer::asText() const
 {
     StringBuilder result;
 
+    String allValue;
+    if (hasAllShorthand(allValue))
+        return allValue;
+
     BitArray<numCSSProperties> shorthandPropertyUsed;
     BitArray<numCSSProperties> shorthandPropertyAppeared;
 
-    unsigned size = m_propertySet.propertyCount();
+    unsigned size = propertyCount();
     unsigned numDecls = 0;
     for (unsigned n = 0; n < size; ++n) {
-        StylePropertySet::PropertyReference property = m_propertySet.propertyAt(n);
+        CSSPropertyInternal property = propertyAt(n);
         CSSPropertyID propertyID = property.id();
         // Only enabled or internal properties should be part of the style.
         ASSERT(RuntimeCSSEnabled::isCSSPropertyEnabled(propertyID) || isInternalProperty(propertyID));
         CSSPropertyID shorthandPropertyID = CSSPropertyInvalid;
         CSSPropertyID borderFallbackShorthandProperty = CSSPropertyInvalid;
         String value;
 
         switch (propertyID) {
         case CSSPropertyBackgroundAttachment:
         case CSSPropertyBackgroundClip:
@@ skipping 119 matching lines @@
         case CSSPropertyWebkitTransformOriginY:
         case CSSPropertyWebkitTransformOriginZ:
             shorthandPropertyID = CSSPropertyWebkitTransformOrigin;
             break;
         case CSSPropertyWebkitTransitionProperty:
         case CSSPropertyWebkitTransitionDuration:
         case CSSPropertyWebkitTransitionTimingFunction:
         case CSSPropertyWebkitTransitionDelay:
             shorthandPropertyID = CSSPropertyWebkitTransition;
             break;
+        case CSSPropertyAll:
+            result.append(getPropertyText(propertyID, property.value()->cssText(), property.isImportant(), numDecls++));
+            continue;
         default:
             break;
         }
 
         unsigned shortPropertyIndex = shorthandPropertyID - firstCSSProperty;
         if (shorthandPropertyID) {
             if (shorthandPropertyUsed.get(shortPropertyIndex))
                 continue;
             if (!shorthandPropertyAppeared.get(shortPropertyIndex) && value.isNull())
-                value = m_propertySet.getPropertyValue(shorthandPropertyID);
+                value = propertyValue(shorthandPropertyID);
             shorthandPropertyAppeared.set(shortPropertyIndex);
         }
 
         if (!value.isNull()) {
             if (shorthandPropertyID) {
                 propertyID = shorthandPropertyID;
                 shorthandPropertyUsed.set(shortPropertyIndex);
             }
-        } else
+        } else {
+            // We should not show "initial" when the "initial" is implicit.
+            // If explicit "initial", we need to show.
+            if (property.value()->isImplicitInitialValue())
+                continue;
             value = property.value()->cssText();
-
-        if (value == "initial" && !CSSProperty::isInheritedProperty(propertyID))
-            continue;
+        }
 
         result.append(getPropertyText(propertyID, value, property.isImportant(), numDecls++));
     }
 
     if (shorthandPropertyAppeared.get(CSSPropertyBackground - firstCSSProperty))
         appendBackgroundPropertyAsText(result, numDecls);
 
     ASSERT(!numDecls ^ !result.isEmpty());
     return result.toString();
 }
@@ skipping 69 matching lines @@
     case CSSPropertyWebkitTextStroke:
         return getShorthandValue(webkitTextStrokeShorthand());
     case CSSPropertyTransformOrigin:
     case CSSPropertyWebkitTransformOrigin:
         return getShorthandValue(webkitTransformOriginShorthand());
     case CSSPropertyWebkitTransition:
         return getLayeredShorthandValue(webkitTransitionShorthand());
     case CSSPropertyWebkitAnimation:
         return getLayeredShorthandValue(webkitAnimationShorthand());
     case CSSPropertyMarker: {
-        RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyMarkerStart);
+        RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(CSSPropertyMarkerStart);
         if (value)
             return value->cssText();
         return String();
     }
     case CSSPropertyBorderRadius:
         return get4Values(borderRadiusShorthand());
     default:
         return String();
     }
 }
 
 String StylePropertySerializer::borderSpacingValue(const StylePropertyShorthand& shorthand) const
 {
-    RefPtrWillBeRawPtr<CSSValue> horizontalValue = m_propertySet.getPropertyCSSValue(shorthand.properties()[0]);
-    RefPtrWillBeRawPtr<CSSValue> verticalValue = m_propertySet.getPropertyCSSValue(shorthand.properties()[1]);
+    RefPtrWillBeRawPtr<CSSValue> horizontalValue = getPropertyCSSValue(shorthand.properties()[0]);
+    RefPtrWillBeRawPtr<CSSValue> verticalValue = getPropertyCSSValue(shorthand.properties()[1]);
 
     // While standard border-spacing property does not allow specifying border-spacing-vertical without
     // specifying border-spacing-horizontal <http://www.w3.org/TR/CSS21/tables.html#separated-borders>,
     // -webkit-border-spacing-vertical can be set without -webkit-border-spacing-horizontal.
     if (!horizontalValue || !verticalValue)
         return String();
 
     String horizontalValueCSSText = horizontalValue->cssText();
     String verticalValueCSSText = verticalValue->cssText();
     if (horizontalValueCSSText == verticalValueCSSText)
         return horizontalValueCSSText;
     return horizontalValueCSSText + ' ' + verticalValueCSSText;
 }
 
 void StylePropertySerializer::appendFontLonghandValueIfExplicit(CSSPropertyID propertyID, StringBuilder& result, String& commonValue) const
 {
-    int foundPropertyIndex = m_propertySet.findPropertyIndex(propertyID);
+    int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return; // All longhands must have at least implicit values if "font" is specified.
 
-    if (m_propertySet.propertyAt(foundPropertyIndex).isImplicit()) {
+    if (propertyAt(foundPropertyIndex).isImplicit()) {
         commonValue = String();
         return;
     }
 
     char prefix = '\0';
     switch (propertyID) {
     case CSSPropertyFontStyle:
         break; // No prefix.
     case CSSPropertyFontFamily:
     case CSSPropertyFontVariant:
     case CSSPropertyFontWeight:
         prefix = ' ';
         break;
     case CSSPropertyLineHeight:
         prefix = '/';
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     if (prefix && !result.isEmpty())
         result.append(prefix);
-    String value = m_propertySet.propertyAt(foundPropertyIndex).value()->cssText();
+    String value = propertyAt(foundPropertyIndex).value()->cssText();
     result.append(value);
     if (!commonValue.isNull() && commonValue != value)
         commonValue = String();
 }
 
 String StylePropertySerializer::fontValue() const
 {
-    int fontSizePropertyIndex = m_propertySet.findPropertyIndex(CSSPropertyFontSize);
-    int fontFamilyPropertyIndex = m_propertySet.findPropertyIndex(CSSPropertyFontFamily);
+    int fontSizePropertyIndex = findPropertyIndex(CSSPropertyFontSize);
+    int fontFamilyPropertyIndex = findPropertyIndex(CSSPropertyFontFamily);
     if (fontSizePropertyIndex == -1 || fontFamilyPropertyIndex == -1)
         return emptyString();
 
-    StylePropertySet::PropertyReference fontSizeProperty = m_propertySet.propertyAt(fontSizePropertyIndex);
-    StylePropertySet::PropertyReference fontFamilyProperty = m_propertySet.propertyAt(fontFamilyPropertyIndex);
+    CSSPropertyInternal fontSizeProperty = propertyAt(fontSizePropertyIndex);
+    CSSPropertyInternal fontFamilyProperty = propertyAt(fontFamilyPropertyIndex);
     if (fontSizeProperty.isImplicit() || fontFamilyProperty.isImplicit())
         return emptyString();
 
     String commonValue = fontSizeProperty.value()->cssText();
     StringBuilder result;
     appendFontLonghandValueIfExplicit(CSSPropertyFontStyle, result, commonValue);
     appendFontLonghandValueIfExplicit(CSSPropertyFontVariant, result, commonValue);
     appendFontLonghandValueIfExplicit(CSSPropertyFontWeight, result, commonValue);
     if (!result.isEmpty())
         result.append(' ');
     result.append(fontSizeProperty.value()->cssText());
     appendFontLonghandValueIfExplicit(CSSPropertyLineHeight, result, commonValue);
     if (!result.isEmpty())
         result.append(' ');
     result.append(fontFamilyProperty.value()->cssText());
     if (isInitialOrInherit(commonValue))
         return commonValue;
     return result.toString();
 }
 
 String StylePropertySerializer::get4Values(const StylePropertyShorthand& shorthand) const
 {
     // Assume the properties are in the usual order top, right, bottom, left.
-    int topValueIndex = m_propertySet.findPropertyIndex(shorthand.properties()[0]);
-    int rightValueIndex = m_propertySet.findPropertyIndex(shorthand.properties()[1]);
-    int bottomValueIndex = m_propertySet.findPropertyIndex(shorthand.properties()[2]);
-    int leftValueIndex = m_propertySet.findPropertyIndex(shorthand.properties()[3]);
+    int topValueIndex = findPropertyIndex(shorthand.properties()[0]);
+    int rightValueIndex = findPropertyIndex(shorthand.properties()[1]);
+    int bottomValueIndex = findPropertyIndex(shorthand.properties()[2]);
+    int leftValueIndex = findPropertyIndex(shorthand.properties()[3]);
 
     if (topValueIndex == -1 || rightValueIndex == -1 || bottomValueIndex == -1 || leftValueIndex == -1)
         return String();
 
-    StylePropertySet::PropertyReference top = m_propertySet.propertyAt(topValueIndex);
-    StylePropertySet::PropertyReference right = m_propertySet.propertyAt(rightValueIndex);
-    StylePropertySet::PropertyReference bottom = m_propertySet.propertyAt(bottomValueIndex);
-    StylePropertySet::PropertyReference left = m_propertySet.propertyAt(leftValueIndex);
+    CSSPropertyInternal top = propertyAt(topValueIndex);
+    CSSPropertyInternal right = propertyAt(rightValueIndex);
+    CSSPropertyInternal bottom = propertyAt(bottomValueIndex);
+    CSSPropertyInternal left = propertyAt(leftValueIndex);
 
         // All 4 properties must be specified.
     if (!top.value() || !right.value() || !bottom.value() || !left.value())
         return String();
 
     if (top.isInherited() && right.isInherited() && bottom.isInherited() && left.isInherited())
         return getValueName(CSSValueInherit);
 
     if (top.value()->isInitialValue() || right.value()->isInitialValue() || bottom.value()->isInitialValue() || left.value()->isInitialValue()) {
         if (top.value()->isInitialValue() && right.value()->isInitialValue() && bottom.value()->isInitialValue() && left.value()->isInitialValue() && !top.isImplicit()) {
@@ skipping 29 matching lines @@
 String StylePropertySerializer::getLayeredShorthandValue(const StylePropertyShorthand& shorthand) const
 {
     StringBuilder result;
 
     const unsigned size = shorthand.length();
     // Begin by collecting the properties into an array.
     WillBeHeapVector<RefPtrWillBeMember<CSSValue> > values(size);
     size_t numLayers = 0;
 
     for (unsigned i = 0; i < size; ++i) {
-        values[i] = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
+        values[i] = getPropertyCSSValue(shorthand.properties()[i]);
         if (values[i]) {
             if (values[i]->isBaseValueList()) {
                 CSSValueList* valueList = toCSSValueList(values[i].get());
                 numLayers = max(valueList->length(), numLayers);
             } else
                 numLayers = max<size_t>(1U, numLayers);
         }
     }
 
     String commonValue;
@@ skipping 22 matching lines @@
                     } else if (i) {
                         // Other singletons only belong in the first layer.
                         value = nullptr;
                     }
                 }
             }
 
             // We need to report background-repeat as it was written in the CSS. If the property is implicit,
             // then it was written with only one value. Here we figure out which value that was so we can
             // report back correctly.
-            if ((shorthand.properties()[j] == CSSPropertyBackgroundRepeatX && m_propertySet.isPropertyImplicit(shorthand.properties()[j]))
-                || (shorthand.properties()[j] == CSSPropertyWebkitMaskRepeatX && m_propertySet.isPropertyImplicit(shorthand.properties()[j]))) {
+            if ((shorthand.properties()[j] == CSSPropertyBackgroundRepeatX && isPropertyImplicit(shorthand.properties()[j]))
+                || (shorthand.properties()[j] == CSSPropertyWebkitMaskRepeatX && isPropertyImplicit(shorthand.properties()[j]))) {
 
                 // BUG 49055: make sure the value was not reset in the layer check just above.
                 if ((j < size - 1 && shorthand.properties()[j + 1] == CSSPropertyBackgroundRepeatY && value)
                     || (j < size - 1 && shorthand.properties()[j + 1] == CSSPropertyWebkitMaskRepeatY && value)) {
                     RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
                     RefPtrWillBeRawPtr<CSSValue> nextValue = values[j + 1];
                     if (nextValue->isValueList())
                         yValue = toCSSValueList(nextValue.get())->itemWithoutBoundsCheck(i);
                     else
                         yValue = nextValue;
@@ skipping 80 matching lines @@
     if (result.isEmpty())
         return String();
     return result.toString();
 }
 
 String StylePropertySerializer::getShorthandValue(const StylePropertyShorthand& shorthand) const
 {
     String commonValue;
     StringBuilder result;
     for (unsigned i = 0; i < shorthand.length(); ++i) {
-        if (!m_propertySet.isPropertyImplicit(shorthand.properties()[i])) {
-            RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
+        if (!isPropertyImplicit(shorthand.properties()[i])) {
+            RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(shorthand.properties()[i]);
             if (!value)
                 return String();
             String valueText = value->cssText();
             if (!i)
                 commonValue = valueText;
             else if (!commonValue.isNull() && commonValue != valueText)
                 commonValue = String();
             if (value->isInitialValue())
                 continue;
             if (!result.isEmpty())
                 result.append(' ');
             result.append(valueText);
         } else
             commonValue = String();
     }
     if (isInitialOrInherit(commonValue))
         return commonValue;
     if (result.isEmpty())
         return String();
     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;
     bool lastPropertyWasImportant = false;
     for (unsigned i = 0; i < shorthand.length(); ++i) {
-        RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
+        RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(shorthand.properties()[i]);
         // FIXME: CSSInitialValue::cssText should generate the right value.
         if (!value)
             return String();
         String text = value->cssText();
         if (text.isNull())
             return String();
         if (res.isNull())
             res = text;
         else if (res != text)
             return String();
 
-        bool currentPropertyIsImportant = m_propertySet.propertyIsImportant(shorthand.properties()[i]);
+        bool currentPropertyIsImportant = propertyIsImportant(shorthand.properties()[i]);
         if (i && lastPropertyWasImportant != currentPropertyIsImportant)
             return String();
         lastPropertyWasImportant = currentPropertyIsImportant;
     }
     return res;
 }
 
 String StylePropertySerializer::borderPropertyValue(CommonValueMode valueMode) const
 {
     const StylePropertyShorthand properties[3] = { borderWidthShorthand(), borderStyleShorthand(), borderColorShorthand() };
@@ skipping 38 matching lines @@
         builder.append("repeat-x");
     } else {
         builder.append(repeatX.cssText());
         builder.append(" ");
         builder.append(repeatY.cssText());
     }
 }
 
 String StylePropertySerializer::backgroundRepeatPropertyValue() const
 {
-    RefPtrWillBeRawPtr<CSSValue> repeatX = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatX);
-    RefPtrWillBeRawPtr<CSSValue> repeatY = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatY);
+    RefPtrWillBeRawPtr<CSSValue> repeatX = getPropertyCSSValue(CSSPropertyBackgroundRepeatX);
+    RefPtrWillBeRawPtr<CSSValue> repeatY = getPropertyCSSValue(CSSPropertyBackgroundRepeatY);
     if (!repeatX || !repeatY)
         return String();
-    if (m_propertySet.propertyIsImportant(CSSPropertyBackgroundRepeatX) != m_propertySet.propertyIsImportant(CSSPropertyBackgroundRepeatY))
+    if (propertyIsImportant(CSSPropertyBackgroundRepeatX) != propertyIsImportant(CSSPropertyBackgroundRepeatY))
         return String();
     if (repeatX->cssValueType() == repeatY->cssValueType()
         && (repeatX->cssValueType() == CSSValue::CSS_INITIAL || repeatX->cssValueType() == CSSValue::CSS_INHERIT)) {
         return repeatX->cssText();
     }
 
     RefPtrWillBeRawPtr<CSSValueList> repeatXList;
     if (repeatX->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) {
         repeatXList = CSSValueList::createCommaSeparated();
         repeatXList->append(repeatX);
@@ skipping 22 matching lines @@
             *repeatXList->item(i % repeatXList->length()),
             *repeatYList->item(i % repeatYList->length()));
     }
     return builder.toString();
 }
 
 void StylePropertySerializer::appendBackgroundPropertyAsText(StringBuilder& result, unsigned& numDecls) const
 {
     if (isPropertyShorthandAvailable(backgroundShorthand())) {
         String backgroundValue = getPropertyValue(CSSPropertyBackground);
-        bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundImage);
+        bool isImportant = propertyIsImportant(CSSPropertyBackgroundImage);
         result.append(getPropertyText(CSSPropertyBackground, backgroundValue, isImportant, numDecls++));
         return;
     }
     if (shorthandHasOnlyInitialOrInheritedValue(backgroundShorthand())) {
-        RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundImage);
-        bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundImage);
+        RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(CSSPropertyBackgroundImage);
+        bool isImportant = propertyIsImportant(CSSPropertyBackgroundImage);
         result.append(getPropertyText(CSSPropertyBackground, value->cssText(), isImportant, numDecls++));
         return;
     }
 
     // backgroundShorthandProperty without layered shorhand properties
     const CSSPropertyID backgroundPropertyIds[] = {
         CSSPropertyBackgroundImage,
         CSSPropertyBackgroundAttachment,
         CSSPropertyBackgroundColor,
         CSSPropertyBackgroundSize,
         CSSPropertyBackgroundOrigin,
         CSSPropertyBackgroundClip
     };
 
     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(backgroundPropertyIds); ++i) {
         CSSPropertyID propertyID = backgroundPropertyIds[i];
-        RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(propertyID);
+        RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(propertyID);
         if (!value)
             continue;
-        result.append(getPropertyText(propertyID, value->cssText(), m_propertySet.propertyIsImportant(propertyID), numDecls++));
+        result.append(getPropertyText(propertyID, value->cssText(), propertyIsImportant(propertyID), numDecls++));
     }
 
     // FIXME: This is a not-so-nice way to turn x/y positions into single background-position in output.
     // It is required because background-position-x/y are non-standard properties and WebKit generated output
     // would not work in Firefox (<rdar://problem/5143183>)
     // It would be a better solution if background-position was CSS_PAIR.
     if (shorthandHasOnlyInitialOrInheritedValue(backgroundPositionShorthand())) {
-        RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundPositionX);
-        bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionX);
+        RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(CSSPropertyBackgroundPositionX);
+        bool isImportant = propertyIsImportant(CSSPropertyBackgroundPositionX);
         result.append(getPropertyText(CSSPropertyBackgroundPosition, value->cssText(), isImportant, numDecls++));
     } else if (isPropertyShorthandAvailable(backgroundPositionShorthand())) {
-        String positionValue = m_propertySet.getPropertyValue(CSSPropertyBackgroundPosition);
-        bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionX);
+        String positionValue = propertyValue(CSSPropertyBackgroundPosition);
+        bool isImportant = propertyIsImportant(CSSPropertyBackgroundPositionX);
         if (!positionValue.isNull())
             result.append(getPropertyText(CSSPropertyBackgroundPosition, positionValue, isImportant, numDecls++));
     } else {
         // should check background-position-x or background-position-y.
-        if (RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundPositionX)) {
+        if (RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(CSSPropertyBackgroundPositionX)) {
             if (!value->isImplicitInitialValue()) {
-                bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionX);
+                bool isImportant = propertyIsImportant(CSSPropertyBackgroundPositionX);
                 result.append(getPropertyText(CSSPropertyBackgroundPositionX, value->cssText(), isImportant, numDecls++));
             }
         }
-        if (RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundPositionY)) {
+        if (RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(CSSPropertyBackgroundPositionY)) {
             if (!value->isImplicitInitialValue()) {
-                bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionY);
+                bool isImportant = propertyIsImportant(CSSPropertyBackgroundPositionY);
                 result.append(getPropertyText(CSSPropertyBackgroundPositionY, value->cssText(), isImportant, numDecls++));
             }
         }
     }
 
-    String repeatValue = m_propertySet.getPropertyValue(CSSPropertyBackgroundRepeat);
+    String repeatValue = propertyValue(CSSPropertyBackgroundRepeat);
     if (!repeatValue.isNull())
-        result.append(getPropertyText(CSSPropertyBackgroundRepeat, repeatValue, m_propertySet.propertyIsImportant(CSSPropertyBackgroundRepeatX), numDecls++));
+        result.append(getPropertyText(CSSPropertyBackgroundRepeat, repeatValue, propertyIsImportant(CSSPropertyBackgroundRepeatX), numDecls++));
 }
 
 bool StylePropertySerializer::isPropertyShorthandAvailable(const StylePropertyShorthand& shorthand) const
 {
     ASSERT(shorthand.length() > 0);
 
-    bool isImportant = m_propertySet.propertyIsImportant(shorthand.properties()[0]);
+    bool isImportant = propertyIsImportant(shorthand.properties()[0]);
     for (unsigned i = 0; i < shorthand.length(); ++i) {
-        RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
+        RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(shorthand.properties()[i]);
         if (!value || (value->isInitialValue() && !value->isImplicitInitialValue()) || value->isInheritedValue())
             return false;
-        if (isImportant != m_propertySet.propertyIsImportant(shorthand.properties()[i]))
+        if (isImportant != propertyIsImportant(shorthand.properties()[i]))
             return false;
     }
     return true;
 }
 
 bool StylePropertySerializer::shorthandHasOnlyInitialOrInheritedValue(const StylePropertyShorthand& shorthand) const
 {
     ASSERT(shorthand.length() > 0);
-    bool isImportant = m_propertySet.propertyIsImportant(shorthand.properties()[0]);
+    bool isImportant = propertyIsImportant(shorthand.properties()[0]);
     bool isInitialValue = true;
     bool isInheritedValue = true;
     for (unsigned i = 0; i < shorthand.length(); ++i) {
-        RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
+        RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(shorthand.properties()[i]);
         if (!value)
             return false;
         if (!value->isInitialValue())
             isInitialValue = false;
         if (!value->isInheritedValue())
             isInheritedValue = false;
-        if (isImportant != m_propertySet.propertyIsImportant(shorthand.properties()[i]))
+        if (isImportant != propertyIsImportant(shorthand.properties()[i]))
             return false;
     }
     return isInitialValue || isInheritedValue;
 }
 
+bool StylePropertySerializer::hasAllShorthand(String& result) const

[esprehn, 2014/06/12 00:36:44]

has*() methods shouldn't really reaturn stuff like this, and returning a String
by way of a non-const ref is very strange.

Can we just return a String from this and return emptyString() when you would
have returned false?

I'd suggest calling it allShorthand() or something?

+{
+    if (!propertyCount())
+        return false;
+
+    bool firstPropertyIsImportant = propertyAt(0).isImportant();
+    bool isInitialValue = true;
+    bool isInheritedValue = true;
+    bool isUnsetValue = true;
+
+    BitArray<numCSSProperties> shorthandPropertyAppeared;
+
+    for (unsigned i = 0; i < propertyCount(); ++i) {
+        CSSPropertyInternal property = propertyAt(i);
+
+        unsigned shorthandIndex = property.id() - firstCSSProperty;
+        shorthandPropertyAppeared.set(shorthandIndex);
+
+        if (!property.value()->isInitialValue())
+            isInitialValue = false;
+        if (!property.value()->isInheritedValue())
+            isInheritedValue = false;
+        if ((CSSProperty::isInheritedProperty(property.id()) && !property.value()->isInheritedValue()) || (!CSSProperty::isInheritedProperty(property.id()) && !property.value()->isInitialValue()))
+            isUnsetValue = false;
+
+        if (firstPropertyIsImportant != property.isImportant())
+            return false;
+    }
+    if (!isInitialValue && !isInheritedValue && !isUnsetValue)
+        return false;
+
+    for (int i = firstCSSProperty; i <= lastCSSProperty; ++i) {
+        CSSPropertyID propertyId = static_cast<CSSPropertyID>(i);
+
+        if (isExpandedShorthandForAll(propertyId))
+            continue;
+        if (!CSSProperty::isAffectedByAllProperty(propertyId))
+            continue;
+
+        unsigned shorthandIndex = i - firstCSSProperty;
+        if (!shorthandPropertyAppeared.get(shorthandIndex))
+            return false;
+    }
+
+    String value;
+    if (isInitialValue)
+        value = "initial";
+    else if (isInheritedValue)
+        value = "inherit";
+    else
+        value = "unset";
+    result = getPropertyText(CSSPropertyAll, value, firstPropertyIsImportant, false);
+    return true;
 }
+
+}