Add the client for accessing Subresource Filter only list.

components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.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 "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/test/histogram_tester.h"
 #include "components/safe_browsing_db/util.h"
 #include "components/subresource_filter/content/browser/content_subresource_filter_driver.h"
@@ skipping 10 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace subresource_filter {
 
 namespace {
 
 const char kExampleUrlWithParams[] = "https://example.com/soceng?q=engsoc";
 const char kExampleUrl[] = "https://example.com";
 const char kExampleLoginUrl[] = "https://example.com/login";
-const char kMatchesPatternHistogramName[] =
-    "SubresourceFilter.PageLoad.RedirectChainMatchPattern";
-const char kNavigationChainSize[] =
-    "SubresourceFilter.PageLoad.RedirectChainLength";
 const char kUrlA[] = "https://example_a.com";
 const char kUrlB[] = "https://example_b.com";
 const char kUrlC[] = "https://example_c.com";
 const char kUrlD[] = "https://example_d.com";
 
+const char kMatchesPatternHistogramName[] =
+    "SubresourceFilter.PageLoad.RedirectChainMatchPattern";
+const char kNavigationChainSize[] =
+    "SubresourceFilter.PageLoad.RedirectChainLength";
+const char kSubresourceFilterOnlySuffix[] = ".SubresourceFilterOnly";
+
 // Human readable representation of expected redirect chain match patterns.
 // The explanations for the buckets given for the following redirect chain:
 // A->B->C->D, where A is initial URL and D is a final URL.
 enum RedirectChainMatchPattern {
   EMPTY,             // No histograms were recorded.
   F0M0L1,            // D is a Safe Browsing match.
   F0M1L0,            // B or C, or both are Safe Browsing matches.
   F0M1L1,            // B or C, or both and D are Safe Browsing matches.
   F1M0L0,            // A is Safe Browsing match
   F1M0L1,            // A and D are Safe Browsing matches.
@@ skipping 155 matching lines @@
 
   MockSubresourceFilterDriver* subframe_driver() { return subframe_driver_; }
   content::RenderFrameHost* subframe_rfh() { return subframe_rfh_; }
 
   void BlacklistURLWithRedirectsNavigateAndCommit(
       const std::vector<bool>& blacklisted_urls,
       const std::vector<GURL>& navigation_chain,
       safe_browsing::SBThreatType threat_type,
       safe_browsing::ThreatPatternType threat_type_metadata,
       RedirectChainMatchPattern expected_pattern,
+      const std::string histogram_suffix,
       bool expected_activation) {
     base::HistogramTester tester;
     EXPECT_CALL(*client(), ToggleNotificationVisibility(false)).Times(1);
     content::RenderFrameHostTester* rfh_tester =
         content::RenderFrameHostTester::For(main_rfh());
 
     rfh_tester->SimulateNavigationStart(navigation_chain.front());
     if (blacklisted_urls.front()) {
       factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
           navigation_chain.front(), navigation_chain, threat_type,
@@ skipping 15 matching lines @@
         .Times(expected_activation);
     if (!content::IsBrowserSideNavigationEnabled()) {
       factory()->ReadyToCommitNavigationInternal(main_rfh(),
                                                  navigation_chain.back());
     }
 
     rfh_tester->SimulateNavigationCommit(navigation_chain.back());
     ::testing::Mock::VerifyAndClearExpectations(driver());
 
     if (expected_pattern != EMPTY) {
-      EXPECT_THAT(tester.GetAllSamples(kMatchesPatternHistogramName),
-                  ::testing::ElementsAre(base::Bucket(expected_pattern, 1)));
       EXPECT_THAT(
-          tester.GetAllSamples(kNavigationChainSize),
+          tester.GetAllSamples(kMatchesPatternHistogramName + histogram_suffix),
+          ::testing::ElementsAre(base::Bucket(expected_pattern, 1)));
+      EXPECT_THAT(
+          tester.GetAllSamples(kNavigationChainSize + histogram_suffix),
           ::testing::ElementsAre(base::Bucket(navigation_chain.size(), 1)));
 
     } else {
-      EXPECT_THAT(tester.GetAllSamples(kMatchesPatternHistogramName),
-                  ::testing::IsEmpty());
-      EXPECT_THAT(tester.GetAllSamples(kNavigationChainSize),
+      EXPECT_THAT(
+          tester.GetAllSamples(kMatchesPatternHistogramName + histogram_suffix),
+          ::testing::IsEmpty());
+      EXPECT_THAT(tester.GetAllSamples(kNavigationChainSize + histogram_suffix),
                   ::testing::IsEmpty());
     }
   }
 
   void NavigateAndCommitSubframe(const GURL& url, bool expected_activation) {
     EXPECT_CALL(*subframe_driver(),
                 ActivateForProvisionalLoad(::testing::_, ::testing::_,
                                            expected_measure_performance()))
         .Times(expected_activation);
     EXPECT_CALL(*client(), ToggleNotificationVisibility(::testing::_)).Times(0);
 
     factory()->ReadyToCommitNavigationInternal(subframe_rfh(), url);
     ::testing::Mock::VerifyAndClearExpectations(subframe_driver());
     ::testing::Mock::VerifyAndClearExpectations(client());
   }
 
   void NavigateAndExpectActivation(
       const std::vector<bool>& blacklisted_urls,
       const std::vector<GURL>& navigation_chain,
       safe_browsing::SBThreatType threat_type,
       safe_browsing::ThreatPatternType threat_type_metadata,
       RedirectChainMatchPattern expected_pattern,
+      const std::string& histogram_suffix,
       bool expected_activation) {
     BlacklistURLWithRedirectsNavigateAndCommit(
         blacklisted_urls, navigation_chain, threat_type, threat_type_metadata,
-        expected_pattern, expected_activation);
-
+        expected_pattern, histogram_suffix, expected_activation);
     NavigateAndCommitSubframe(GURL(kExampleLoginUrl), expected_activation);
   }
 
   void NavigateAndExpectActivation(const std::vector<bool>& blacklisted_urls,
                                    const std::vector<GURL>& navigation_chain,
                                    RedirectChainMatchPattern expected_pattern,
                                    bool expected_activation) {
     NavigateAndExpectActivation(
         blacklisted_urls, navigation_chain,
         safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
         safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS,
-        expected_pattern, expected_activation);
+        expected_pattern, std::string(), expected_activation);
   }
 
   void EmulateDidDisallowFirstSubresourceMessage() {
     factory()->OnMessageReceived(
         SubresourceFilterHostMsg_DidDisallowFirstSubresource(
             main_rfh()->GetRoutingID()),
         main_rfh());
   }
 
   void EmulateInPageNavigation(const std::vector<bool>& blacklisted_urls,
@@ skipping 144 matching lines @@
     std::vector<GURL> navigation_chain;
     RedirectChainMatchPattern hit_expected_pattern;
     bool expected_activation;
   } kRedirectRedirectChainMatchPatternTestData[] = {
       {{false}, {GURL(kUrlA)}, EMPTY, false},
       {{true}, {GURL(kUrlA)}, NO_REDIRECTS_HIT, true},
       {{false, false}, {GURL(kUrlA), GURL(kUrlB)}, EMPTY, false},
       {{false, true}, {GURL(kUrlA), GURL(kUrlB)}, F0M0L1, true},
       {{true, false}, {GURL(kUrlA), GURL(kUrlB)}, F1M0L0, false},
       {{true, true}, {GURL(kUrlA), GURL(kUrlB)}, F1M0L1, true},
-
       {{false, false, false},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        EMPTY,
        false},
       {{false, false, true},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        F0M0L1,
        true},
       {{false, true, false},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
@@ skipping 25 matching lines @@
        false},
   };
 
   for (size_t i = 0U; i < arraysize(kRedirectRedirectChainMatchPatternTestData);
        ++i) {
     auto test_data = kRedirectRedirectChainMatchPatternTestData[i];
     NavigateAndExpectActivation(
         test_data.blacklisted_urls, test_data.navigation_chain,
         safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
         safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS,
-        test_data.hit_expected_pattern, test_data.expected_activation);
+        test_data.hit_expected_pattern, std::string(),
+        test_data.expected_activation);
     NavigateAndExpectActivation({false}, {GURL("https://dummy.com")}, EMPTY,
                                 false);
+    NavigateAndExpectActivation(
+        test_data.blacklisted_urls, test_data.navigation_chain,
+        safe_browsing::SB_THREAT_TYPE_SUBRESOURCE_FILTER,
+        safe_browsing::ThreatPatternType::NONE, test_data.hit_expected_pattern,
+        kSubresourceFilterOnlySuffix, false);
   }
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, NotificationVisibility) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       kActivationScopeAllSites);
 
   NavigateAndExpectActivation({false}, {GURL(kExampleUrl)}, EMPTY,
@@ skipping 46 matching lines @@
       kActivationScopeActivationList, test_data.activation_list);
 
   const GURL test_url("https://example.com/nonsoceng?q=engsocnon");
   std::vector<GURL> navigation_chain;
 
   NavigateAndExpectActivation({false, false, false, true},
                               {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC), test_url},
                               test_data.threat_type,
                               test_data.threat_type_metadata,
                               test_data.expected_activation ? F0M0L1 : EMPTY,
-                              test_data.expected_activation);
+                              std::string(), test_data.expected_activation);
 };
 
 TEST_P(ContentSubresourceFilterDriverFactoryActivationScopeTest,
        ActivateForScopeType) {
   const ActivationScopeTestData& test_data = GetParam();
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
       test_data.activation_scope,
       kActivationListSocialEngineeringAdsInterstitial);
@@ skipping 54 matching lines @@
     ActivationScopeTest,
     ContentSubresourceFilterDriverFactoryActivationScopeTest,
     ::testing::ValuesIn(kActivationScopeTestData));
 
 INSTANTIATE_TEST_CASE_P(
     ActivationLevelTest,
     ContentSubresourceFilterDriverFactoryActivationLevelTest,
     ::testing::ValuesIn(kActivationLevelTestData));
 
 }  // namespace subresource_filter