Allow Safe Browsing Saresource Filter to distinguish between different lists.

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 "components/safe_browsing_db/util.h"
 #include "components/subresource_filter/content/browser/content_subresource_filter_driver.h"
 #include "components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"
 #include "components/subresource_filter/core/browser/subresource_filter_client.h"
 #include "components/subresource_filter/core/browser/subresource_filter_features.h"
 #include "components/subresource_filter/core/browser/subresource_filter_features_test_support.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
 
 const char kExampleUrlWithParams[] = "https://example.com/soceng?q=engsoc";
 const char kTestUrl[] = "https://test.com";
 const char kExampleUrl[] = "https://example.com";
 
+struct ActivationListTestData {
+  bool should_add;
+  const char* const activation_list;
+  safe_browsing::SBThreatType threat_type;
+  safe_browsing::ThreatPatternType threat_type_metadata;
+};
+
+const ActivationListTestData kActivationListTestData[] = {
+    {false, "", safe_browsing::SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {false, subresource_filter::kActivationListSocialEngineeringAdsInterstitial,
+     safe_browsing::SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL,
+     safe_browsing::ThreatPatternType::NONE},
+    {false, subresource_filter::kActivationListSocialEngineeringAdsInterstitial,
+     safe_browsing::SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL,
+     safe_browsing::ThreatPatternType::MALWARE_LANDING},
+    {false, subresource_filter::kActivationListSocialEngineeringAdsInterstitial,
+     safe_browsing::SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL,
+     safe_browsing::ThreatPatternType::MALWARE_DISTRIBUTION},
+    {true, subresource_filter::kActivationListSocialEngineeringAdsInterstitial,
+     safe_browsing::SB_THREAT_TYPE_URL_MALWARE,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {false, subresource_filter::kActivationListPhishingInterstitial,
+     safe_browsing::SB_THREAT_TYPE_API_ABUSE,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {false, subresource_filter::kActivationListPhishingInterstitial,
+     safe_browsing::SB_THREAT_TYPE_BLACKLISTED_RESOURCE,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {false, subresource_filter::kActivationListPhishingInterstitial,
+     safe_browsing::SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {false, subresource_filter::kActivationListPhishingInterstitial,
+     safe_browsing::SB_THREAT_TYPE_BINARY_MALWARE_URL,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {false, subresource_filter::kActivationListPhishingInterstitial,
+     safe_browsing::SB_THREAT_TYPE_URL_UNWANTED,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {false, subresource_filter::kActivationListPhishingInterstitial,
+     safe_browsing::SB_THREAT_TYPE_URL_MALWARE,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {false, subresource_filter::kActivationListPhishingInterstitial,
+     safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {false, subresource_filter::kActivationListPhishingInterstitial,
+     safe_browsing::SB_THREAT_TYPE_SAFE,
+     safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},
+    {true, subresource_filter::kActivationListPhishingInterstitial,
+     safe_browsing::SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL,
+     safe_browsing::ThreatPatternType::NONE},
+};
+
 }  // namespace
+
 namespace subresource_filter {
 
 class MockSubresourceFilterDriver : public ContentSubresourceFilterDriver {
  public:
   explicit MockSubresourceFilterDriver(
       content::RenderFrameHost* render_frame_host)
       : ContentSubresourceFilterDriver(render_frame_host) {}
 
   ~MockSubresourceFilterDriver() override = default;
 
@@ skipping 53 matching lines @@
 
   MockSubresourceFilterClient* client() { return client_; }
   MockSubresourceFilterDriver* driver() { return driver_; }
 
   MockSubresourceFilterDriver* subframe_driver() { return subframe_driver_; }
   content::RenderFrameHost* subframe_rfh() { return subframe_rfh_; }
 
   void BlacklistURLWithRedirects(const GURL& url,
                                  const std::vector<GURL>& redirects) {
     factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
-        url, redirects,
+        url, redirects, safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
         safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS);
   }
 
   void ActivateAndExpectForFrameHostForUrl(MockSubresourceFilterDriver* driver,
                                            content::RenderFrameHost* rfh,
                                            const GURL& url,
                                            bool should_activate) {
     EXPECT_CALL(*driver, ActivateForProvisionalLoad(::testing::_))
         .Times(should_activate);
     factory()->ReadyToCommitMainFrameNavigation(rfh, url);
@@ skipping 39 matching lines @@
   MockSubresourceFilterDriver* driver_;
 
   content::RenderFrameHost* subframe_rfh_;
   MockSubresourceFilterDriver* subframe_driver_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSubresourceFilterDriverFactoryTest);
 };
 
 class ContentSubresourceFilterDriverFactoryThreatTypeTest
     : public ContentSubresourceFilterDriverFactoryTest,
-      public ::testing::WithParamInterface<safe_browsing::ThreatPatternType> {
+      public ::testing::WithParamInterface<ActivationListTestData> {
  public:
   ContentSubresourceFilterDriverFactoryThreatTypeTest() {}
   ~ContentSubresourceFilterDriverFactoryThreatTypeTest() override {}
 
+  void VerifyEntitiesNotInTheBlacklist(
+      const GURL& test_url,
+      const std::vector<GURL>& redirects,
+      const ActivationListTestData& test_data) {
+    factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
+        test_url, std::vector<GURL>(), test_data.threat_type,
+        test_data.threat_type_metadata);
+    EXPECT_EQ(test_data.should_add ? 1 : 0U,
+              factory()->activation_set().size());
+    EXPECT_EQ(test_data.should_add,
+              factory()->ShouldActivateForURL(GURL(test_url)));
+    EXPECT_EQ(test_data.should_add, factory()->ShouldActivateForURL(
+                                        GURL(test_url.GetWithEmptyPath())));
+    EXPECT_EQ(test_data.should_add,
+              factory()->ShouldActivateForURL(
+                  GURL("http://" + test_url.host() + "/path?q=q")));
+    factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
+        test_url, redirects, test_data.threat_type,
+        test_data.threat_type_metadata);
+    for (const auto& redirect : redirects) {
+      EXPECT_EQ(test_data.should_add,
+                factory()->ShouldActivateForURL(redirect));
+      EXPECT_EQ(test_data.should_add,
+                factory()->ShouldActivateForURL(redirect.GetWithEmptyPath()));
+      EXPECT_EQ(test_data.should_add, factory()->ShouldActivateForURL(
+                                          GURL("http://" + redirect.host())));
+      EXPECT_EQ(test_data.should_add,
+                factory()->ShouldActivateForURL(
+                    GURL("http://" + redirect.host() + "/path?q=q")));
+    }
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ContentSubresourceFilterDriverFactoryThreatTypeTest);
 };
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, SocEngHitEmptyRedirects) {
+  base::FieldTrialList field_trial_list(nullptr);
+  testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
+      base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
+      kActivationScopeNoSites, kActivationListSocialEngineeringAdsInterstitial);
+
   BlacklistURLWithRedirects(GURL(kExampleUrlWithParams), std::vector<GURL>());
   EXPECT_EQ(1U, factory()->activation_set().size());
 
   EXPECT_TRUE(factory()->ShouldActivateForURL(GURL(kExampleUrl)));
   EXPECT_TRUE(factory()->ShouldActivateForURL(GURL("http://example.com")));
   EXPECT_TRUE(
       factory()->ShouldActivateForURL(GURL("http://example.com/42?q=42!")));
   EXPECT_TRUE(
       factory()->ShouldActivateForURL(GURL("https://example.com/42?q=42!")));
   EXPECT_TRUE(
       factory()->ShouldActivateForURL(GURL("http://example.com/awesomepath")));
   const GURL whitelisted("http://example.com/page?q=whitelisted");
   EXPECT_TRUE(factory()->ShouldActivateForURL(whitelisted));
   factory()->AddHostOfURLToWhitelistSet(whitelisted);
   EXPECT_FALSE(factory()->ShouldActivateForURL(whitelisted));
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, SocEngHitWithRedirects) {
+  base::FieldTrialList field_trial_list(nullptr);
+  testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
+      base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
+      kActivationScopeNoSites, kActivationListSocialEngineeringAdsInterstitial);
+
   std::vector<GURL> redirects;
   redirects.push_back(GURL("https://example1.com"));
   redirects.push_back(GURL("https://example2.com"));
   redirects.push_back(GURL("https://example3.com"));
   BlacklistURLWithRedirects(GURL(kExampleUrlWithParams), redirects);
   EXPECT_EQ(4U, factory()->activation_set().size());
   EXPECT_TRUE(factory()->ShouldActivateForURL(GURL(kExampleUrl)));
 
   for (const auto& redirect : redirects) {
     EXPECT_TRUE(factory()->ShouldActivateForURL(redirect));
     EXPECT_TRUE(factory()->ShouldActivateForURL(redirect.GetWithEmptyPath()));
     EXPECT_TRUE(
         factory()->ShouldActivateForURL(GURL("http://" + redirect.host())));
     EXPECT_TRUE(factory()->ShouldActivateForURL(
         GURL("http://" + redirect.host() + "/path?q=q")));
   }
   const GURL whitelisted("http://example.com/page?q=42");
   EXPECT_TRUE(factory()->ShouldActivateForURL(whitelisted));
   factory()->AddHostOfURLToWhitelistSet(whitelisted);
   EXPECT_FALSE(factory()->ShouldActivateForURL(whitelisted));
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        ActivateForFrameHostNotNeeded) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_DISABLE_FEATURE, kActivationStateEnabled,
-      kActivationScopeNoSites);
+      kActivationScopeNoSites, kActivationListSocialEngineeringAdsInterstitial);
   ActivateAndExpectForFrameHostForUrl(driver(), main_rfh(), GURL(kTestUrl),
                                       false /* should_activate */);
   BlacklistURLWithRedirects(GURL(kExampleUrlWithParams), std::vector<GURL>());
   ActivateAndExpectForFrameHostForUrl(driver(), main_rfh(),
                                       GURL("https://not-example.com"),
                                       false /* should_activate */);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, ActivateForFrameHostNeeded) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
-      kActivationScopeActivationList);
+      kActivationScopeActivationList,
+      kActivationListSocialEngineeringAdsInterstitial);
 
   BlacklistURLWithRedirects(GURL(kExampleUrlWithParams), std::vector<GURL>());
   ActivateAndExpectForFrameHostForUrl(driver(), main_rfh(), GURL(kTestUrl),
                                       false /* should_activate */);
   ActivateAndExpectForFrameHostForUrl(driver(), main_rfh(), GURL(kExampleUrl),
                                       true /* should_activate */);
 }
 
 TEST_P(ContentSubresourceFilterDriverFactoryThreatTypeTest, NonSocEngHit) {
+  const ActivationListTestData& test_data = GetParam();
+  base::FieldTrialList field_trial_list(nullptr);
+  testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
+      base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
+      kActivationScopeNoSites, test_data.activation_list);
+
   std::vector<GURL> redirects;
   redirects.push_back(GURL("https://example1.com"));
   redirects.push_back(GURL("https://example2.com"));
   redirects.push_back(GURL("https://example3.com"));
 
   const GURL test_url("https://example.com/nonsoceng?q=engsocnon");
-  factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
-      GURL(test_url), std::vector<GURL>(), GetParam());
-  EXPECT_EQ(0U, factory()->activation_set().size());
-  EXPECT_FALSE(factory()->ShouldActivateForURL(GURL(test_url)));
-  EXPECT_FALSE(
-      factory()->ShouldActivateForURL(GURL(test_url.GetWithEmptyPath())));
-  EXPECT_FALSE(factory()->ShouldActivateForURL(
-      GURL("http://" + test_url.host() + "/path?q=q")));
-  for (const auto& redirect : redirects) {
-    EXPECT_FALSE(factory()->ShouldActivateForURL(redirect));
-    EXPECT_FALSE(factory()->ShouldActivateForURL(redirect.GetWithEmptyPath()));
-    EXPECT_FALSE(
-        factory()->ShouldActivateForURL(GURL("http://" + redirect.host())));
-    EXPECT_FALSE(factory()->ShouldActivateForURL(
-        GURL("http://" + redirect.host() + "/path?q=q")));
-  }
+  VerifyEntitiesNotInTheBlacklist(test_url, redirects, test_data);
 };
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        ActivationPromptNotShownForNonMainFrames) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
-      kActivationScopeActivationList);
+      kActivationScopeActivationList,
+      kActivationListSocialEngineeringAdsInterstitial);
   NavigateToUrlAndExpectActivationAndPromptSubFrame(GURL(kExampleUrl),
                                                     false /* should_prompt */);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        DidStartProvisionalLoadScopeAllSitesStateDryRun) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateDryRun,
-      kActivationScopeAllSites);
+      kActivationScopeAllSites,
+      kActivationListSocialEngineeringAdsInterstitial);
   NavigateToUrlAndExpectActivationAndPrompt(GURL(kExampleUrlWithParams),
                                             true /* should_activate */,
                                             ActivationState::DRYRUN);
   factory()->AddHostOfURLToWhitelistSet(GURL(kExampleUrlWithParams));
   NavigateToUrlAndExpectActivationAndPrompt(GURL(kExampleUrlWithParams),
                                             false /* should_activate */,
                                             ActivationState::DISABLED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        DidStartProvisionalLoadScopeAllSitesStateEnabled) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
-      kActivationScopeAllSites);
+      kActivationScopeAllSites,
+      kActivationListSocialEngineeringAdsInterstitial);
   NavigateToUrlAndExpectActivationAndPrompt(GURL(kExampleUrlWithParams),
                                             true /* should_activate */,
                                             ActivationState::ENABLED);
   factory()->AddHostOfURLToWhitelistSet(GURL(kExampleUrlWithParams));
   NavigateToUrlAndExpectActivationAndPrompt(GURL(kExampleUrlWithParams),
                                             false /* should_activate */,
                                             ActivationState::DISABLED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        DidStartProvisionalLoadScopeNoSites) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateDryRun,
-      kActivationScopeNoSites);
+      kActivationScopeNoSites, kActivationListSocialEngineeringAdsInterstitial);
   NavigateToUrlAndExpectActivationAndPrompt(GURL(kExampleUrlWithParams),
                                             false /* should_activate */,
                                             ActivationState::DISABLED);
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest,
        DidStartProvisionalLoadScopeActivationList) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateDisabled,
-      kActivationScopeActivationList);
+      kActivationScopeActivationList,
+      kActivationListSocialEngineeringAdsInterstitial);
   NavigateToUrlAndExpectActivationAndPrompt(GURL(kExampleUrlWithParams),
                                             false /* should_activate */,
                                             ActivationState::DISABLED);
 }
 
-INSTANTIATE_TEST_CASE_P(
-    NoSonEngHit,
-    ContentSubresourceFilterDriverFactoryThreatTypeTest,
-    ::testing::Values(
-        safe_browsing::ThreatPatternType::NONE,
-        safe_browsing::ThreatPatternType::MALWARE_LANDING,
-        safe_browsing::ThreatPatternType::MALWARE_DISTRIBUTION,
-        safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_LANDING));
+INSTANTIATE_TEST_CASE_P(NoSonEngHit,
+                        ContentSubresourceFilterDriverFactoryThreatTypeTest,
+                        ::testing::ValuesIn(kActivationListTestData));
 
 }  // namespace subresource_filter