[Variables] Enable get/setProperty and similar APIs from the CSSOM

third_party/WebKit/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.
  * 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/StylePropertySet.h"
 
 #include "core/StylePropertyShorthand.h"
+#include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/StylePropertySerializer.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/frame/UseCounter.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "wtf/text/StringBuilder.h"
 
 #ifndef NDEBUG
@@ skipping 59 matching lines @@
 #if !ENABLE(OILPAN)
     RawPtrWillBeMember<CSSValue>* valueArray = const_cast<RawPtrWillBeMember<CSSValue>*>(this->valueArray());
     for (unsigned i = 0; i < m_arraySize; ++i) {
         // Checking for nullptr here is a workaround to prevent crashing.  http://crbug.com/449032
         if (valueArray[i])
             valueArray[i]->deref();
     }
 #endif
 }
 
-int ImmutableStylePropertySet::findPropertyIndex(CSSPropertyID propertyID) const
+// Convert property into an uint16_t for comparison with metadata's m_propertyID to avoid
+// the compiler converting it to an int multiple times in a loop.
+static uint16_t getConvertedCSSPropertyID(CSSPropertyID propertyID)
 {
-    // Convert here propertyID into an uint16_t to compare it with the metadata's m_propertyID to avoid
-    // the compiler converting it to an int multiple times in the loop.
-    uint16_t id = static_cast<uint16_t>(propertyID);
+    return static_cast<uint16_t>(propertyID);
+}
+
+static uint16_t getConvertedCSSPropertyID(const AtomicString&)
+{
+    return static_cast<uint16_t>(CSSPropertyVariable);
+}
+
+static bool isPropertyMatch(const StylePropertyMetadata& metadata, const CSSValue&, uint16_t id, CSSPropertyID propertyID)
+{
+    ASSERT(id == propertyID);
+    bool result = metadata.m_propertyID == id;
+    // Only enabled properties should be part of the style.
+    ASSERT(!result || CSSPropertyMetadata::isEnabledProperty(propertyID));
+    return result;
+}
+
+static bool isPropertyMatch(const StylePropertyMetadata& metadata, const CSSValue& value, uint16_t id, const AtomicString& customPropertyName)
+{
+    ASSERT(id == CSSPropertyVariable);
+    return metadata.m_propertyID == id
+        && toCSSCustomPropertyDeclaration(value).name() == customPropertyName;
+}
+
+template<typename T>
+int ImmutableStylePropertySet::findPropertyIndex(T property) const
+{
+    uint16_t id = getConvertedCSSPropertyID(property);
     for (int n = m_arraySize - 1 ; n >= 0; --n) {
-        if (metadataArray()[n].m_propertyID == id) {
-            // Only enabled properties should be part of the style.
-            ASSERT(CSSPropertyMetadata::isEnabledProperty(propertyID));
+        if (isPropertyMatch(metadataArray()[n], *valueArray()[n], id, property))
             return n;
-        }
     }
 
     return -1;
 }
+template CORE_EXPORT int ImmutableStylePropertySet::findPropertyIndex(CSSPropertyID) const;
+template CORE_EXPORT int ImmutableStylePropertySet::findPropertyIndex(AtomicString) const;
 
 DEFINE_TRACE_AFTER_DISPATCH(ImmutableStylePropertySet)
 {
     const RawPtrWillBeMember<CSSValue>* values = valueArray();
     for (unsigned i = 0; i < m_arraySize; i++)
         visitor->trace(values[i]);
     StylePropertySet::traceAfterDispatch(visitor);
 }
 
 MutableStylePropertySet::MutableStylePropertySet(const StylePropertySet& other)
     : StylePropertySet(other.cssParserMode())
 {
     if (other.isMutable()) {
         m_propertyVector = toMutableStylePropertySet(other).m_propertyVector;
     } else {
         m_propertyVector.reserveInitialCapacity(other.propertyCount());
         for (unsigned i = 0; i < other.propertyCount(); ++i)
             m_propertyVector.uncheckedAppend(other.propertyAt(i).toCSSProperty());
     }
 }
 
-String StylePropertySet::getPropertyValue(CSSPropertyID propertyID) const
+static String serializeShorthand(const StylePropertySet& propertySet, CSSPropertyID propertyID)
 {
-    RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(propertyID);
+    return StylePropertySerializer(propertySet).getPropertyValue(propertyID);
+}
+
+static String serializeShorthand(const StylePropertySet&, const AtomicString& customPropertyName)
+{
+    // Custom properties are never shorthands.
+    return "";
+}
+
+template<typename T>
+String StylePropertySet::getPropertyValue(T property) const
+{
+    RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(property);
     if (value)
         return value->cssText();
+    return serializeShorthand(*this, property);
+}
+template CORE_EXPORT String StylePropertySet::getPropertyValue<CSSPropertyID>(CSSPropertyID) const;
+template CORE_EXPORT String StylePropertySet::getPropertyValue<AtomicString>(AtomicString) const;
 
-    return StylePropertySerializer(*this).getPropertyValue(propertyID);
-}
-
-PassRefPtrWillBeRawPtr<CSSValue> StylePropertySet::getPropertyCSSValue(CSSPropertyID propertyID) const
+template<typename T>
+PassRefPtrWillBeRawPtr<CSSValue> StylePropertySet::getPropertyCSSValue(T property) const
 {
-    int foundPropertyIndex = findPropertyIndex(propertyID);
+    int foundPropertyIndex = findPropertyIndex(property);
     if (foundPropertyIndex == -1)
         return nullptr;
     return propertyAt(foundPropertyIndex).value();
 }
+template CORE_EXPORT PassRefPtrWillBeRawPtr<CSSValue> StylePropertySet::getPropertyCSSValue<CSSPropertyID>(CSSPropertyID) const;
+template CORE_EXPORT PassRefPtrWillBeRawPtr<CSSValue> StylePropertySet::getPropertyCSSValue<AtomicString>(AtomicString) const;
 
 DEFINE_TRACE(StylePropertySet)
 {
     if (m_isMutable)
         toMutableStylePropertySet(this)->traceAfterDispatch(visitor);
     else
         toImmutableStylePropertySet(this)->traceAfterDispatch(visitor);
 }
 
 #if ENABLE(OILPAN)
 void StylePropertySet::finalizeGarbageCollectedObject()
 {
     if (m_isMutable)
         toMutableStylePropertySet(this)->~MutableStylePropertySet();
     else
         toImmutableStylePropertySet(this)->~ImmutableStylePropertySet();
 }
 #endif
 
 bool MutableStylePropertySet::removeShorthandProperty(CSSPropertyID propertyID)
 {
     StylePropertyShorthand shorthand = shorthandForProperty(propertyID);
     if (!shorthand.length())
         return false;
 
     return removePropertiesInSet(shorthand.properties(), shorthand.length());
 }
 
-bool MutableStylePropertySet::removeProperty(CSSPropertyID propertyID, String* returnText)
+bool MutableStylePropertySet::removePropertyAtIndex(int propertyIndex, String* returnText)
 {
-    if (removeShorthandProperty(propertyID)) {
+    if (propertyIndex == -1) {
+        if (returnText)
+            *returnText = "";
+        return false;
+    }
+
+    if (returnText)
+        *returnText = propertyAt(propertyIndex).value()->cssText();
+
+    // A more efficient removal strategy would involve marking entries as empty
+    // and sweeping them when the vector grows too big.
+    m_propertyVector.remove(propertyIndex);
+
+    return true;
+}
+
+template<typename T>
+bool MutableStylePropertySet::removeProperty(T property, String* returnText)
+{
+    if (removeShorthandProperty(property)) {
         // FIXME: Return an equivalent shorthand when possible.
         if (returnText)
             *returnText = "";
         return true;
     }
 
-    int foundPropertyIndex = findPropertyIndex(propertyID);
-    if (foundPropertyIndex == -1) {
-        if (returnText)
-            *returnText = "";
-        return false;
-    }
+    int foundPropertyIndex = findPropertyIndex(property);
+    return removePropertyAtIndex(foundPropertyIndex, returnText);
+}
+template CORE_EXPORT bool MutableStylePropertySet::removeProperty(CSSPropertyID, String*);
+template CORE_EXPORT bool MutableStylePropertySet::removeProperty(AtomicString, String*);
 
-    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.
-    m_propertyVector.remove(foundPropertyIndex);
-
-    return true;
-}
-
-bool StylePropertySet::propertyIsImportant(CSSPropertyID propertyID) const
+template<typename T>
+bool StylePropertySet::propertyIsImportant(T property) const
 {
-    int foundPropertyIndex = findPropertyIndex(propertyID);
+    int foundPropertyIndex = findPropertyIndex(property);
     if (foundPropertyIndex != -1)
         return propertyAt(foundPropertyIndex).isImportant();
+    return shorthandIsImportant(property);
+}
+template bool StylePropertySet::propertyIsImportant<CSSPropertyID>(CSSPropertyID) const;
+template bool StylePropertySet::propertyIsImportant<AtomicString>(AtomicString) const;
 
+bool StylePropertySet::shorthandIsImportant(CSSPropertyID propertyID) const
+{
     StylePropertyShorthand shorthand = shorthandForProperty(propertyID);
     if (!shorthand.length())
         return false;
 
     for (unsigned i = 0; i < shorthand.length(); ++i) {
         if (!propertyIsImportant(shorthand.properties()[i]))
             return false;
     }
     return true;
 }
 
+bool StylePropertySet::shorthandIsImportant(AtomicString customPropertyName) const
+{
+    // Custom properties are never shorthands.
+    return false;
+}
+
 CSSPropertyID StylePropertySet::getPropertyShorthand(CSSPropertyID propertyID) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return CSSPropertyInvalid;
     return propertyAt(foundPropertyIndex).shorthandID();
 }
 
 bool StylePropertySet::isPropertyImplicit(CSSPropertyID propertyID) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return false;
     return propertyAt(foundPropertyIndex).isImplicit();
 }
 
 bool MutableStylePropertySet::setProperty(CSSPropertyID unresolvedProperty, const String& value, bool important, StyleSheetContents* contextStyleSheet)
 {
     // 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(resolveCSSPropertyID(unresolvedProperty));
 
     // 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, unresolvedProperty, value, important, contextStyleSheet);
 }
 
+bool MutableStylePropertySet::setProperty(const AtomicString& customPropertyName, const String& value, bool important, StyleSheetContents* contextStyleSheet)
+{
+    if (value.isEmpty())
+        return removeProperty(customPropertyName);
+    return CSSParser::parseValueForCustomProperty(this, customPropertyName, value, important, contextStyleSheet);
+}
+
 void MutableStylePropertySet::setProperty(CSSPropertyID propertyID, PassRefPtrWillBeRawPtr<CSSValue> prpValue, bool important)
 {
     StylePropertyShorthand shorthand = shorthandForProperty(propertyID);
     if (!shorthand.length()) {
         setProperty(CSSProperty(propertyID, prpValue, important));
         return;
     }
 
     removePropertiesInSet(shorthand.properties(), shorthand.length());
 
@@ skipping 56 matching lines @@
 String StylePropertySet::asText() const
 {
     return StylePropertySerializer(*this).asText();
 }
 
 void MutableStylePropertySet::mergeAndOverrideOnConflict(const StylePropertySet* other)
 {
     unsigned size = other->propertyCount();
     for (unsigned n = 0; n < size; ++n) {
         PropertyReference toMerge = other->propertyAt(n);
+        // TODO(leviw): This probably doesn't work correctly with Custom Properties
         CSSProperty* old = findCSSPropertyWithID(toMerge.id());
         if (old)
             setProperty(toMerge.toCSSProperty(), old);
         else
             m_propertyVector.append(toMerge.toCSSProperty());
     }
 }
 
 bool StylePropertySet::hasFailedOrCanceledSubresources() const
 {
@@ skipping 36 matching lines @@
     }
     if (newIndex != oldSize) {
         m_propertyVector.shrink(newIndex);
         return true;
     }
     return false;
 }
 
 CSSProperty* MutableStylePropertySet::findCSSPropertyWithID(CSSPropertyID propertyID)
 {
+    // TODO(leviw): Calling this with a custom property should probably assert, or this
+    // method should alternatively take a string used for custom properties and check it
+    // in that case.
+    if (propertyID == CSSPropertyVariable)
+        return nullptr;
+
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return nullptr;
     return &m_propertyVector.at(foundPropertyIndex);
 }
 
 bool StylePropertySet::propertyMatches(CSSPropertyID propertyID, const CSSValue* propertyValue) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
@@ skipping 52 matching lines @@
     // style property set.
     if (m_cssomWrapper) {
         ASSERT(!static_cast<CSSStyleDeclaration*>(m_cssomWrapper.get())->parentRule());
         ASSERT(!m_cssomWrapper->parentElement());
         return m_cssomWrapper.get();
     }
     m_cssomWrapper = adoptPtrWillBeNoop(new PropertySetCSSStyleDeclaration(*this));
     return m_cssomWrapper.get();
 }
 
-int MutableStylePropertySet::findPropertyIndex(CSSPropertyID propertyID) const
+template<typename T>
+int MutableStylePropertySet::findPropertyIndex(T property) const
 {
     const CSSProperty* begin = m_propertyVector.data();
     const CSSProperty* end = begin + m_propertyVector.size();
-    // Convert here propertyID into an uint16_t to compare it with the metadata's m_propertyID to avoid
-    // the compiler converting it to an int multiple times in the loop.
-    uint16_t id = static_cast<uint16_t>(propertyID);
 
-    auto compare = [propertyID, id](const CSSProperty& property) -> bool {
-        if (property.metadata().m_propertyID == id) {
-            // Only enabled properties should be part of the style.
-            ASSERT(CSSPropertyMetadata::isEnabledProperty(propertyID));
-            return true;
-        }
-        return false;
-    };
+    uint16_t id = getConvertedCSSPropertyID(property);
 
-    const CSSProperty* it = std::find_if(begin, end, compare);
+    const CSSProperty* it = std::find_if(begin, end, [property, id](const CSSProperty& cssProperty) -> bool {
+        return isPropertyMatch(cssProperty.metadata(), *cssProperty.value(), id, property);
+    });
 
     return (it == end) ? -1 : it - begin;
 }
+template CORE_EXPORT int MutableStylePropertySet::findPropertyIndex(CSSPropertyID) const;
+template CORE_EXPORT int MutableStylePropertySet::findPropertyIndex(AtomicString) const;
 
 DEFINE_TRACE_AFTER_DISPATCH(MutableStylePropertySet)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_cssomWrapper);
     visitor->trace(m_propertyVector);
 #endif
     StylePropertySet::traceAfterDispatch(visitor);
 }
 
@@ skipping 20 matching lines @@
 {
     return adoptRefWillBeNoop(new MutableStylePropertySet(cssParserMode));
 }
 
 PassRefPtrWillBeRawPtr<MutableStylePropertySet> MutableStylePropertySet::create(const CSSProperty* properties, unsigned count)
 {
     return adoptRefWillBeNoop(new MutableStylePropertySet(properties, count));
 }
 
 } // namespace blink