[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 {
 
 void StyleInvalidator::invalidate(Document& document)
 {
     RecursionData recursionData;
     if (Element* documentElement = document.documentElement())
         invalidate(*documentElement, recursionData);
     document.clearChildNeedsStyleInvalidation();
@@ skipping 53 matching lines @@
         return;
     }
     m_invalidationSets.append(&invalidationSet);
     m_invalidateCustomPseudo = invalidationSet.customPseudoInvalid();
 }
 
 bool StyleInvalidator::RecursionData::matchesCurrentInvalidationSets(Element& element)
 {
     ASSERT(!m_wholeSubtreeInvalid);
 
-    if (m_invalidateCustomPseudo && element.shadowPseudoId() != nullAtom)
+    if (m_invalidateCustomPseudo && element.shadowPseudoId() != nullAtom) {
+        TRACE_STYLE_INVALIDATOR_INVALIDATION(element, InvalidateCustomPseudo);
         return true;
+    }
 
     for (InvalidationSets::iterator it = m_invalidationSets.begin(); it != m_invalidationSets.end(); ++it) {
         if ((*it)->invalidatesElement(element))
             return true;
     }
 
     return false;
 }
 
 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 (InvalidationList::const_iterator it = invalidationList->begin(); it != invalidationList->end(); ++it)
                 recursionData.pushInvalidationSet(**it);
             // FIXME: It's really only necessary to clone the render style for this element, not full style recalc.
+            TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),

[pdr., 2014/09/30 02:08:49]

Can you add a newline here so it's clear the comment and trace event are
unrelated?

[kouhei (in TOK), 2014/09/30 02:22:00]

I think this comment is related. IIUC, theoretically we don't need to
setNeedsStyleRecalcStyle here, as the element might not match the current
invalidation set. This is forcing styleRecalc to disable RenderStyle sharing for
the element.

+                "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);
     } 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 {
+            TRACE_STYLE_INVALIDATOR_INVALIDATION(element, PreventStyleSharingForParent);
             element.setNeedsStyleRecalc(LocalStyleChange);
+        }
     }
 
     element.clearChildNeedsStyleInvalidation();
     element.clearNeedsStyleInvalidation();
 
     return thisElementNeedsStyleRecalc;
 }
 
 void StyleInvalidator::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_pendingInvalidationMap);
 #endif
 }
 
 } // namespace blink