Allow Safe Browsing Saresource Filter to distinguish between different lists.

components/subresource_filter/content/browser/subresource_filter_navigation_throttle_unittests.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/subresource_filter_navigation_throttle.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 116 matching lines @@
 TEST_F(SubresourceFilterNavigationThrottleTest, RequestWithoutRedirects) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
       kActivationScopeActivationList);
 
   const GURL url(kExampleURL);
   SetUpNavigationHandleForURL(url);
   SimulateWillStart();
   factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
-      url, std::vector<GURL>(),
+      url, std::vector<GURL>(), safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
       safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS);
   EXPECT_CALL(*driver(), ActivateForProvisionalLoad(ActivationState::ENABLED))
       .Times(1);
   SimulateWillProcessResponse();
   ::testing::Mock::VerifyAndClearExpectations(driver());
 
   EXPECT_EQ(1U, factory()->activation_set().size());
   EXPECT_TRUE(factory()->ShouldActivateForURL(url));
 }
 
 TEST_F(SubresourceFilterNavigationThrottleTest,
        RequestWithoutRedirectsNoActivation) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
       kActivationScopeActivationList);
 
   const GURL url_with_activation(kExampleURL);
   const GURL url_without_activation(kTestURL);
 
   factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
       url_with_activation, std::vector<GURL>(),
+      safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
       safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS);
 
   SetUpNavigationHandleForURL(url_without_activation);
   SimulateWillStart();
 
   EXPECT_CALL(*driver(), ActivateForProvisionalLoad(::testing::_)).Times(0);
   SimulateWillProcessResponse();
   ::testing::Mock::VerifyAndClearExpectations(driver());
 
   EXPECT_EQ(1U, factory()->activation_set().size());
   EXPECT_TRUE(factory()->ShouldActivateForURL(url_with_activation));
   EXPECT_FALSE(factory()->ShouldActivateForURL(url_without_activation));
 }
 
 TEST_F(SubresourceFilterNavigationThrottleTest,
        RequestToNonWebURLNoActivation) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
       kActivationScopeActivationList);
 
   const GURL non_web_url(kNonWebURL);
 
   factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
       non_web_url, std::vector<GURL>(),
+      safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
       safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS);
 
   SetUpNavigationHandleForURL(non_web_url);
   SimulateWillStart();
 
   EXPECT_CALL(*driver(), ActivateForProvisionalLoad(::testing::_)).Times(0);
   SimulateWillProcessResponse();
   ::testing::Mock::VerifyAndClearExpectations(driver());
 
   EXPECT_EQ(0U, factory()->activation_set().size());
   EXPECT_FALSE(factory()->ShouldActivateForURL(non_web_url));
 }
 
 TEST_F(SubresourceFilterNavigationThrottleTest,
        AddRedirectFromNavThrottleToServiceEmptyInitRedirects) {
   // Navigations |url| -> |redirect|. Safe Browsing classifies the |url| as
   // containing deceptive content.
   // Test checks that both |url| and |redirect| are in the activation set.
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
       kActivationScopeActivationList);
 
   const GURL url(kExampleURL);
   const GURL redirect(kRedirectURLFirst);
 
   SetUpNavigationHandleForURL(url);
   SimulateWillStart();
   factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
-      url, std::vector<GURL>(),
+      url, std::vector<GURL>(), safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
       safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS);
   SimulateRedirects(redirect);
 
   EXPECT_CALL(*driver(), ActivateForProvisionalLoad(ActivationState::ENABLED))
       .Times(1);
   SimulateWillProcessResponse();
   ::testing::Mock::VerifyAndClearExpectations(driver());
 
   EXPECT_EQ(2U, factory()->activation_set().size());
   EXPECT_TRUE(factory()->ShouldActivateForURL(url));
@@ skipping 16 matching lines @@
   const GURL first_redirect(kRedirectURLFirst);
   const GURL second_redirect(kRedirectURLSecond);
   const GURL third_redirect(kRedirectURLThird);
 
   SetUpNavigationHandleForURL(url);
   SimulateWillStart();
 
   std::vector<GURL> redirects = {first_redirect, second_redirect,
                                  third_redirect};
   factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
-      url, redirects, safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS);
+      url, redirects, safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
+      safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS);
 
   SimulateRedirects(redirect_after_sb_classification);
 
   EXPECT_CALL(*driver(), ActivateForProvisionalLoad(ActivationState::ENABLED))
       .Times(1);
   SimulateWillProcessResponse();
   ::testing::Mock::VerifyAndClearExpectations(driver());
 
   EXPECT_EQ(redirects.size() + 2U, factory()->activation_set().size());
   EXPECT_TRUE(factory()->ShouldActivateForURL(url));
   EXPECT_TRUE(factory()->ShouldActivateForURL(first_redirect));
   EXPECT_TRUE(factory()->ShouldActivateForURL(second_redirect));
   EXPECT_TRUE(factory()->ShouldActivateForURL(third_redirect));
   EXPECT_TRUE(
       factory()->ShouldActivateForURL(redirect_after_sb_classification));
 }
 
 TEST_F(SubresourceFilterNavigationThrottleTest,
        RequestRedirectWithMatchRedirectTest) {
   base::FieldTrialList field_trial_list(nullptr);
   testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(
       base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,
       kActivationScopeActivationList);
 
   const GURL init_url(kExampleURL);
   const GURL redirect_with_match(kRedirectURLFirst);
   const GURL final_url(kRedirectURLSecond);
   std::vector<GURL> redirects = {redirect_with_match};
   factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
-      init_url, redirects,
+      init_url, redirects, safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
       safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS);
 
   SetUpNavigationHandleForURL(init_url);
   SimulateWillStart();
   SimulateRedirects(redirect_with_match);
   SimulateRedirects(final_url);
 
   EXPECT_CALL(*driver(), ActivateForProvisionalLoad(ActivationState::ENABLED))
       .Times(1);
   SimulateWillProcessResponse();
   ::testing::Mock::VerifyAndClearExpectations(driver());
 
   EXPECT_EQ(3U, factory()->activation_set().size());
   EXPECT_TRUE(factory()->ShouldActivateForURL(init_url));
   EXPECT_TRUE(factory()->ShouldActivateForURL(redirect_with_match));
   EXPECT_TRUE(factory()->ShouldActivateForURL(final_url));
 }
 
 }  // namespace subresource_filter