[Invalidation Tracking] Trace ScheduleStyleInvalidation

Source/core/css/RuleFeature.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 19 matching lines @@
 #include "core/css/RuleFeature.h"
 
 #include "core/HTMLNames.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSSelectorList.h"
 #include "core/css/RuleSet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/invalidation/DescendantInvalidationSet.h"
 #include "core/dom/Element.h"
 #include "core/dom/Node.h"
+#include "core/inspector/InspectorTraceEvents.h"
 #include "wtf/BitVector.h"
 
 namespace blink {
 
 #if ENABLE(ASSERT)
 
 static bool supportsInvalidation(CSSSelector::Match match)
 {
     switch (match) {
     case CSSSelector::Tag:
@@ skipping 131 matching lines @@
     case CSSSelector::PseudoHostContext:
         // :host-context matches a shadow host, yet the simple selectors inside
         // :host-context matches an ancestor of the shadow host.
         return true;
     default:
         ASSERT(supportsInvalidation(selector.pseudoType()));
         return false;
     }
 }
 
+static const unsigned char* s_tracingEnabled = nullptr;
+
+#define TRACE_SCHEDULE_STYLE_INVALIDATION_IF_ENABLED(...) \
+    if (UNLIKELY(*s_tracingEnabled)) \
+        TRACE_SCHEDULE_STYLE_INVALIDATION(__VA_ARGS__);
+
 RuleFeature::RuleFeature(StyleRule* rule, unsigned selectorIndex, bool hasDocumentSecurityOrigin)
     : rule(rule)
     , selectorIndex(selectorIndex)
     , hasDocumentSecurityOrigin(hasDocumentSecurityOrigin)
 {
+    s_tracingEnabled = TRACE_EVENT_API_GET_CATEGORY_ENABLED(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"));

[rune, 2014/10/20 07:24:03]

This looks like a strange place to initialize that variable. RuleFeatures are
typically not created after you loaded your document. If I want to do tracing
with invalidationTracking enabled, I would typically do that after I loaded the
document to check the style invalidation effect of some user interaction?

[kouhei (in TOK), 2014/10/20 09:06:20]

Thanks for your comment.

This is a bit confusing (i'll add a comment later), but this is only caching the
pointer to the flag, so the flag itself can be changed afterwards.
The location of the flag doesn't change since tracing backend is initialized, so
ideally this can be done only once per renderer process.

[rune, 2014/10/20 09:18:18]

Yes, I see that now. Still, I think it would be better if this was exported as a
fast api from the tracing code instead if possible.

 }
 
 void RuleFeature::trace(Visitor* visitor)
 {
     visitor->trace(rule);
 }
 
 // This method is somewhat conservative in what it accepts.
 RuleFeatureSet::InvalidationSetMode RuleFeatureSet::invalidationSetModeForSelector(const CSSSelector& selector)
 {
@@ skipping 385 matching lines @@
     for (unsigned i = 0; i < oldClasses.size(); ++i) {
         if (remainingClassBits.quickGet(i))
             continue;
         // Class was removed.
         addClassToInvalidationSet(oldClasses[i], element);
     }
 }
 
 void RuleFeatureSet::scheduleStyleInvalidationForAttributeChange(const QualifiedName& attributeName, Element& element)
 {
-
-    if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_attributeInvalidationSets.get(attributeName.localName()))
+    if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_attributeInvalidationSets.get(attributeName.localName())) {
+        TRACE_SCHEDULE_STYLE_INVALIDATION_IF_ENABLED(element, *invalidationSet, attributeChange, attributeName);
         m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
+    }
 }
 
 void RuleFeatureSet::scheduleStyleInvalidationForIdChange(const AtomicString& oldId, const AtomicString& newId, Element& element)
 {
     if (!oldId.isEmpty()) {
-        if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_idInvalidationSets.get(oldId))
+        if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_idInvalidationSets.get(oldId)) {
+            TRACE_SCHEDULE_STYLE_INVALIDATION_IF_ENABLED(element, *invalidationSet, idChange, oldId);
             m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
+        }
     }
     if (!newId.isEmpty()) {
-        if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_idInvalidationSets.get(newId))
+        if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_idInvalidationSets.get(newId)) {
+            TRACE_SCHEDULE_STYLE_INVALIDATION_IF_ENABLED(element, *invalidationSet, idChange, newId);
             m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
+        }
     }
 }
 
 void RuleFeatureSet::scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoType pseudo, Element& element)
 {
-    if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_pseudoInvalidationSets.get(pseudo))
+    if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_pseudoInvalidationSets.get(pseudo)) {
+        TRACE_SCHEDULE_STYLE_INVALIDATION_IF_ENABLED(element, *invalidationSet, pseudoChange, pseudo);
         m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
+    }
 }
 
 void RuleFeatureSet::addClassToInvalidationSet(const AtomicString& className, Element& element)
 {
-    if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_classInvalidationSets.get(className))
+    if (RefPtrWillBeRawPtr<DescendantInvalidationSet> invalidationSet = m_classInvalidationSets.get(className)) {
+        TRACE_SCHEDULE_STYLE_INVALIDATION_IF_ENABLED(element, *invalidationSet, classChange, className);
         m_styleInvalidator.scheduleInvalidation(invalidationSet, element);
+    }
 }
 
 StyleInvalidator& RuleFeatureSet::styleInvalidator()
 {
     return m_styleInvalidator;
 }
 
 void RuleFeatureSet::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(siblingRules);
     visitor->trace(uncommonAttributeRules);
     visitor->trace(m_classInvalidationSets);
     visitor->trace(m_attributeInvalidationSets);
     visitor->trace(m_idInvalidationSets);
     visitor->trace(m_pseudoInvalidationSets);
     visitor->trace(m_styleInvalidator);
 #endif
 }
 
 } // namespace blink