Partial implementation of CSSVariablesMap for CSS Variables CSSOM

Source/core/css/StylePropertySet.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 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.
  *
  * 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/StylePropertySet.h"
 
+#include "RuntimeEnabledFeatures.h"
 #include "core/css/CSSParser.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/CSSVariableValue.h"
 #include "core/css/PropertySetCSSStyleDeclaration.h"
 #include "core/css/StylePropertySerializer.h"
 #include "core/css/StylePropertyShorthand.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/page/RuntimeCSSEnabled.h"
 #include "wtf/MemoryInstrumentationVector.h"
 #include "wtf/text/StringBuilder.h"
@@ skipping 89 matching lines @@
 }
 
 PassRefPtr<CSSValue> StylePropertySet::getPropertyCSSValue(CSSPropertyID propertyID) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return 0;
     return propertyAt(foundPropertyIndex).value();
 }
 
+unsigned StylePropertySet::variableCount() const

[esprehn, 2013/07/04 02:48:52]

Why is this needed? Your getComputedStyle one looks at the size();

[alancutter (OOO until 2018), 2013/07/04 06:18:14]

In the StylePropertySet the CSS Variable properties are in the same collection
as the other CSS properties so they'll need to be counted individually. In the
computed style the variables are stored in a HashMap separate from all the other
values.

Moving the CSS Variable properties in StylePropertySet into a separate HashMap
is certainly something I will look into doing but would be better as a different
patch.

+{
+    ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());
+    unsigned count = 0;
+    for (unsigned i = 0; i < propertyCount(); ++i) {
+        if (propertyAt(i).id() == CSSPropertyVariable)
+            count++;
+    }
+    return count;
+}
+
+String StylePropertySet::variableValue(const AtomicString& name) const
+{
+    ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());
+    size_t index = findVariableIndex(name);
+    if (index == notFound)
+        return String();
+    return static_cast<CSSVariableValue*>(propertyAt(index).value())->value();
+}
+
 bool MutableStylePropertySet::removeShorthandProperty(CSSPropertyID propertyID)
 {
     StylePropertyShorthand shorthand = shorthandForProperty(propertyID);
     if (!shorthand.length())
         return false;
 
     bool ret = removePropertiesInSet(shorthand.properties(), shorthand.length());
 
     CSSPropertyID prefixingVariant = prefixingVariantForPropertyId(propertyID);
     if (prefixingVariant == propertyID)
@@ skipping 114 matching lines @@
 
 unsigned getIndexInShorthandVectorForPrefixingVariant(const CSSProperty& property, CSSPropertyID prefixingVariant)
 {
     if (!property.isSetFromShorthand())
         return 0;
 
     CSSPropertyID prefixedShorthand = prefixingVariantForPropertyId(property.shorthandID());
     return indexOfShorthandForLonghand(prefixedShorthand, matchingShorthandsForLonghand(prefixingVariant));
 }
 
+bool MutableStylePropertySet::setVariableValue(const AtomicString& name, const String& value, ExceptionCode&, bool important)
+{
+    ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());
+    if (value.isEmpty())
+        return removeVariable(name);
+
+    size_t index = findVariableIndex(name);
+    if (index != notFound) {
+        CSSValue* cssValue = m_propertyVector.at(index).value();
+        ASSERT(cssValue && cssValue->isVariableValue());
+        if (static_cast<CSSVariableValue*>(cssValue)->value() == value)
+            return false;
+    }
+
+    CSSProperty property(CSSPropertyVariable, CSSVariableValue::create(name, value), important);
+    if (index == notFound)
+        m_propertyVector.append(property);
+    else
+        m_propertyVector.at(index) = property;
+    return true;
+}
+
 void MutableStylePropertySet::appendPrefixingVariantProperty(const CSSProperty& property)
 {
     m_propertyVector.append(property);
     CSSPropertyID prefixingVariant = prefixingVariantForPropertyId(property.id());
     if (prefixingVariant == property.id())
         return;
 
     m_propertyVector.append(CSSProperty(prefixingVariant, property.value(), property.isImportant(), property.isSetFromShorthand(), getIndexInShorthandVectorForPrefixingVariant(property, prefixingVariant), property.metadata().m_implicit));
 }
 
@@ skipping 157 matching lines @@
         newProperties.append(property);
     }
 
     bool changed = newProperties.size() != m_propertyVector.size();
     m_propertyVector = newProperties;
     return changed;
 }
 
 int StylePropertySet::findPropertyIndex(CSSPropertyID propertyID) const
 {
+    // CSS variables share the same property ID, findVariableIndex() should be used for variables instead.
+    ASSERT(propertyID != CSSPropertyVariable);
     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;
 }
 
+size_t StylePropertySet::findVariableIndex(const AtomicString& name) const
+{
+    ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());
+    for (int i = propertyCount() - 1; i >= 0; --i) {
+        const PropertyReference& property = propertyAt(i);
+        if (property.id() == CSSPropertyVariable && static_cast<const CSSVariableValue*>(property.value())->name() == name)
+            return i;
+    }
+    return notFound;
+}
+
 CSSProperty* MutableStylePropertySet::findCSSPropertyWithID(CSSPropertyID propertyID)
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return 0;
     return &m_propertyVector.at(foundPropertyIndex);
 }
 
 bool StylePropertySet::propertyMatches(CSSPropertyID propertyID, const CSSValue* propertyValue) const
 {
@@ skipping 24 matching lines @@
     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]);
 }
 
+bool MutableStylePropertySet::removeVariable(const AtomicString& name)
+{
+    ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());
+    size_t index = findVariableIndex(name);
+    if (index == notFound)
+        return false;
+    m_propertyVector.remove(index);
+    return true;
+}
+
+bool MutableStylePropertySet::clearVariables()
+{
+    ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());
+    bool removed = false;
+    size_t i = 0;
+    while (i < propertyCount()) {
+        if (propertyAt(i).id() == CSSPropertyVariable) {
+            removed = true;
+            m_propertyVector.remove(i);
+        } else {
+            i++;
+        }
+    }
+    return removed;
+}
+
 PassRefPtr<MutableStylePropertySet> StylePropertySet::mutableCopy() const
 {
     return adoptRef(new MutableStylePropertySet(*this));
 }
 
 PassRefPtr<MutableStylePropertySet> StylePropertySet::copyPropertiesInSet(const Vector<CSSPropertyID>& properties) const
 {
     Vector<CSSProperty, 256> list;
     list.reserveInitialCapacity(properties.size());
     for (unsigned i = 0; i < properties.size(); ++i) {
@@ skipping 95 matching lines @@
     result.appendLiteral(": ");
     result.append(propertyValue()->cssText());
     if (isImportant())
         result.appendLiteral(" !important");
     result.append(';');
     return result.toString();
 }
 
 
 } // namespace WebCore