[Invalidation Tracking] Trace StyleInvalidator setNeedsStyleRecalc

Source/core/css/invalidation/StyleInvalidator.cpp

 
 // Copyright 2014 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 "config.h"
 
 #include "core/css/invalidation/StyleInvalidator.h"
 
 #include "core/css/invalidation/DescendantInvalidationSet.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
+#include "core/inspector/InspectorTraceEvents.h"
 #include "core/rendering/RenderObject.h"
 
 namespace blink {
 
+static const unsigned char* s_tracingEnabled = nullptr;
+
 void StyleInvalidator::invalidate(Document& document)
 {
     RecursionData recursionData;
     if (Element* documentElement = document.documentElement())
         invalidate(*documentElement, recursionData);
     document.clearChildNeedsStyleInvalidation();
     document.clearNeedsStyleInvalidation();
     clearPendingInvalidations();
 }
 
@@ skipping 24 matching lines @@
 {
     if (node.isElementNode() && node.needsStyleInvalidation())
         m_pendingInvalidationMap.remove(toElement(&node));
 }
 
 void StyleInvalidator::clearPendingInvalidations()
 {
     m_pendingInvalidationMap.clear();
 }
 
+void StyleInvalidator::init()
+{
+    s_tracingEnabled = TRACE_EVENT_API_GET_CATEGORY_ENABLED(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"));
+}
+
 StyleInvalidator::StyleInvalidator()
 {
 }
 
 StyleInvalidator::~StyleInvalidator()
 {
 }
 
 void StyleInvalidator::RecursionData::pushInvalidationSet(const DescendantInvalidationSet& invalidationSet)
 {
     ASSERT(!m_wholeSubtreeInvalid);
     if (invalidationSet.treeBoundaryCrossing())
         m_treeBoundaryCrossing = true;
     if (invalidationSet.wholeSubtreeInvalid()) {
         m_wholeSubtreeInvalid = true;
         return;
     }
     m_invalidationSets.append(&invalidationSet);
     m_invalidateCustomPseudo = invalidationSet.customPseudoInvalid();
 }
 
-bool StyleInvalidator::RecursionData::matchesCurrentInvalidationSets(Element& element)
+ALWAYS_INLINE bool StyleInvalidator::RecursionData::matchesCurrentInvalidationSets(Element& element)
 {
     ASSERT(!m_wholeSubtreeInvalid);
 
-    if (m_invalidateCustomPseudo && element.shadowPseudoId() != nullAtom)
+    if (m_invalidateCustomPseudo && element.shadowPseudoId() != nullAtom) {
+        if (UNLIKELY(*s_tracingEnabled))

[pdr., 2014/10/14 01:36:47]

Can you break this unlikely out into a macro using the same _IF_ENABLED pattern?

[kouhei (in TOK), 2014/10/14 02:02:10]

Done.

+            TRACE_STYLE_INVALIDATOR_INVALIDATION(element, InvalidateCustomPseudo);
         return true;
+    }
 
     for (const auto& invalidationSet : m_invalidationSets) {
         if (invalidationSet->invalidatesElement(element))
             return true;
     }
 
     return false;
 }
 
-bool StyleInvalidator::checkInvalidationSetsAgainstElement(Element& element, StyleInvalidator::RecursionData& recursionData)
+ALWAYS_INLINE bool StyleInvalidator::checkInvalidationSetsAgainstElement(Element& element, StyleInvalidator::RecursionData& recursionData)
 {
     if (element.styleChangeType() >= SubtreeStyleChange || recursionData.wholeSubtreeInvalid()) {
         recursionData.setWholeSubtreeInvalid();
         return false;
     }
     if (element.needsStyleInvalidation()) {
         if (InvalidationList* invalidationList = m_pendingInvalidationMap.get(&element)) {
             for (const auto& invalidationSet : *invalidationList)
                 recursionData.pushInvalidationSet(*invalidationSet);
             // FIXME: It's really only necessary to clone the render style for this element, not full style recalc.
+            if (UNLIKELY(*s_tracingEnabled)) {
+                TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),
+                    "StyleInvalidatorInvalidationTracking",
+                    "data", InspectorStyleInvalidatorInvalidateEvent::invalidationList(element, *invalidationList));
+            }
             return true;
         }
     }
+
     return recursionData.matchesCurrentInvalidationSets(element);
 }
 
 bool StyleInvalidator::invalidateChildren(Element& element, StyleInvalidator::RecursionData& recursionData)
 {
     bool someChildrenNeedStyleRecalc = false;
     for (ShadowRoot* root = element.youngestShadowRoot(); root; root = root->olderShadowRoot()) {
         if (!recursionData.treeBoundaryCrossing() && !root->childNeedsStyleInvalidation() && !root->needsStyleInvalidation())
             continue;
         for (Element* child = ElementTraversal::firstChild(*root); child; child = ElementTraversal::nextSibling(*child)) {
@@ skipping 17 matching lines @@
     bool thisElementNeedsStyleRecalc = checkInvalidationSetsAgainstElement(element, recursionData);
 
     bool someChildrenNeedStyleRecalc = false;
     if (recursionData.hasInvalidationSets() || element.childNeedsStyleInvalidation())
         someChildrenNeedStyleRecalc = invalidateChildren(element, recursionData);
 
     if (thisElementNeedsStyleRecalc) {
         element.setNeedsStyleRecalc(recursionData.wholeSubtreeInvalid() ? SubtreeStyleChange : LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
     } else if (recursionData.hasInvalidationSets() && someChildrenNeedStyleRecalc) {
         // Clone the RenderStyle in order to preserve correct style sharing, if possible. Otherwise recalc style.
-        if (RenderObject* renderer = element.renderer())
+        if (RenderObject* renderer = element.renderer()) {
             renderer->setStyleInternal(RenderStyle::clone(renderer->style()));
-        else
+        } else {
+            if (UNLIKELY(*s_tracingEnabled))
+                TRACE_STYLE_INVALIDATOR_INVALIDATION(element, PreventStyleSharingForParent);
             element.setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleInvalidator));
+        }
     }
 
     element.clearChildNeedsStyleInvalidation();
     element.clearNeedsStyleInvalidation();
 
     return thisElementNeedsStyleRecalc;
 }
 
 void StyleInvalidator::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_pendingInvalidationMap);
 #endif
 }
 
 } // namespace blink