Backend for css rule tracking

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

Index: third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp
diff --git a/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp b/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp
index 32a79edb4fb79cafe687e354afbf527c0322bfa0..17cb12865ce9f1d2f7e347b773fc88446838e46d 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp
@@ -52,6 +52,7 @@
 #include "core/css/StyleSheetList.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/css/resolver/StyleResolver.h"
+#include "core/css/resolver/StyleRuleUsageTracker.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/Node.h"
 #include "core/dom/StyleChangeReason.h"
@@ -301,6 +302,7 @@ std::unique_ptr<protocol::DOM::Rect> buildRectForFloatRect(
 
 namespace CSSAgentState {
 static const char cssAgentEnabled[] = "cssAgentEnabled";
+static const char ruleRecordingEnabled[] = "ruleRecordingEnabled";
 }
 
 typedef blink::protocol::CSS::Backend::EnableCallback EnableCallback;
@@ -686,6 +688,8 @@ InspectorCSSAgent::~InspectorCSSAgent() {}
 void InspectorCSSAgent::restore() {
   if (m_state->booleanProperty(CSSAgentState::cssAgentEnabled, false))
     wasEnabled();
+  if (m_state->booleanProperty(CSSAgentState::ruleRecordingEnabled, false))
+    setUsageTrackerStatus(true);
 }
 
 void InspectorCSSAgent::flushPendingProtocolNotifications() {
@@ -748,6 +752,8 @@ void InspectorCSSAgent::disable(ErrorString*) {
   m_instrumentingAgents->removeInspectorCSSAgent(this);
   m_state->setBoolean(CSSAgentState::cssAgentEnabled, false);
   m_resourceContentLoader->cancel(m_resourceContentLoaderClientId);
+  m_state->setBoolean(CSSAgentState::ruleRecordingEnabled, false);
+  setUsageTrackerStatus(false);
 }
 
 void InspectorCSSAgent::didCommitLoadForLocalFrame(LocalFrame* frame) {
@@ -2036,6 +2042,16 @@ InspectorCSSAgent::buildObjectForAttributesStyle(Element* element) {
   return inspectorStyle->buildObjectForStyle();
 }
 
+void InspectorCSSAgent::didAddDocument(Document* document) {
+  if (!m_tracker)
+    return;
+
+  document->styleEngine().setRuleUsageTracker(m_tracker);
+  document->setNeedsStyleRecalc(
+      SubtreeStyleChange,
+      StyleChangeReasonForTracing::create(StyleChangeReason::Inspector));
+}
+
 void InspectorCSSAgent::didRemoveDocument(Document* document) {}
 
 void InspectorCSSAgent::didRemoveDOMNode(Node* node) {
@@ -2489,6 +2505,80 @@ void InspectorCSSAgent::visitLayoutTreeNodes(
   }
 }
 
+void InspectorCSSAgent::setUsageTrackerStatus(bool enabled) {
+  if (enabled) {
+    if (!m_tracker)
+      m_tracker = new StyleRuleUsageTracker();
+  } else {
+    m_tracker = nullptr;
+  }
+
+  HeapVector<Member<Document>> documents = m_domAgent->documents();
+  for (Document* document : documents) {
+    document->styleEngine().setRuleUsageTracker(m_tracker);
+
+    document->setNeedsStyleRecalc(
+        SubtreeStyleChange,
+        StyleChangeReasonForTracing::create(StyleChangeReason::Inspector));
+  }
+}
+
+void InspectorCSSAgent::startRuleUsageTracking(ErrorString* errorString) {
+  m_state->setBoolean(CSSAgentState::ruleRecordingEnabled, true);
+  setUsageTrackerStatus(true);
+}
+
+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;
+}
+
+void InspectorCSSAgent::stopRuleUsageTracking(
+    ErrorString* errorString,
+    std::unique_ptr<protocol::Array<protocol::CSS::RuleUsage>>* result) {
+  if (!m_tracker) {
+    *errorString = "CSS rule usage tracking is not enabled";
+    return;
+  }
+
+  *result = protocol::Array<protocol::CSS::RuleUsage>::create();
+
+  HeapVector<Member<Document>> documents = m_domAgent->documents();
+  for (Document* document : documents) {
+    HeapHashSet<Member<CSSStyleSheet>>* newSheetsVector =
+        m_documentToCSSStyleSheets.get(document);
+
+    if (!newSheetsVector)
+      continue;
+
+    for (auto sheet : *newSheetsVector) {
+      InspectorStyleSheet* styleSheet =
+          m_cssStyleSheetToInspectorStyleSheet.get(sheet);
+      const CSSRuleVector ruleVector = styleSheet->flatRules();
+      for (auto rule : ruleVector) {
+        if (rule->type() != CSSRule::kStyleRule)
+          continue;
+
+        CSSStyleRule* cssRule = static_cast<CSSStyleRule*>(rule.get());
+
+        StyleRule* styleRule = cssRule->styleRule();
+
+        result->get()->addItem(
+            buildObjectForRuleUsage(cssRule, m_tracker->contains(styleRule)));
+      }
+    }
+  }
+
+  setUsageTrackerStatus(false);
+}
+
 DEFINE_TRACE(InspectorCSSAgent) {
   visitor->trace(m_domAgent);
   visitor->trace(m_inspectedFrames);
@@ -2502,6 +2592,7 @@ DEFINE_TRACE(InspectorCSSAgent) {
   visitor->trace(m_invalidatedDocuments);
   visitor->trace(m_nodeToInspectorStyleSheet);
   visitor->trace(m_inspectorUserAgentStyleSheet);
+  visitor->trace(m_tracker);
   InspectorBaseAgent::trace(visitor);
 }