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 "components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/test/histogram_tester.h"
@@ skipping 17 matching lines @@
 namespace subresource_filter {
 
 using ActivationDecision =
     ContentSubresourceFilterDriverFactory::ActivationDecision;
 
 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 kSubframeName[] = "Child";
 
+const char kMatchesPatternHistogramName[] =
+    "SubresourceFilter.PageLoad.RedirectChainMatchPattern";
+const char kNavigationChainSize[] =
+    "SubresourceFilter.PageLoad.RedirectChainLength";
+
+#if defined(GOOGLE_CHROME_BUILD)
+const char kSubresourceFilterSuffix[] = ".SubresourceFilter";
+#endif
+
 // 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.
   F1M1L0,            // B and/or C and A are Safe Browsing matches.
   F1M1L1,            // B and/or C and A and D are Safe Browsing matches.
   NO_REDIRECTS_HIT,  // Redirect chain consists of single URL, aka no redirects
                      // has happened, and this URL was a Safe Browsing hit.
   NUM_HIT_PATTERNS,
 };
 
 std::string GetSuffixForList(const ActivationList& type) {
   switch (type) {
     case ActivationList::SOCIAL_ENG_ADS_INTERSTITIAL:
       return ".SocialEngineeringAdsInterstitial";
     case ActivationList::PHISHING_INTERSTITIAL:
       return ".PhishingInterstital";
+    case ActivationList::SUBRESOURCE_FILTER:
+      return ".SubresourceFilterOnly";
     case ActivationList::NONE:
       return std::string();
   }
   return std::string();
 }
 
 struct ActivationListTestData {
   ActivationDecision expected_activation_decision;
   const char* const activation_list;
   safe_browsing::SBThreatType threat_type;
@@ skipping 159 matching lines @@
   }
 
   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,
       const content::Referrer& referrer,
       ui::PageTransition transition,
       RedirectChainMatchPattern expected_pattern,
+      const std::string& histogram_suffix,

[engedy, 2017/03/21 13:44:16]

Note that this is not used.

[melandory, 2017/03/24 15:49:28]

Done.

       ActivationDecision expected_activation_decision) {
     const bool expected_activation =
         expected_activation_decision == ActivationDecision::ACTIVATED;
     base::HistogramTester tester;
     EXPECT_CALL(*client(), ToggleNotificationVisibility(false)).Times(1);
 
     std::unique_ptr<content::NavigationSimulator> navigation_simulator =
         content::NavigationSimulator::CreateRendererInitiated(
             navigation_chain.front(), main_rfh());
     navigation_simulator->SetReferrer(referrer);
@@ skipping 22 matching lines @@
               factory()->GetActivationDecisionForLastCommittedPageLoad());
 
     // Re-create a subframe now that the frame has navigated.
     content::RenderFrameHostTester* rfh_tester =
         content::RenderFrameHostTester::For(main_rfh());
     rfh_tester->AppendChild(kSubframeName);
     ActivationList activation_list =
         GetListForThreatTypeAndMetadata(threat_type, threat_type_metadata);
 
     const std::string suffix(GetSuffixForList(activation_list));
     if (expected_pattern != EMPTY) {

[engedy, 2017/03/21 13:44:16]

nit: If |suffix| is empty, can we make some strong assertions here such as
calling HistogramTester::GetTotalCountsForPrefix to ensure that no samples are
recorded into this histogram family? 

[melandory, 2017/03/24 15:49:27]

Done.

       EXPECT_THAT(tester.GetAllSamples(kMatchesPatternHistogramName + suffix),
                   ::testing::ElementsAre(base::Bucket(expected_pattern, 1)));
       EXPECT_THAT(
           tester.GetAllSamples(kNavigationChainSize + suffix),
           ::testing::ElementsAre(base::Bucket(navigation_chain.size(), 1)));
     } else {
       EXPECT_THAT(tester.GetAllSamples(kMatchesPatternHistogramName + suffix),
                   ::testing::IsEmpty());
       EXPECT_THAT(tester.GetAllSamples(kNavigationChainSize + suffix),
                   ::testing::IsEmpty());
@@ skipping 10 matching lines @@
   }
 
   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,
       const content::Referrer& referrer,
       ui::PageTransition transition,
       RedirectChainMatchPattern expected_pattern,
+      const std::string& histogram_suffix,
       ActivationDecision expected_activation_decision) {
     const bool expected_activation =
         expected_activation_decision == ActivationDecision::ACTIVATED;
     BlacklistURLWithRedirectsNavigateAndCommit(
         blacklisted_urls, navigation_chain, threat_type, threat_type_metadata,
-        referrer, transition, expected_pattern, expected_activation_decision);
+        referrer, transition, expected_pattern, histogram_suffix,
+        expected_activation_decision);
 
     NavigateAndCommitSubframe(GURL(kExampleLoginUrl), expected_activation);
   }
 
   void NavigateAndExpectActivation(
       const std::vector<bool>& blacklisted_urls,
       const std::vector<GURL>& navigation_chain,
       RedirectChainMatchPattern expected_pattern,
       ActivationDecision expected_activation_decision) {
     NavigateAndExpectActivation(
         blacklisted_urls, navigation_chain,
         safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
         safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS,
         content::Referrer(), ui::PAGE_TRANSITION_LINK, expected_pattern,
-        expected_activation_decision);
+        std::string(), expected_activation_decision);
   }
 
   void EmulateDidDisallowFirstSubresourceMessage() {
     factory()->OnMessageReceived(
         SubresourceFilterHostMsg_DidDisallowFirstSubresource(
             main_rfh()->GetRoutingID()),
         main_rfh());
   }
 
   void EmulateFailedNavigationAndExpectNoActivation(const GURL& url) {
@@ skipping 181 matching lines @@
        F0M0L1,
        ActivationDecision::ACTIVATED},
       {{true, false},
        {GURL(kUrlA), GURL(kUrlB)},
        F1M0L0,
        ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
       {{true, true},
        {GURL(kUrlA), GURL(kUrlB)},
        F1M0L1,
        ActivationDecision::ACTIVATED},
-
       {{false, false, false},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        EMPTY,
        ActivationDecision::ACTIVATION_LIST_NOT_MATCHED},
       {{false, false, true},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
        F0M0L1,
        ActivationDecision::ACTIVATED},
       {{false, true, false},
        {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},
@@ skipping 26 matching lines @@
   };
 
   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,
         content::Referrer(), ui::PAGE_TRANSITION_LINK,
-        test_data.hit_expected_pattern, test_data.expected_activation_decision);
+        test_data.hit_expected_pattern, std::string(),
+        test_data.expected_activation_decision);
     NavigateAndExpectActivation(
         {false}, {GURL("https://dummy.com")}, EMPTY,
         ActivationDecision::ACTIVATION_LIST_NOT_MATCHED);
+#if defined(GOOGLE_CHROME_BUILD)
+    NavigateAndExpectActivation(
+        test_data.blacklisted_urls, test_data.navigation_chain,
+        safe_browsing::SB_THREAT_TYPE_SUBRESOURCE_FILTER,
+        safe_browsing::ThreatPatternType::NONE, content::Referrer(),
+        ui::PAGE_TRANSITION_LINK, EMPTY, test_data.hit_expected_pattern,
+        kSubresourceFilterSuffix,
+        ActivationDecision::ACTIVATION_LIST_NOT_MATCHED);
+#endif
   }
 }
 
 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 41 matching lines @@
     testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
         base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationLevelEnabled,
         kActivationScopeAllSites, "" /* activation_lists */,
         "" /* performance_measurement_rate */, "" /* suppress_notifications */,
         "true" /* whitelist_site_on_reload */);
 
     NavigateAndExpectActivation(
         {false}, {GURL(kExampleUrl)},
         safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
         safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS,
-        test_case.referrer, test_case.transition, EMPTY,
+        test_case.referrer, test_case.transition, EMPTY, std::string(),
         test_case.expected_activation_decision);
     // Verify that if the first URL failed to activate, subsequent same-origin
     // navigations also fail to activate.
     NavigateAndExpectActivation({false}, {GURL(kExampleUrlWithParams)}, EMPTY,
                                 test_case.expected_activation_decision);
   }
 }
 
 TEST_P(ContentSubresourceFilterDriverFactoryActivationLevelTest,
        ActivateForFrameState) {
@@ skipping 28 matching lines @@
   const GURL test_url("https://example.com/nonsoceng?q=engsocnon");
   std::vector<GURL> navigation_chain;
 
   ActivationList effective_list = GetListForThreatTypeAndMetadata(
       test_data.threat_type, test_data.threat_type_metadata);
   NavigateAndExpectActivation(
       {false, false, false, true},
       {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC), test_url}, test_data.threat_type,
       test_data.threat_type_metadata, content::Referrer(),
       ui::PAGE_TRANSITION_LINK,
-      effective_list != ActivationList::NONE ? F0M0L1 : EMPTY,
+      effective_list != ActivationList::NONE ? F0M0L1 : EMPTY, std::string(),
       test_data.expected_activation_decision);
 };
 
 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,
@@ skipping 60 matching lines @@
     ActivationScopeTest,
     ContentSubresourceFilterDriverFactoryActivationScopeTest,
     ::testing::ValuesIn(kActivationScopeTestData));
 
 INSTANTIATE_TEST_CASE_P(
     ActivationLevelTest,
     ContentSubresourceFilterDriverFactoryActivationLevelTest,
     ::testing::ValuesIn(kActivationLevelTestData));
 
 }  // namespace subresource_filter