DevTools: add support for polling for coverage data in CSS agent

third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 672 matching lines @@
       m_resourceContainer(resourceContainer),
       m_resourceContentLoaderClientId(resourceContentLoader->createClientId()) {
 }
 
 InspectorCSSAgent::~InspectorCSSAgent() {}
 
 void InspectorCSSAgent::restore() {
   if (m_state->booleanProperty(CSSAgentState::cssAgentEnabled, false))
     wasEnabled();
   if (m_state->booleanProperty(CSSAgentState::ruleRecordingEnabled, false))
-    setUsageTrackerStatus(true);
+    setCoverageEnabled(true);
 }
 
 void InspectorCSSAgent::flushPendingProtocolNotifications() {
   if (!m_invalidatedDocuments.size())
     return;
   HeapHashSet<Member<Document>> invalidatedDocuments;
   m_invalidatedDocuments.swap(invalidatedDocuments);
   for (Document* document : invalidatedDocuments)
     updateActiveStyleSheets(document);
 }
@@ skipping 44 matching lines @@
     updateActiveStyleSheets(document);
 }
 
 Response InspectorCSSAgent::disable() {
   reset();
   m_domAgent->setDOMListener(nullptr);
   m_instrumentingAgents->removeInspectorCSSAgent(this);
   m_state->setBoolean(CSSAgentState::cssAgentEnabled, false);
   m_resourceContentLoader->cancel(m_resourceContentLoaderClientId);
   m_state->setBoolean(CSSAgentState::ruleRecordingEnabled, false);
-  setUsageTrackerStatus(false);
+  setCoverageEnabled(false);
   return Response::OK();
 }
 
 void InspectorCSSAgent::didCommitLoadForLocalFrame(LocalFrame* frame) {
   if (frame == m_inspectedFrames->root())
     reset();
 }
 
 void InspectorCSSAgent::mediaQueryResultChanged() {
   flushPendingProtocolNotifications();
@@ skipping 48 matching lines @@
     }
   }
 
   for (CSSStyleSheet* cssStyleSheet : addedSheets) {
       InspectorStyleSheet* newStyleSheet = bindStyleSheet(cssStyleSheet);
       documentCSSStyleSheets->insert(cssStyleSheet);
       if (frontend()) {
         frontend()->styleSheetAdded(
             newStyleSheet->buildObjectForStyleSheetInfo());
       }
+      if (m_tracker && m_hadFirstCoverageRequest)
+        m_coveragePendingStylsheets.push_back(newStyleSheet);
   }
 
   if (documentCSSStyleSheets->isEmpty())
     m_documentToCSSStyleSheets.remove(document);
 }
 
 void InspectorCSSAgent::documentDetached(Document* document) {
   m_invalidatedDocuments.erase(document);
   setActiveStyleSheets(document, HeapVector<Member<CSSStyleSheet>>());
 }
@@ skipping 1569 matching lines @@
                                        .build());
         }
         layoutTreeNode->setInlineTextNodes(std::move(inlineTextNodes));
       }
     }
 
     layoutTreeNodes.addItem(std::move(layoutTreeNode));
   }
 }
 
-void InspectorCSSAgent::setUsageTrackerStatus(bool enabled) {
+void InspectorCSSAgent::setCoverageEnabled(bool enabled) {
+  if (enabled == !!m_tracker)
+    return;
   if (enabled) {
-    if (!m_tracker)
-      m_tracker = new StyleRuleUsageTracker();
+    m_tracker = new StyleRuleUsageTracker();
+    m_hadFirstCoverageRequest = false;
   } else {
     m_tracker = nullptr;
+    m_coveragePendingStylsheets.clear();
+    m_unusedStyleRuleToCSSStyleRule.clear();
   }
 
-  HeapVector<Member<Document>> documents = m_domAgent->documents();
-  for (Document* document : documents) {
+  for (Document* document : m_domAgent->documents())
     document->styleEngine().setRuleUsageTracker(m_tracker);
-
-    document->setNeedsStyleRecalc(
-        SubtreeStyleChange,
-        StyleChangeReasonForTracing::create(StyleChangeReason::Inspector));
-  }
 }
 
 Response InspectorCSSAgent::startRuleUsageTracking() {
   m_state->setBoolean(CSSAgentState::ruleRecordingEnabled, true);
-  setUsageTrackerStatus(true);
+  setCoverageEnabled(true);
   return Response::OK();
 }
 
-std::unique_ptr<protocol::CSS::RuleUsage>
-InspectorCSSAgent::buildObjectForRuleUsage(CSSStyleRule* rule, bool used) {
-  InspectorStyleSheet* inspectorStyleSheet = inspectorStyleSheetForRule(rule);
-  if (!inspectorStyleSheet)
-    return nullptr;
-
-  std::unique_ptr<protocol::CSS::RuleUsage> result =
-      inspectorStyleSheet->buildObjectForRuleUsage(rule, used);
-
-  return result;
-}
-
 Response InspectorCSSAgent::stopRuleUsageTracking(
     std::unique_ptr<protocol::Array<protocol::CSS::RuleUsage>>* result) {
-  if (!m_tracker) {
-    return Response::Error("CSS rule usage tracking is not enabled");
-  }
+  Response response = takeCoverageDelta(result);
+  setCoverageEnabled(false);
+  return response;
+}
 
-  *result = protocol::Array<protocol::CSS::RuleUsage>::create();
+void InspectorCSSAgent::collectStyleSheetsForCoverage() {
+  DCHECK_EQ(0UL, m_coveragePendingStylsheets.size());
 
   HeapVector<Member<Document>> documents = m_domAgent->documents();
   for (Document* document : documents) {
-    HeapHashSet<Member<CSSStyleSheet>>* newSheetsVector =
-        m_documentToCSSStyleSheets.at(document);
+    document->setNeedsStyleRecalc(
+        SubtreeStyleChange,
+        StyleChangeReasonForTracing::create(StyleChangeReason::Inspector));
+    document->updateStyleAndLayoutTree();
+  }
+  m_coveragePendingStylsheets.appendRange(
+      m_idToInspectorStyleSheet.values().begin(),
+      m_idToInspectorStyleSheet.values().end());
+}
 
-    if (!newSheetsVector)
-      continue;
+Response InspectorCSSAgent::takeCoverageDelta(
+    std::unique_ptr<protocol::Array<protocol::CSS::RuleUsage>>* result) {
+  if (!m_tracker)
+    return Response::Error("CSS rule usage tracking is not enabled");
 
-    for (auto sheet : *newSheetsVector) {
-      InspectorStyleSheet* styleSheet =
-          m_cssStyleSheetToInspectorStyleSheet.at(sheet);
-      const CSSRuleVector ruleVector = styleSheet->flatRules();
-      for (auto rule : ruleVector) {
-        if (rule->type() != CSSRule::kStyleRule)
-          continue;
+  if (!m_hadFirstCoverageRequest) {
+    m_hadFirstCoverageRequest = true;
+    collectStyleSheetsForCoverage();
+  }
 
-        CSSStyleRule* cssRule = static_cast<CSSStyleRule*>(rule.get());
+  HeapVector<Member<StyleRule>> coverageDeltaVector = m_tracker->takeDelta();
+  HeapHashSet<Member<StyleRule>> coverageDelta;
+  for (auto item : coverageDeltaVector)
+    coverageDelta.insert(item);
 
-        StyleRule* styleRule = cssRule->styleRule();
+  *result = protocol::Array<protocol::CSS::RuleUsage>::create();
+  for (auto styleSheet : m_coveragePendingStylsheets) {
+    const CSSRuleVector& ruleVector = styleSheet->flatRules();
+    for (auto rule : ruleVector) {
+      if (rule->type() != CSSRule::kStyleRule)
+        continue;
 
-        std::unique_ptr<protocol::CSS::RuleUsage> protocolRule =
-            buildObjectForRuleUsage(cssRule, m_tracker->contains(styleRule));
-        if (!protocolRule)
-          continue;
+      StyleRule* styleRule =
+          static_cast<CSSStyleRule*>(rule.get())->styleRule();
+      bool used = !!coverageDelta.take(styleRule);

[alph, 2017/03/20 20:48:31]

contains

+      std::unique_ptr<protocol::CSS::RuleUsage> ruleUsageObject =
+          styleSheet->buildObjectForRuleUsage(rule, used);
 
-        result->get()->addItem(std::move(protocolRule));
-      }
+      if (ruleUsageObject)
+        (*result)->addItem(std::move(ruleUsageObject));
+      if (!used)
+        m_unusedStyleRuleToCSSStyleRule.set(styleRule, asCSSStyleRule(rule));
     }
   }
+  m_coveragePendingStylsheets.clear();
 
-  setUsageTrackerStatus(false);
+  for (Member<StyleRule> rule : coverageDelta) {
+    HeapHashMap<Member<const StyleRule>, Member<CSSStyleRule>>::iterator it =

[alph, 2017/03/20 20:48:31]

nit: auto it = 

+        m_unusedStyleRuleToCSSStyleRule.find(rule);
+    if (it == m_unusedStyleRuleToCSSStyleRule.end())
+      continue;
+    InspectorStyleSheet* styleSheet = inspectorStyleSheetForRule(it->value);
+    if (!styleSheet)
+      continue;
+    std::unique_ptr<protocol::CSS::RuleUsage> ruleUsageObject =
+        styleSheet->buildObjectForRuleUsage(it->value, true);
+    if (ruleUsageObject)
+      (*result)->addItem(std::move(ruleUsageObject));
+    m_unusedStyleRuleToCSSStyleRule.remove(it);
+  }
 
   return Response::OK();
 }
 
 DEFINE_TRACE(InspectorCSSAgent) {
   visitor->trace(m_domAgent);
   visitor->trace(m_inspectedFrames);
   visitor->trace(m_networkAgent);
   visitor->trace(m_resourceContentLoader);
   visitor->trace(m_resourceContainer);
   visitor->trace(m_idToInspectorStyleSheet);
   visitor->trace(m_idToInspectorStyleSheetForInlineStyle);
   visitor->trace(m_cssStyleSheetToInspectorStyleSheet);
   visitor->trace(m_documentToCSSStyleSheets);
   visitor->trace(m_invalidatedDocuments);
   visitor->trace(m_nodeToInspectorStyleSheet);
   visitor->trace(m_inspectorUserAgentStyleSheet);
   visitor->trace(m_tracker);
+  visitor->trace(m_unusedStyleRuleToCSSStyleRule);
+  visitor->trace(m_coveragePendingStylsheets);
   InspectorBaseAgent::trace(visitor);
 }
 
 }  // namespace blink