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 1d366dd242374e8f133a1cd2c1aaf046061144fb..ce1960466038ea99748f2aff8aae0b9680933f1e 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp
@@ -301,6 +301,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 +687,8 @@ InspectorCSSAgent::~InspectorCSSAgent() {}
 void InspectorCSSAgent::restore() {
   if (m_state->booleanProperty(CSSAgentState::cssAgentEnabled, false))
     wasEnabled();
+  if (m_state->booleanProperty(CSSAgentState::ruleRecordingEnabled, false))
+    setTrackerStatus(true);
 }
 
 void InspectorCSSAgent::flushPendingProtocolNotifications() {
@@ -748,6 +751,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);
+  setTrackerStatus(false);
 }
 
 void InspectorCSSAgent::didCommitLoadForLocalFrame(LocalFrame* frame) {
@@ -765,10 +770,48 @@ void InspectorCSSAgent::fontsUpdated() {
   frontend()->fontsUpdated();
 }
 
+void InspectorCSSAgent::getUnusedRules(

[caseq, 2016/10/31 19:06:05]

nit: consider merging into getRuleList()

+    std::unique_ptr<protocol::Array<protocol::CSS::RuleUsage>>* result) {
+  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) {
+        CSSStyleRule* cssRule = static_cast<CSSStyleRule*>(rule.get());
+
+        StyleRule* styleRule = cssRule->styleRule();
+
+        result->get()->addItem(buildObjectForRuleUsage(
+            rule.get(), m_tracker.get()->getRuleList()->contains(styleRule)));

[caseq, 2016/10/31 19:06:06]

just m_tracker->getRuleList(), remove .get()

+      }
+    }
+  }
+}
+
 void InspectorCSSAgent::activeStyleSheetsUpdated(Document* document) {
   m_invalidatedDocuments.add(document);
 }
 
+void InspectorCSSAgent::didCommitLoad(LocalFrame*, DocumentLoader* loader) {
+  if (!m_tracker)
+    return;
+
+  Document* document = loader->frame()->document();
+
+  document->styleEngine().setRuleUsageTracker(m_tracker);
+  document->setNeedsStyleRecalc(
+      SubtreeStyleChange,
+      StyleChangeReasonForTracing::create(StyleChangeReason::Inspector));
+}
+
 void InspectorCSSAgent::updateActiveStyleSheets(
     Document* document,
     StyleSheetsUpdateType styleSheetsUpdateType) {
@@ -2473,6 +2516,96 @@ void InspectorCSSAgent::visitLayoutTreeNodes(
   }
 }
 
+void InspectorCSSAgent::setTrackerStatus(bool enable) {
+  if (enable) {
+    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::setSelectorRecording(ErrorString* errorString,
+                                             bool enable) {
+  m_state->setBoolean(CSSAgentState::ruleRecordingEnabled, enable);
+  setTrackerStatus(enable);
+}
+
+std::unique_ptr<protocol::CSS::RuleUsage>
+InspectorCSSAgent::buildObjectForRuleUsage(CSSRule* rule, bool status) {
+  CSSStyleRule* cssRule = static_cast<CSSStyleRule*>(rule);
+
+  InspectorStyleSheet* inspectorStyleSheet =
+      inspectorStyleSheetForRule(cssRule);
+  if (!inspectorStyleSheet)
+    return nullptr;
+
+  String ruleType;
+  switch (rule->type()) {
+    case CSSRule::kStyleRule:
+      ruleType = "Style";
+      break;
+    case CSSRule::kCharsetRule:
+      ruleType = "Charset";
+      break;
+    case CSSRule::kImportRule:
+      ruleType = "Import";
+      break;
+    case CSSRule::kMediaRule:
+      ruleType = "Media";
+      break;
+    case CSSRule::kFontFaceRule:
+      ruleType = "FontFace";
+      break;
+    case CSSRule::kPageRule:
+      ruleType = "Page";
+      break;
+    case CSSRule::kKeyframesRule:
+      ruleType = "Keyframes";
+      break;
+    case CSSRule::kKeyframeRule:
+      ruleType = "Keyframe";
+      break;
+    case CSSRule::kNamespaceRule:
+      ruleType = "Namespace";
+      break;
+    case CSSRule::kSupportsRule:
+      ruleType = "Support";
+      break;
+    case CSSRule::kViewportRule:
+      ruleType = "Viewport";
+      break;
+  }
+
+  std::unique_ptr<protocol::CSS::RuleUsage> result =
+      inspectorStyleSheet->buildObjectForRuleUsage(rule, ruleType, status);
+  if (!result)
+    return nullptr;
+
+  return result;
+}
+
+void InspectorCSSAgent::getRuleList(
+    ErrorString* errorString,
+    std::unique_ptr<protocol::Array<protocol::CSS::RuleUsage>>* result) {
+  *result = protocol::Array<protocol::CSS::RuleUsage>::create();
+
+  if (!m_tracker) {
+    *errorString = "CSS rule usage tracking is not enabled";
+    return;
+  }
+  getUnusedRules(result);
+}
+
 DEFINE_TRACE(InspectorCSSAgent) {
   visitor->trace(m_domAgent);
   visitor->trace(m_inspectedFrames);
@@ -2486,6 +2619,7 @@ DEFINE_TRACE(InspectorCSSAgent) {
   visitor->trace(m_invalidatedDocuments);
   visitor->trace(m_nodeToInspectorStyleSheet);
   visitor->trace(m_inspectorUserAgentStyleSheet);
+  visitor->trace(m_tracker);
   InspectorBaseAgent::trace(visitor);
 }