Add instrumentation hooks to mesaure which subresource filter rules are used.

components/subresource_filter/content/renderer/web_document_subresource_filter_impl.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/subresource_filter/content/renderer/web_document_subresource_filter_impl.h"
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "components/subresource_filter/core/common/activation_state.h"
 #include "components/subresource_filter/core/common/memory_mapped_ruleset.h"
+#include "components/subresource_filter/core/common/url_pattern.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace subresource_filter {
 
 namespace {
 
 using WebLoadPolicy = blink::WebDocumentSubresourceFilter::LoadPolicy;
@@ skipping 58 matching lines @@
     case LoadPolicy::DISALLOW:
       return WebLoadPolicy::kDisallow;
     case LoadPolicy::WOULD_DISALLOW:
       return WebLoadPolicy::kWouldDisallow;
     default:
       NOTREACHED();
       return WebLoadPolicy::kAllow;
   }
 }
 
+class LogRuleRecorder : public RuleRecorder {
+ public:
+  ~LogRuleRecorder() override {}
+  void RecordRuleUsage(const flat::UrlRule* rule) override {
+    if (!rule)
+      return;
+    std::string domains;
+    auto* domains_included = rule->domains_included();
+    auto* domains_excluded = rule->domains_excluded();
+    if (domains_included || domains_excluded) {
+      domains += " Domains:";
+      if (domains_included) {
+        domains += " +(";
+        for (const auto* domain : *domains_included) {
+          domains += domain->str();
+          domains += " ";
+        }
+        domains += ")";
+      }
+      if (domains_excluded) {
+        domains += " -(";
+        for (const auto* domain : *domains_excluded) {
+          domains += domain->str();
+          domains += " ";
+        }
+        domains += ")";
+      }
+    }
+    UrlPattern pattern(*rule);
+    LOG(ERROR) << "rule " << pattern << domains;
+  }
+};
+
 }  // namespace
 
 WebDocumentSubresourceFilterImpl::~WebDocumentSubresourceFilterImpl() = default;
 
 WebDocumentSubresourceFilterImpl::WebDocumentSubresourceFilterImpl(
     url::Origin document_origin,
     ActivationState activation_state,
     scoped_refptr<const MemoryMappedRuleset> ruleset,
     base::OnceClosure first_disallowed_load_callback)
-    : filter_(std::move(document_origin), activation_state, std::move(ruleset)),
+    : filter_(std::move(document_origin),
+              activation_state,
+              std::move(ruleset),
+              base::MakeUnique<LogRuleRecorder>()),
       first_disallowed_load_callback_(
           std::move(first_disallowed_load_callback)) {}
 
 WebLoadPolicy WebDocumentSubresourceFilterImpl::GetLoadPolicy(
     const blink::WebURL& resourceUrl,
     blink::WebURLRequest::RequestContext request_context) {
   return getLoadPolicyImpl(resourceUrl, ToElementType(request_context));
 }
 
 WebLoadPolicy
@@ skipping 19 matching lines @@
       url.ProtocolIs(url::kDataScheme)) {
     ++filter_.statistics().num_loads_total;
     return WebLoadPolicy::kAllow;
   }
 
   // TODO(pkalinnikov): Would be good to avoid converting to GURL.
   return ToWebLoadPolicy(filter_.GetLoadPolicy(GURL(url), element_type));
 }
 
 }  // namespace subresource_filter