Allow use of @apply and custom properties in InlineStylePropertyMap::getProperties()

third_party/WebKit/Source/core/css/cssom/InlineStylePropertyMap.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/cssom/InlineStylePropertyMap.h"
 
 #include "bindings/core/v8/Iterable.h"
 #include "core/CSSPropertyNames.h"
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
@@ skipping 32 matching lines @@
 {
     const CSSValue* cssValue = m_ownerElement->ensureMutableInlineStyle().getPropertyCSSValue(customPropertyName);
     if (!cssValue)
         return CSSStyleValueVector();
 
     return StyleValueFactory::cssValueToStyleValueVector(CSSPropertyInvalid, *cssValue);
 }
 
 Vector<String> InlineStylePropertyMap::getProperties()
 {
+    DEFINE_STATIC_LOCAL(const String, kAtApply, "@apply");
     Vector<String> result;
+    bool containsAtApply = false;
     StylePropertySet& inlineStyleSet = m_ownerElement->ensureMutableInlineStyle();
     for (unsigned i = 0; i < inlineStyleSet.propertyCount(); i++) {
         CSSPropertyID propertyID = inlineStyleSet.propertyAt(i).id();
-        result.append(getPropertyNameString(propertyID));
+        if (propertyID == CSSPropertyVariable) {
+            StylePropertySet::PropertyReference propertyReference = inlineStyleSet.propertyAt(i);
+            const CSSCustomPropertyDeclaration& customDeclaration = toCSSCustomPropertyDeclaration(propertyReference.value());
+            result.append(customDeclaration.name());
+        } else if (propertyID == CSSPropertyApplyAtRule) {
+            if (!containsAtApply) {
+                result.append(kAtApply);

[esprehn, 2016/08/10 04:01:06]

Hmm, I also wonder if we're supposed to add the name of the apply or just skip
@apply? What does the spec say? This patch is probably okay to land, but the
more I think about this having an @apply value show up in the return value of
getProperties() is very weird.

[meade_UTC10, 2016/08/10 04:22:32]

The spec doesn't say anything at all about @apply yet. I've filed
https://github.com/w3c/css-houdini-drafts/issues/276.

+                containsAtApply = true;
+            }
+        } else {
+            DCHECK(propertyID >= firstCSSProperty && propertyID <= lastUnresolvedCSSProperty);

[esprehn, 2016/08/10 04:01:06]

getPropertyNameString actually contains this assert

https://cs.chromium.org/chromium/src/out/Debug/gen/blink/core/CSSPropertyName...

[meade_UTC10, 2016/08/10 04:22:32]

Removed.

+            result.append(getPropertyNameString(propertyID));
+        }
     }
     return result;
 }
 
 void InlineStylePropertyMap::set(CSSPropertyID propertyID, CSSStyleValueOrCSSStyleValueSequenceOrString& item, ExceptionState& exceptionState)
 {
     if (item.isCSSStyleValue()) {
         const CSSValue* cssValue = styleValueToCSSValue(propertyID, *item.getAsCSSStyleValue());
         if (!cssValue) {
             exceptionState.throwTypeError("Invalid type for property");
@@ skipping 71 matching lines @@
     m_ownerElement->setInlineStyleProperty(propertyID, cssValueList);
 }
 
 void InlineStylePropertyMap::remove(CSSPropertyID propertyID, ExceptionState& exceptionState)
 {
     m_ownerElement->removeInlineStyleProperty(propertyID);
 }
 
 HeapVector<StylePropertyMap::StylePropertyMapEntry> InlineStylePropertyMap::getIterationEntries()
 {
+    DEFINE_STATIC_LOCAL(const String, kAtApply, "@apply");
     HeapVector<StylePropertyMap::StylePropertyMapEntry> result;
     StylePropertySet& inlineStyleSet = m_ownerElement->ensureMutableInlineStyle();
     for (unsigned i = 0; i < inlineStyleSet.propertyCount(); i++) {
         StylePropertySet::PropertyReference propertyReference = inlineStyleSet.propertyAt(i);
         CSSPropertyID propertyID = propertyReference.id();
         String name;
         CSSStyleValueOrCSSStyleValueSequence value;
         if (propertyID == CSSPropertyVariable) {
             const CSSCustomPropertyDeclaration& customDeclaration = toCSSCustomPropertyDeclaration(propertyReference.value());
             name = customDeclaration.name();
             // TODO(meade): Eventually custom properties will support other types, so actually return them instead of always returning a CSSUnsupportedStyleValue.
             value.setCSSStyleValue(CSSUnsupportedStyleValue::create(customDeclaration.customCSSText()));
         } else if (propertyID == CSSPropertyApplyAtRule) {
-            name = "@apply";
+            name = kAtApply;
             value.setCSSStyleValue(CSSUnsupportedStyleValue::create(toCSSCustomIdentValue(propertyReference.value()).value()));
         } else {
             name = getPropertyNameString(propertyID);
             CSSStyleValueVector styleValueVector = StyleValueFactory::cssValueToStyleValueVector(propertyID, propertyReference.value());
             if (styleValueVector.size() == 1)
                 value.setCSSStyleValue(styleValueVector[0]);
             else
                 value.setCSSStyleValueSequence(styleValueVector);
         }
         result.append(std::make_pair(name, value));
     }
     return result;
 }
 
 } // namespace blink