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/browser/subresource_filter_client.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 12 matching lines @@
     return ActivationDecision::URL_WHITELISTED;
 
   switch (scope) {
     case ActivationScope::ALL_SITES:
       return ActivationDecision::ACTIVATED;
     case ActivationScope::ACTIVATION_LIST:
       // The logic to ensure only http/https URLs are activated lives in
       // AddActivationListMatch to ensure the activation list only has relevant
       // entries.
       DCHECK(url.SchemeIsHTTPOrHTTPS() ||
-             !DidURLMatchCurrentActivationList(url));
-      return DidURLMatchCurrentActivationList(url)
+             !DidURLMatchActivationList(url, GetCurrentActivationList()));
+      return DidURLMatchActivationList(url, GetCurrentActivationList())
                  ? ActivationDecision::ACTIVATED
                  : ActivationDecision::ACTIVATION_LIST_NOT_MATCHED;
     default:
       return ActivationDecision::ACTIVATION_DISABLED;
   }
 }
 
 void ContentSubresourceFilterDriverFactory::ActivateForFrameHostIfNeeded(
     content::RenderFrameHost* render_frame_host,
     const GURL& url) {
@@ skipping 21 matching lines @@
 }
 
 void ContentSubresourceFilterDriverFactory::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   if (navigation_handle->IsInMainFrame() &&
       !navigation_handle->IsSameDocument()) {
     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->IsSameDocument());
   if (navigation_handle->IsInMainFrame())
     navigation_chain_.push_back(navigation_handle->GetURL());
 }
 
@@ skipping 95 matching lines @@
     ResetActivationState();
     return;
   }
 
   activation_level_ = GetMaximumActivationLevel();
   measure_performance_ = activation_level_ != ActivationLevel::DISABLED &&
                          ShouldMeasurePerformanceForPageLoad();
   ActivateForFrameHostIfNeeded(render_frame_host, url);
 }
 
-bool ContentSubresourceFilterDriverFactory::DidURLMatchCurrentActivationList(
-    const GURL& url) const {
+bool ContentSubresourceFilterDriverFactory::DidURLMatchActivationList(
+    const GURL& url,
+    ActivationList acttivation_list) 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.find(acttivation_list) !=
              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()
-    const {
+int ContentSubresourceFilterDriverFactory::CalculateHitPatternForActivationList(
+    ActivationList activation_list) const {
   int hits_pattern = 0;
   const int kInitialURLHitMask = 0x4;
   const int kRedirectURLHitMask = 0x2;
   const int kFinalURLHitMask = 0x1;
+
   if (navigation_chain_.size() > 1) {
-    if (DidURLMatchCurrentActivationList(navigation_chain_.back()))
+    if (DidURLMatchActivationList(navigation_chain_.back(), activation_list))
       hits_pattern |= kFinalURLHitMask;
-    if (DidURLMatchCurrentActivationList(navigation_chain_.front()))
+    if (DidURLMatchActivationList(navigation_chain_.front(), activation_list))
       hits_pattern |= kInitialURLHitMask;
 
     // Examine redirects.
     for (size_t i = 1; i < navigation_chain_.size() - 1; ++i) {
-      if (DidURLMatchCurrentActivationList(navigation_chain_[i])) {
+      if (DidURLMatchActivationList(navigation_chain_[i], activation_list)) {
         hits_pattern |= kRedirectURLHitMask;
         break;
       }
     }
   } else {
     if (navigation_chain_.size() &&
-        DidURLMatchCurrentActivationList(navigation_chain_.front())) {
+        DidURLMatchActivationList(navigation_chain_.front(), activation_list)) {
       hits_pattern = 0x8;  // One url hit.
     }
   }
+  return hits_pattern;
+}
+
+void ContentSubresourceFilterDriverFactory::RecordRedirectChainMatchPattern()
+    const {
+  int hits_pattern = CalculateHitPatternForActivationList(
+      !subresource_filter_only_hit_ ? GetCurrentActivationList()
+                                    : ActivationList::SUBRESOURCE_FILTER);
   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