Backend for css rule tracking

third_party/WebKit/Source/core/css/resolver/StyleResolver.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, 2013 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/)
@@ skipping 54 matching lines @@
 #include "core/css/resolver/AnimatedStyleBuilder.h"
 #include "core/css/resolver/CSSVariableResolver.h"
 #include "core/css/resolver/MatchResult.h"
 #include "core/css/resolver/MediaQueryResult.h"
 #include "core/css/resolver/ScopedStyleResolver.h"
 #include "core/css/resolver/SelectorFilterParentScope.h"
 #include "core/css/resolver/SharedStyleFinder.h"
 #include "core/css/resolver/StyleAdjuster.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/css/resolver/StyleResolverStats.h"
+#include "core/css/resolver/StyleRuleUsageTracker.h"
 #include "core/dom/CSSSelectorWatch.h"
 #include "core/dom/FirstLetterPseudoElement.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/StyleEngine.h"
 #include "core/dom/Text.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 122 matching lines @@
   const HeapVector<Member<StyleRule>>& watchedSelectors =
       watch->watchedCallbackSelectors();
   if (!watchedSelectors.size())
     return;
   m_watchedSelectorsRules = RuleSet::create();
   for (unsigned i = 0; i < watchedSelectors.size(); ++i)
     m_watchedSelectorsRules->addStyleRule(watchedSelectors[i].get(),
                                           RuleHasNoSpecialState);
 }
 
+void StyleResolver::setRuleUsageTracker(StyleRuleUsageTracker* tracker) {
+  m_tracker = tracker;
+}
+
 void StyleResolver::lazyAppendAuthorStyleSheets(
     unsigned firstNew,
     const HeapVector<Member<CSSStyleSheet>>& styleSheets) {
   unsigned size = styleSheets.size();
   for (unsigned i = firstNew; i < size; ++i)
     m_pendingStyleSheets.add(styleSheets[i].get());
 }
 
 void StyleResolver::removePendingAuthorStyleSheets(
     const HeapVector<Member<CSSStyleSheet>>& styleSheets) {
@@ skipping 612 matching lines @@
         const CSSValue* value =
             it->properties->getPropertyCSSValue(CSSPropertyDisplay);
         if (value && value->isIdentifierValue() &&
             toCSSIdentifierValue(*value).getValueID() == CSSValueBlock)
           UseCounter::count(
               element->document(),
               UseCounter::SummaryElementWithDisplayBlockAuthorRule);
       }
     }
 
+    addMatchedRulesToTracker(collector);

[pfeldman, 2016/10/31 21:03:35]

I'd pull the check into the call site:

if (m_tracker)
    trackMatchedRules(collector);

+
     if (element->computedStyle() &&
         element->computedStyle()->textAutosizingMultiplier() !=
             state.style()->textAutosizingMultiplier()) {
       // Preserve the text autosizing multiplier on style recalc. Autosizer will
       // update it during layout if needed.
       // NOTE: this must occur before applyMatchedProperties for correct
       // computation of font-relative lengths.
       state.style()->setTextAutosizingMultiplier(
           element->computedStyle()->textAutosizingMultiplier());
       state.style()->setUnique();
@@ skipping 154 matching lines @@
   if (!baseComputedStyle) {
     // Check UA, user and author rules.
     ElementRuleCollector collector(state.elementContext(), m_selectorFilter,
                                    state.style());
     collector.setPseudoStyleRequest(pseudoStyleRequest);
 
     matchUARules(collector);
     matchAuthorRules(*state.element(), collector);
     collector.finishAddingAuthorRulesForTreeScope();
 
+    addMatchedRulesToTracker(collector);
+
     if (!collector.matchedResult().hasMatchedProperties())
       return false;
 
     applyMatchedProperties(state, collector.matchedResult());
     applyCallbackSelectors(state);
 
     // Cache our original display.
     state.style()->setOriginalDisplay(state.style()->display());
 
     // FIXME: Passing 0 as the Element* introduces a lot of complexity
@@ skipping 102 matching lines @@
 }
 
 void StyleResolver::updateFont(StyleResolverState& state) {
   state.fontBuilder().createFont(document().styleEngine().fontSelector(),
                                  state.mutableStyleRef());
   state.setConversionFontSizes(CSSToLengthConversionData::FontSizes(
       state.style(), state.rootElementStyle()));
   state.setConversionZoom(state.style()->effectiveZoom());
 }
 
+void StyleResolver::addMatchedRulesToTracker(
+    const ElementRuleCollector& collector) {
+  if (!m_tracker)
+    return;
+
+  for (auto matchedRule : collector.matchedRulesList())
+    m_tracker->markRuleAsUsed(matchedRule.ruleData()->rule());
+}
+
 StyleRuleList* StyleResolver::styleRulesForElement(Element* element,
                                                    unsigned rulesToInclude) {
   ASSERT(element);
   StyleResolverState state(document(), element);
   ElementRuleCollector collector(state.elementContext(), m_selectorFilter,
                                  state.style());
   collector.setMode(SelectorChecker::CollectingStyleRules);
   collectPseudoRulesForElement(*element, collector, PseudoIdNone,
                                rulesToInclude);
   return collector.matchedStyleRuleList();
 }
 
 CSSRuleList* StyleResolver::pseudoCSSRulesForElement(Element* element,
                                                      PseudoId pseudoId,
                                                      unsigned rulesToInclude) {
   ASSERT(element);
   StyleResolverState state(document(), element);
   ElementRuleCollector collector(state.elementContext(), m_selectorFilter,
                                  state.style());
   collector.setMode(SelectorChecker::CollectingCSSRules);
   collectPseudoRulesForElement(*element, collector, pseudoId, rulesToInclude);
+
+  addMatchedRulesToTracker(collector);
   return collector.matchedCSSRuleList();
 }
 
 CSSRuleList* StyleResolver::cssRulesForElement(Element* element,
                                                unsigned rulesToInclude) {
   return pseudoCSSRulesForElement(element, PseudoIdNone, rulesToInclude);
 }
 
 void StyleResolver::collectPseudoRulesForElement(
     const Element& element,
@@ skipping 668 matching lines @@
 
   ElementRuleCollector collector(state.elementContext(), m_selectorFilter,
                                  state.style());
   collector.setMode(SelectorChecker::CollectingStyleRules);
   collector.setIncludeEmptyRules(true);
 
   MatchRequest matchRequest(m_watchedSelectorsRules.get());
   collector.collectMatchingRules(matchRequest);
   collector.sortAndTransferMatchedRules();
 
+  addMatchedRulesToTracker(collector);
+
   StyleRuleList* rules = collector.matchedStyleRuleList();
   if (!rules)
     return;
   for (size_t i = 0; i < rules->size(); i++)
     state.style()->addCallbackSelector(
         rules->at(i)->selectorList().selectorsText());
 }
 
 void StyleResolver::computeFont(ComputedStyle* style,
                                 const StylePropertySet& propertySet) {
@@ skipping 51 matching lines @@
   visitor->trace(m_viewportDependentMediaQueryResults);
   visitor->trace(m_deviceDependentMediaQueryResults);
   visitor->trace(m_selectorFilter);
   visitor->trace(m_features);
   visitor->trace(m_siblingRuleSet);
   visitor->trace(m_uncommonAttributeRuleSet);
   visitor->trace(m_watchedSelectorsRules);
   visitor->trace(m_styleSharingLists);
   visitor->trace(m_pendingStyleSheets);
   visitor->trace(m_document);
+  visitor->trace(m_tracker);
 }
 
 }  // namespace blink