Add the client for accessing Subresource Filter only list.

components/subresource_filter/content/browser/content_subresource_filter_driver_factory.cc

 // Copyright 2016 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/browser/content_subresource_filter_driver_factory.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/time/time.h"
 #include "components/subresource_filter/content/common/subresource_filter_messages.h"
@@ skipping 61 matching lines @@
          url == referrer.url;
 }
 
 ContentSubresourceFilterDriverFactory::ContentSubresourceFilterDriverFactory(
     content::WebContents* web_contents,
     std::unique_ptr<SubresourceFilterClient> client)
     : content::WebContentsObserver(web_contents),
       client_(std::move(client)),
       activation_level_(ActivationLevel::DISABLED),
       activation_decision_(ActivationDecision::UNKNOWN),
-      measure_performance_(false) {}
+      measure_performance_(false),
+      subresource_filter_only_hit_(false) {}
 
 ContentSubresourceFilterDriverFactory::
     ~ContentSubresourceFilterDriverFactory() {}
 
 void ContentSubresourceFilterDriverFactory::OnFirstSubresourceLoadDisallowed() {
   if (ShouldSuppressNotifications())
     return;
 
   client_->ToggleNotificationVisibility(activation_level_ ==
                                         ActivationLevel::ENABLED);
@@ skipping 25 matching lines @@
     OnMainResourceMatchedSafeBrowsingBlacklist(
         const GURL& url,
         const std::vector<GURL>& redirect_urls,
         safe_browsing::SBThreatType threat_type,
         safe_browsing::ThreatPatternType threat_type_metadata) {
   bool is_phishing_interstitial =
       (threat_type == safe_browsing::SB_THREAT_TYPE_URL_PHISHING);
   bool is_soc_engineering_ads_interstitial =
       threat_type_metadata ==
       safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS;
-
+  subresource_filter_only_hit_ =
+      threat_type == safe_browsing::SB_THREAT_TYPE_SUBRESOURCE_FILTER;
   if (is_phishing_interstitial) {
     if (is_soc_engineering_ads_interstitial) {
       AddActivationListMatch(url, ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL);
     }
     AddActivationListMatch(url, ActivationList::PHISHING_INTERSTITIAL);
+  } else if (subresource_filter_only_hit_) {
+    AddActivationListMatch(url, ActivationList::SUBRESOURCE_FILTER);
   }
 }
 
 void ContentSubresourceFilterDriverFactory::AddHostOfURLToWhitelistSet(
     const GURL& url) {
   if (url.has_host() && url.SchemeIsHTTPOrHTTPS())
     whitelisted_hosts_.insert(url.host());
 }
 
 ContentSubresourceFilterDriverFactory::ActivationDecision
@@ skipping 54 matching lines @@
   aggregated_document_statistics_ = DocumentLoadStatistics();
 }
 
 void ContentSubresourceFilterDriverFactory::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   if (navigation_handle->IsInMainFrame() && !navigation_handle->IsSamePage()) {
     activation_decision_ = ActivationDecision::UNKNOWN;
     ResetActivationState();
     navigation_chain_.push_back(navigation_handle->GetURL());
     client_->ToggleNotificationVisibility(false);
+    subresource_filter_only_hit_ = false;
   }
 }
 
 void ContentSubresourceFilterDriverFactory::DidRedirectNavigation(
     content::NavigationHandle* navigation_handle) {
   DCHECK(!navigation_handle->IsSamePage());
   if (navigation_handle->IsInMainFrame())
     navigation_chain_.push_back(navigation_handle->GetURL());
 }
 
@@ skipping 104 matching lines @@
 
 bool ContentSubresourceFilterDriverFactory::DidURLMatchCurrentActivationList(
     const GURL& url) const {
   auto match_types =
       activation_list_matches_.find(DistillURLToHostAndPath(url));
   return match_types != activation_list_matches_.end() &&
          match_types->second.find(GetCurrentActivationList()) !=
              match_types->second.end();
 }
 
+bool ContentSubresourceFilterDriverFactory::
+    DidURLMatchSubresourceFilterOnlyList(const GURL& url) const {

[engedy, 2017/03/02 12:00:42]

Let's try to avoid duplicating the code above, and make the signature of this:
`bool DidURLMatchActivationList(const GURL&, ActivationList)`.

Then DidURLMatchCurrentActivationList could call into this with passing
GetCurrentActivationList() as the second argument.

This would also remove the need for the lambda below.

[melandory, 2017/03/06 15:00:00]

Done.

+  auto match_types =
+      activation_list_matches_.find(DistillURLToHostAndPath(url));
+  return match_types != activation_list_matches_.end() &&
+         match_types->second.find(ActivationList::SUBRESOURCE_FILTER) !=
+             match_types->second.end();
+}
+
 void ContentSubresourceFilterDriverFactory::AddActivationListMatch(
     const GURL& url,
     ActivationList match_type) {
   if (url.has_host() && url.SchemeIsHTTPOrHTTPS())
     activation_list_matches_[DistillURLToHostAndPath(url)].insert(match_type);
 }
 
 void ContentSubresourceFilterDriverFactory::RecordRedirectChainMatchPattern()

[engedy, 2017/03/02 12:00:43]

What do you think of recording two histograms here entirely independently of
each other, and independently of the current activation list:

SubresourceFilter.PageLoad.*.SocialEngineeringAdsInterstitial
SubresourceFilter.PageLoad.*.SubresourceFilter[Only]

[melandory, 2017/03/06 15:00:00]

I like the idea. A bit of refactoring will be involved, I think it's better to
do separately, I've started WIP cL: https://codereview.chromium.org/2733833002

     const {
   int hits_pattern = 0;
   const int kInitialURLHitMask = 0x4;
   const int kRedirectURLHitMask = 0x2;
   const int kFinalURLHitMask = 0x1;
+  auto in_list = [this](const GURL& url) {
+    return subresource_filter_only_hit_
+               ? DidURLMatchSubresourceFilterOnlyList(url)
+               : DidURLMatchCurrentActivationList(url);
+  };
   if (navigation_chain_.size() > 1) {
-    if (DidURLMatchCurrentActivationList(navigation_chain_.back()))
+    if (in_list(navigation_chain_.back()))
       hits_pattern |= kFinalURLHitMask;
-    if (DidURLMatchCurrentActivationList(navigation_chain_.front()))
+    if (in_list(navigation_chain_.front()))
       hits_pattern |= kInitialURLHitMask;
 
     // Examine redirects.
     for (size_t i = 1; i < navigation_chain_.size() - 1; ++i) {
-      if (DidURLMatchCurrentActivationList(navigation_chain_[i])) {
+      if (in_list(navigation_chain_[i])) {
         hits_pattern |= kRedirectURLHitMask;
         break;
       }
     }
   } else {
-    if (navigation_chain_.size() &&
-        DidURLMatchCurrentActivationList(navigation_chain_.front())) {
+    if (navigation_chain_.size() && in_list(navigation_chain_.front())) {
       hits_pattern = 0x8;  // One url hit.
     }
   }
   if (!hits_pattern)
     return;
-  UMA_HISTOGRAM_ENUMERATION(
-      "SubresourceFilter.PageLoad.RedirectChainMatchPattern", hits_pattern,
-      0x10 /* max value */);
-  UMA_HISTOGRAM_COUNTS("SubresourceFilter.PageLoad.RedirectChainLength",
-                       navigation_chain_.size());
+  if (subresource_filter_only_hit_) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "SubresourceFilter.PageLoad.RedirectChainMatchPattern."
+        "SubresourceFilterOnly",
+        hits_pattern, 0x10 /* max value */);
+    UMA_HISTOGRAM_COUNTS(
+        "SubresourceFilter.PageLoad.RedirectChainLength.SubresourceFilterOnly",
+        navigation_chain_.size());
+
+  } else {
+    UMA_HISTOGRAM_ENUMERATION(
+        "SubresourceFilter.PageLoad.RedirectChainMatchPattern", hits_pattern,
+        0x10 /* max value */);
+    UMA_HISTOGRAM_COUNTS("SubresourceFilter.PageLoad.RedirectChainLength",
+                         navigation_chain_.size());
+  }
 }
 
 }  // namespace subresource_filter