[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.
@@ skipping 101 matching lines @@
         if (metadataArray()[n].m_propertyID == id) {
             // Only enabled properties should be part of the style.
             ASSERT(CSSPropertyMetadata::isEnabledProperty(propertyID));
             return n;
         }
     }
 
     return -1;
 }
 
+int ImmutableStylePropertySet::findCustomPropertyIndex(const AtomicString& propertyName) const
+{
+    // 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.
+    const uint16_t variableId = static_cast<uint16_t>(CSSPropertyVariable);
+
+    for (int n = m_arraySize - 1 ; n >= 0; --n) {
+        if (metadataArray()[n].m_propertyID == variableId
+            && toCSSCustomPropertyDeclaration(valueArray()[n])->name() == propertyName)
+            return n;
+    }
+
+    return -1;
+}
+
 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
 {
     RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(propertyID);
     if (value)
         return value->cssText();
 
     return StylePropertySerializer(*this).getPropertyValue(propertyID);
 }
 
+String StylePropertySet::getCustomPropertyValue(const AtomicString& propertyName) const
+{
+    RefPtrWillBeRawPtr<CSSValue> value = getCustomPropertyCSSValue(propertyName);
+    return value ? value->cssText() : "";
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> StylePropertySet::getPropertyCSSValue(CSSPropertyID propertyID) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex == -1)
         return nullptr;
     return propertyAt(foundPropertyIndex).value();
 }
 
+PassRefPtrWillBeRawPtr<CSSCustomPropertyDeclaration> StylePropertySet::getCustomPropertyCSSValue(const AtomicString& propertyName) const
+{
+    int foundPropertyIndex = findCustomPropertyIndex(propertyName);
+    if (foundPropertyIndex == -1)
+        return nullptr;
+    return toCSSCustomPropertyDeclaration(propertyAt(foundPropertyIndex).value());
+}
+
 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::removePropertyAtIndex(int propertyIndex, String* returnText)
+{
+    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;
+}
+
 bool MutableStylePropertySet::removeProperty(CSSPropertyID propertyID, String* returnText)
 {
     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;
-    }
+    return removePropertyAtIndex(foundPropertyIndex, returnText);
+}
 
-    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 MutableStylePropertySet::removeCustomProperty(const AtomicString& propertyName, String* returnText)
+{
+    int foundPropertyIndex = findCustomPropertyIndex(propertyName);
+    return removePropertyAtIndex(foundPropertyIndex, returnText);
 }
 
 bool StylePropertySet::propertyIsImportant(CSSPropertyID propertyID) const
 {
     int foundPropertyIndex = findPropertyIndex(propertyID);
     if (foundPropertyIndex != -1)
         return propertyAt(foundPropertyIndex).isImportant();
 
     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::customPropertyIsImportant(const AtomicString& propertyName) const
+{
+    int foundPropertyIndex = findCustomPropertyIndex(propertyName);
+    if (foundPropertyIndex != -1)
+        return propertyAt(foundPropertyIndex).isImportant();
+    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::setCustomProperty(const AtomicString& propertyName, const String& value, bool important, StyleSheetContents* contextStyleSheet)
+{
+    if (value.isEmpty())
+        return removeCustomProperty(propertyName);
+    return CSSParser::parseValueForCustomProperty(this, propertyName, 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 74 matching lines @@
             return true;
         }
         return false;
     };
 
     const CSSProperty* it = std::find_if(begin, end, compare);
 
     return (it == end) ? -1 : it - begin;
 }
 
+int MutableStylePropertySet::findCustomPropertyIndex(const AtomicString& propertyName) 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.
+    const uint16_t variableId = static_cast<uint16_t>(CSSPropertyVariable);
+
+    auto compare = [variableId, propertyName](const CSSProperty& property) -> bool {
+        if (property.metadata().m_propertyID == variableId) {
+            return toCSSCustomPropertyDeclaration(property.value())->name() == propertyName;
+        }
+        return false;
+    };
+
+    const CSSProperty* it = std::find_if(begin, end, compare);
+
+    return (it == end) ? -1 : it - begin;
+}
+

[alancutter (OOO until 2018), 2015/11/17 07:10:42]

The copy paste in this file is pretty unappealing. If instead of duplicating
StylePropertySet's interface for CSSPropertyID/AtomicString the parameter was
templated we would avoid code duplication and also avoid touching the callsites
to these methods. StylePropertySet.cpp can explicitly instantiate the
CSSPropertyID and AtomicString specialisations to avoid pushing implementations
up into StylePropertySet.h.

WDYT?

[leviw_travelin_and_unemployed, 2015/11/17 07:23:44]

If that saved us code duplication I'd agree. I'm not entirely sure I understand
your suggestion, but if you're saying you'd prefer template specialization to
function overloading in this case, I'd disagree, but I'm not dogmatic about it.

[alancutter (OOO until 2018), 2015/11/18 21:22:51]

Explicit template specialisation isn't something I've done before so I tried it
out to be sure that it avoided code duplication.
I think it turned out okay, the differences between native and custom property
handling is captured in function overloads while everything else stays the same
only templated: https://codereview.chromium.org/1455053003
leviw, timloh, WDYT?

 DEFINE_TRACE_AFTER_DISPATCH(MutableStylePropertySet)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_cssomWrapper);
     visitor->trace(m_propertyVector);
 #endif
     StylePropertySet::traceAfterDispatch(visitor);
 }
 
 unsigned StylePropertySet::averageSizeInBytes()
@@ skipping 19 matching lines @@
 {
     return adoptRefWillBeNoop(new MutableStylePropertySet(cssParserMode));
 }
 
 PassRefPtrWillBeRawPtr<MutableStylePropertySet> MutableStylePropertySet::create(const CSSProperty* properties, unsigned count)
 {
     return adoptRefWillBeNoop(new MutableStylePropertySet(properties, count));
 }
 
 } // namespace blink