Move property setting/removing/addParsedProperty/addParsedProperties functions to MutableStylePrope…

Source/core/css/StylePropertySet.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.
  *
  * 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 114 matching lines @@
 }
 
 PassRefPtr<CSSValue> StylePropertySet::getPropertyCSSValue(CSSPropertyID propertyID) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return 0;
     return propertyAt(foundPropertyIndex).value();
 }
 
-bool StylePropertySet::removeShorthandProperty(CSSPropertyID propertyID)
+bool MutableStylePropertySet::removeShorthandProperty(CSSPropertyID propertyID)
 {
-    ASSERT(isMutable());
     StylePropertyShorthand shorthand = shorthandForProperty(propertyID);
     if (!shorthand.length())
         return false;
 
     bool ret = removePropertiesInSet(shorthand.properties(), shorthand.length());
 
     CSSPropertyID prefixingVariant = prefixingVariantForPropertyId(propertyID);
     if (prefixingVariant == propertyID)
         return ret;
 
     StylePropertyShorthand shorthandPrefixingVariant = shorthandForProperty(prefixingVariant);
     return removePropertiesInSet(shorthandPrefixingVariant.properties(), shorthandPrefixingVariant.length());
 }
 
-bool StylePropertySet::removeProperty(CSSPropertyID propertyID, String* returnText)
+bool MutableStylePropertySet::removeProperty(CSSPropertyID propertyID, String* returnText)
 {
-    ASSERT(isMutable());
     if (removeShorthandProperty(propertyID)) {
         // FIXME: Return an equivalent shorthand when possible.
         if (returnText)
             *returnText = "";
         return true;
     }
 
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1) {
         if (returnText)
             *returnText = "";
         return false;
     }
 
     if (returnText)
         *returnText = propertyAt(foundPropertyIndex).value()->cssText();
 
     // A more efficient removal strategy would involve marking entries as empty
     // and sweeping them when the vector grows too big.
     mutablePropertyVector().remove(foundPropertyIndex);
 
     removePrefixedOrUnprefixedProperty(propertyID);
 
     return true;
 }
 
-void StylePropertySet::removePrefixedOrUnprefixedProperty(CSSPropertyID propertyID)
+void MutableStylePropertySet::removePrefixedOrUnprefixedProperty(CSSPropertyID propertyID)
 {
     int foundPropertyIndex = findPropertyIndex(prefixingVariantForPropertyId(propertyID));
     if (foundPropertyIndex == -1)
         return;
     mutablePropertyVector().remove(foundPropertyIndex);
 }
 
 bool StylePropertySet::propertyIsImportant(CSSPropertyID propertyID) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
@@ skipping 20 matching lines @@
 }
 
 bool StylePropertySet::isPropertyImplicit(CSSPropertyID propertyID) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return false;
     return propertyAt(foundPropertyIndex).isImplicit();
 }
 
-bool StylePropertySet::setProperty(CSSPropertyID propertyID, const String& value, bool important, StyleSheetContents* contextStyleSheet)
+bool MutableStylePropertySet::setProperty(CSSPropertyID propertyID, const String& value, bool important, StyleSheetContents* contextStyleSheet)
 {
-    ASSERT(isMutable());
     // Setting the value to an empty string just removes the property in both IE and Gecko.
     // Setting it to null seems to produce less consistent results, but we treat it just the same.
     if (value.isEmpty())
         return removeProperty(propertyID);
 
     // When replacing an existing property value, this moves the property to the end of the list.
     // Firefox preserves the position, and MSIE moves the property to the beginning.
     return CSSParser::parseValue(this, propertyID, value, important, cssParserMode(), contextStyleSheet);
 }
 
-void StylePropertySet::setProperty(CSSPropertyID propertyID, PassRefPtr<CSSValue> prpValue, bool important)
+void MutableStylePropertySet::setProperty(CSSPropertyID propertyID, PassRefPtr<CSSValue> prpValue, bool important)
 {
-    ASSERT(isMutable());
     StylePropertyShorthand shorthand = shorthandForProperty(propertyID);
     if (!shorthand.length()) {
         setProperty(CSSProperty(propertyID, prpValue, important));
         return;
     }
 
     removePropertiesInSet(shorthand.properties(), shorthand.length());
 
     RefPtr<CSSValue> value = prpValue;
     for (unsigned i = 0; i < shorthand.length(); ++i)
         mutablePropertyVector().append(CSSProperty(shorthand.properties()[i], value, important));
 }
 
-void StylePropertySet::setProperty(const CSSProperty& property, CSSProperty* slot)
+void MutableStylePropertySet::setProperty(const CSSProperty& property, CSSProperty* slot)
 {
-    ASSERT(isMutable());
     if (!removeShorthandProperty(property.id())) {
-        CSSProperty* toReplace = slot ? slot : findMutableCSSPropertyWithID(property.id());
+        CSSProperty* toReplace = slot ? slot : findCSSPropertyWithID(property.id());
         if (toReplace) {
             *toReplace = property;
             setPrefixingVariantProperty(property);
             return;
         }
     }
     appendPrefixingVariantProperty(property);
 }
 
-void StylePropertySet::appendPrefixingVariantProperty(const CSSProperty& property)
+void MutableStylePropertySet::appendPrefixingVariantProperty(const CSSProperty& property)
 {
     mutablePropertyVector().append(property);
     CSSPropertyID prefixingVariant = prefixingVariantForPropertyId(property.id());
     if (prefixingVariant == property.id())
         return;
     mutablePropertyVector().append(CSSProperty(prefixingVariant, property.value(), property.isImportant(), property.shorthandID(), property.metadata().m_implicit));
 }
 
-void StylePropertySet::setPrefixingVariantProperty(const CSSProperty& property)
+void MutableStylePropertySet::setPrefixingVariantProperty(const CSSProperty& property)
 {
     CSSPropertyID prefixingVariant = prefixingVariantForPropertyId(property.id());
-    CSSProperty* toReplace = findMutableCSSPropertyWithID(prefixingVariant);
+    CSSProperty* toReplace = findCSSPropertyWithID(prefixingVariant);
     if (toReplace)
         *toReplace = CSSProperty(prefixingVariant, property.value(), property.isImportant(), property.shorthandID(), property.metadata().m_implicit);
 }
 
-bool StylePropertySet::setProperty(CSSPropertyID propertyID, int identifier, bool important)
+bool MutableStylePropertySet::setProperty(CSSPropertyID propertyID, int identifier, bool important)
 {
-    ASSERT(isMutable());
     setProperty(CSSProperty(propertyID, cssValuePool().createIdentifierValue(identifier), important));
     return true;
 }
 
 void MutableStylePropertySet::parseDeclaration(const String& styleDeclaration, StyleSheetContents* contextStyleSheet)
 {
     mutablePropertyVector().clear();
 
     CSSParserContext context(cssParserMode());
     if (contextStyleSheet) {
         context = contextStyleSheet->parserContext();
         context.mode = cssParserMode();
     }
 
     CSSParser parser(context, UseCounter::getFrom(contextStyleSheet));
     parser.parseDeclaration(this, styleDeclaration, 0, contextStyleSheet);
 }
 
-void StylePropertySet::addParsedProperties(const Vector<CSSProperty>& properties)
+void MutableStylePropertySet::addParsedProperties(const Vector<CSSProperty>& properties)
 {
-    ASSERT(isMutable());
     mutablePropertyVector().reserveCapacity(mutablePropertyVector().size() + properties.size());
     for (unsigned i = 0; i < properties.size(); ++i)
         addParsedProperty(properties[i]);
 }
 
-void StylePropertySet::addParsedProperty(const CSSProperty& property)
+void MutableStylePropertySet::addParsedProperty(const CSSProperty& property)
 {
-    ASSERT(isMutable());
     // Only add properties that have no !important counterpart present
     if (!propertyIsImportant(property.id()) || property.isImportant())
         setProperty(property);
 }
 
 String StylePropertySet::asText() const
 {
     return StylePropertySerializer(*this).asText();
 }
 
-void StylePropertySet::mergeAndOverrideOnConflict(const StylePropertySet* other)
+void MutableStylePropertySet::mergeAndOverrideOnConflict(const StylePropertySet* other)
 {
     ASSERT(isMutable());
     unsigned size = other->propertyCount();
     for (unsigned n = 0; n < size; ++n) {
         PropertyReference toMerge = other->propertyAt(n);
-        CSSProperty* old = findMutableCSSPropertyWithID(toMerge.id());
+        CSSProperty* old = findCSSPropertyWithID(toMerge.id());
         if (old)
             setProperty(toMerge.toCSSProperty(), old);
         else
             appendPrefixingVariantProperty(toMerge.toCSSProperty());
     }
 }
 
 void StylePropertySet::addSubresourceStyleURLs(ListHashSet<KURL>& urls, StyleSheetContents* contextStyleSheet) const
 {
     unsigned size = propertyCount();
@@ skipping 46 matching lines @@
     if (properties.isEmpty())
         RuntimeCSSEnabled::filterEnabledCSSPropertiesIntoVector(staticBlockProperties, WTF_ARRAY_LENGTH(staticBlockProperties), properties);
     return properties;
 }
 
 void MutableStylePropertySet::clear()
 {
     mutablePropertyVector().clear();
 }
 
-PassRefPtr<StylePropertySet> StylePropertySet::copyBlockProperties() const
+PassRefPtr<MutableStylePropertySet> StylePropertySet::copyBlockProperties() const
 {
     return copyPropertiesInSet(blockProperties());
 }
 
-void StylePropertySet::removeBlockProperties()
+void MutableStylePropertySet::removeBlockProperties()
 {
     removePropertiesInSet(blockProperties().data(), blockProperties().size());
 }
 
-bool StylePropertySet::removePropertiesInSet(const CSSPropertyID* set, unsigned length)
+bool MutableStylePropertySet::removePropertiesInSet(const CSSPropertyID* set, unsigned length)
 {
-    ASSERT(isMutable());
     if (mutablePropertyVector().isEmpty())
         return false;
 
     // FIXME: This is always used with static sets and in that case constructing the hash repeatedly is pretty pointless.
     HashSet<CSSPropertyID> toRemove;
     for (unsigned i = 0; i < length; ++i)
         toRemove.add(set[i]);
 
     Vector<CSSProperty> newProperties;
     newProperties.reserveInitialCapacity(mutablePropertyVector().size());
@@ skipping 19 matching lines @@
     for (int n = propertyCount() - 1 ; n >= 0; --n) {
         if (propertyID == propertyAt(n).id()) {
             // Only enabled properties should be part of the style.
             ASSERT(RuntimeCSSEnabled::isCSSPropertyEnabled(propertyID));
             return n;
         }
     }
     return -1;
 }
 
-CSSProperty* StylePropertySet::findMutableCSSPropertyWithID(CSSPropertyID propertyID)
+CSSProperty* MutableStylePropertySet::findCSSPropertyWithID(CSSPropertyID propertyID)
 {
-    ASSERT(isMutable());
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return 0;
     return &mutablePropertyVector().at(foundPropertyIndex);
 }
     
 bool StylePropertySet::propertyMatches(CSSPropertyID propertyID, const CSSValue* propertyValue) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return false;
     return propertyAt(foundPropertyIndex).value()->equals(*propertyValue);
 }
     
-void StylePropertySet::removeEquivalentProperties(const StylePropertySet* style)
+void MutableStylePropertySet::removeEquivalentProperties(const StylePropertySet* style)
 {
-    ASSERT(isMutable());
     Vector<CSSPropertyID> propertiesToRemove;
     unsigned size = mutablePropertyVector().size();
     for (unsigned i = 0; i < size; ++i) {
         PropertyReference property = propertyAt(i);
         if (style->propertyMatches(property.id(), property.value()))
             propertiesToRemove.append(property.id());
     }    
     // FIXME: This should use mass removal.
     for (unsigned i = 0; i < propertiesToRemove.size(); ++i)
         removeProperty(propertiesToRemove[i]);
 }
 
-void StylePropertySet::removeEquivalentProperties(const CSSStyleDeclaration* style)
+void MutableStylePropertySet::removeEquivalentProperties(const CSSStyleDeclaration* style)
 {
-    ASSERT(isMutable());
     Vector<CSSPropertyID> propertiesToRemove;
     unsigned size = mutablePropertyVector().size();
     for (unsigned i = 0; i < size; ++i) {
         PropertyReference property = propertyAt(i);
         if (style->cssPropertyMatches(property.id(), property.value()))
             propertiesToRemove.append(property.id());
     }    
     // FIXME: This should use mass removal.
     for (unsigned i = 0; i < propertiesToRemove.size(); ++i)
         removeProperty(propertiesToRemove[i]);
@@ skipping 108 matching lines @@
     result.appendLiteral(": ");
     result.append(propertyValue()->cssText());
     if (isImportant())
         result.appendLiteral(" !important");
     result.append(';');
     return result.toString();
 }
 
 
 } // namespace WebCore