Fire attributeChangedCallback on style changes for Custom Elements V1

third_party/WebKit/Source/core/css/PropertySetCSSStyleDeclaration.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 16 matching lines @@
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/parser/CSSVariableParser.h"
 #include "core/dom/Element.h"
 #include "core/dom/MutationObserverInterestGroup.h"
 #include "core/dom/MutationRecord.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/StyleEngine.h"
+#include "core/dom/custom/CustomElement.h"
+#include "core/dom/custom/CustomElementDefinition.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
 
 namespace {
 
+static CustomElementDefinition* definitionIfStyleChangedCallback(Element* element)
+{
+    if (!element || element->getCustomElementState() != CustomElementState::Custom)

[dominicc (has gone to gerrit), 2016/07/22 01:14:01]

I'm guessing if it is worth doing here, it is worth doing everywhere. Why not
make definitionForElement have an inlineable wrapper which checks
CustomElementState and does the early return.

+        return nullptr;
+    CustomElementDefinition* definition = CustomElement::definitionForElement(*element);
+    DCHECK(definition);
+    return definition->hasStyleAttributeChangedCallback() ? definition : nullptr;
+}
+
 class StyleAttributeMutationScope {
     WTF_MAKE_NONCOPYABLE(StyleAttributeMutationScope);
     STACK_ALLOCATED();
 public:
     StyleAttributeMutationScope(AbstractPropertySetCSSStyleDeclaration* decl)
     {
         ++s_scopeCount;
 
         if (s_scopeCount != 1) {
             ASSERT(s_currentDecl == decl);
             return;
         }
 
         ASSERT(!s_currentDecl);
         s_currentDecl = decl;
 
         if (!s_currentDecl->parentElement())
             return;
 
         bool shouldReadOldValue = false;
 
         m_mutationRecipients = MutationObserverInterestGroup::createForAttributesMutation(*s_currentDecl->parentElement(), HTMLNames::styleAttr);
         if (m_mutationRecipients && m_mutationRecipients->isOldValueRequested())

[dominicc (has gone to gerrit), 2016/07/22 01:14:01]

I wonder if this is clearer by simply declaring

bool shouldReadOldValue = ...mutation observer part... || ...custom element
part...;

             shouldReadOldValue = true;
+        else if (definitionIfStyleChangedCallback(s_currentDecl->parentElement()))
+            shouldReadOldValue = true;
 
-        AtomicString oldValue;
         if (shouldReadOldValue)
-            oldValue = s_currentDecl->parentElement()->getAttribute(HTMLNames::styleAttr);
+            m_oldValue = s_currentDecl->parentElement()->getAttribute(HTMLNames::styleAttr);
 
         if (m_mutationRecipients) {
-            AtomicString requestedOldValue = m_mutationRecipients->isOldValueRequested() ? oldValue : nullAtom;
+            AtomicString requestedOldValue = m_mutationRecipients->isOldValueRequested() ? m_oldValue : nullAtom;
             m_mutation = MutationRecord::createAttributes(s_currentDecl->parentElement(), HTMLNames::styleAttr, requestedOldValue);
         }
     }
 
     ~StyleAttributeMutationScope()
     {
         --s_scopeCount;
         if (s_scopeCount)
             return;
 
-        if (m_mutation && s_shouldDeliver)
-            m_mutationRecipients->enqueueMutationRecord(m_mutation);
+        if (s_shouldDeliver) {
+            if (m_mutation)
+                m_mutationRecipients->enqueueMutationRecord(m_mutation);
 
-        s_shouldDeliver = false;
+            Element* element = s_currentDecl->parentElement();
+            if (CustomElementDefinition* definition = definitionIfStyleChangedCallback(element)) {
+                definition->enqueueAttributeChangedCallback(element,
+                    HTMLNames::styleAttr, m_oldValue,
+                    element->getAttribute(HTMLNames::styleAttr));
+            }
+
+            s_shouldDeliver = false;
+        }
 
         // We have to clear internal state before calling Inspector's code.
         AbstractPropertySetCSSStyleDeclaration* localCopyStyleDecl = s_currentDecl;
         s_currentDecl = 0;
 
         if (!s_shouldNotifyInspector)
             return;
 
         s_shouldNotifyInspector = false;
         if (localCopyStyleDecl->parentElement())
@@ skipping 11 matching lines @@
     }
 
 private:
     static unsigned s_scopeCount;
     static AbstractPropertySetCSSStyleDeclaration* s_currentDecl;
     static bool s_shouldNotifyInspector;
     static bool s_shouldDeliver;
 
     Member<MutationObserverInterestGroup> m_mutationRecipients;
     Member<MutationRecord> m_mutation;
+    AtomicString m_oldValue;
 };
 
 unsigned StyleAttributeMutationScope::s_scopeCount = 0;
 AbstractPropertySetCSSStyleDeclaration* StyleAttributeMutationScope::s_currentDecl = 0;
 bool StyleAttributeMutationScope::s_shouldNotifyInspector = false;
 bool StyleAttributeMutationScope::s_shouldDeliver = false;
 
 } // namespace
 
 DEFINE_TRACE(PropertySetCSSStyleDeclaration)
@@ skipping 244 matching lines @@
     return m_parentElement ? &m_parentElement->document().elementSheet() : nullptr;
 }
 
 DEFINE_TRACE(InlineCSSStyleDeclaration)
 {
     visitor->trace(m_parentElement);
     AbstractPropertySetCSSStyleDeclaration::trace(visitor);
 }
 
 } // namespace blink