components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.cc - Issue 2415553002: Metrics for tracking Safe Browsing hit patterns for the Safe Browsing lists Subresource Filter.

Unified Diff: components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.cc

Issue 2415553002: Metrics for tracking Safe Browsing hit patterns for the Safe Browsing lists Subresource Filter. (Closed)

Patch Set: fix browser side navigation tests Created 4 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« components/subresource_filter/content/browser/content_subresource_filter_driver_factory.cc ('K') | « components/subresource_filter/content/browser/content_subresource_filter_driver_factory.cc ('k') | components/subresource_filter/core/common/BUILD.gn » ('j') | tools/metrics/histograms/histograms.xml » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.cc

diff --git a/components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.cc b/components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.cc

index 91991880da0f002a19a383ba984cca3503cc7710..03cac9a0deca4e5097b362afc3bc531a8b629424 100644

--- a/components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.cc

+++ b/components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.cc

@@ -5,6 +5,7 @@

#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"

#include "components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"

@@ -12,21 +13,49 @@

#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/common/browser_side_navigation_policy.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 subresource_filter {

namespace {

const char kExampleUrlWithParams[] = "https://example.com/soceng?q=engsoc";

-const char kTestUrl[] = "https://test.com";

const char kExampleUrl[] = "https://example.com";

const char kExampleLoginUrl[] = "https://example.com/login";

+const char kMatchesPatternHistogramName[] =

+ "SubresourceFilter.PageLoad.RedirectChainMatchPattern";

+const char kNavigationChainSize[] =

+ "SubresourceFilter.PageLoad.RedirectChainSize";

+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";

+// Tracks the redirects extected_pattern for the Subresource filter. The

engedy 2016/11/18 14:12:04 nit: Human readable representation of expected red

melandory 2016/11/22 14:16:24 Done.

+// 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 or C, or both and A are Safe Browsing matches.

engedy 2016/11/18 14:12:04 nit: Could we disambiguate like so: B and/or C, a

melandory 2016/11/22 14:16:24 Done.

+ F1M1L1, // B or C, or both and A and D are Safe Browsing matches.

+ NO_REDIRECTS_HIT, // Redirect chain consists of single URL aka no redirects

engedy 2016/11/18 14:12:04 nit: , aka

melandory 2016/11/22 14:16:24 Done.

+ // has happened, this URL was a Safe Browsing hit.

engedy 2016/11/18 14:12:04 nit: , and this

melandory 2016/11/22 14:16:24 Done.

+ NUM_HIT_PATTERNS,

+};

struct ActivationListTestData {

- bool should_add;

+ bool expected_activation;

const char* const activation_list;

safe_browsing::SBThreatType threat_type;

safe_browsing::ThreatPatternType threat_type_metadata;

@@ -44,9 +73,6 @@ const ActivationListTestData kActivationListTestData[] = {

{false, subresource_filter::kActivationListSocialEngineeringAdsInterstitial,

safe_browsing::SB_THREAT_TYPE_URL_PHISHING,

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},

@@ -74,11 +100,42 @@ const ActivationListTestData kActivationListTestData[] = {

{true, subresource_filter::kActivationListPhishingInterstitial,

safe_browsing::SB_THREAT_TYPE_URL_PHISHING,

safe_browsing::ThreatPatternType::NONE},

+ {true, subresource_filter::kActivationListSocialEngineeringAdsInterstitial,

+ safe_browsing::SB_THREAT_TYPE_URL_MALWARE,

+ safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS},

};

-} // namespace

+struct ActivationScopeTestData {

+ bool expected_activation;

+ bool url_matches_activation_list;

+ const char* const activation_scope;

+};

-namespace subresource_filter {

+const ActivationScopeTestData kActivationScopeTestData[] = {

+ {true /* expected_activation */, false /* url_matches_activation_list */,

+ kActivationScopeAllSites},

+ {true /* expected_activation */, true /* url_matches_activation_list */,

+ kActivationScopeAllSites},

+ {false /* expected_activation */, true /* url_matches_activation_list */,

+ kActivationScopeNoSites},

+ {true /* expected_activation */, true /* url_matches_activation_list */,

+ kActivationScopeActivationList},

+ {false /* expected_activation */, false /* url_matches_activation_list */,

+ kActivationScopeActivationList},

+};

+struct ActivationStateTestData {

+ bool expected_activation;

+ const char* const activation_state;

+};

+const ActivationStateTestData kActivationStateTestData[] = {

+ {true /* expected_activation */, kActivationStateDryRun},

+ {true /* expected_activation */, kActivationStateEnabled},

+ {false /* expected_activation */, kActivationStateDisabled},

+};

+} // namespace

class MockSubresourceFilterDriver : public ContentSubresourceFilterDriver {

public:

@@ -149,37 +206,63 @@ class ContentSubresourceFilterDriverFactoryTest

content::RenderFrameHost* subframe_rfh() { return subframe_rfh_; }

void BlacklistURLWithRedirectsNavigateAndCommit(

- const GURL& bad_url,

- const std::vector<GURL>& redirects,

- const GURL& url,

- bool should_activate) {

+ const std::vector<bool>& blacklisted_urls,

+ const std::vector<GURL>& navigation_chain,

+ safe_browsing::SBThreatType threat_type,

+ safe_browsing::ThreatPatternType threat_type_metadata,

+ RedirectChainMatchPattern extected_pattern,

+ bool expected_activation) {

+ base::HistogramTester tester;

EXPECT_CALL(*client(), ToggleNotificationVisibility(false)).Times(1);

- content::WebContentsTester::For(web_contents())->StartNavigation(url);

+ 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,

+ threat_type_metadata);

+ }

::testing::Mock::VerifyAndClearExpectations(client());

- factory()->OnMainResourceMatchedSafeBrowsingBlacklist(

- bad_url, redirects, safe_browsing::SB_THREAT_TYPE_URL_PHISHING,

- safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS);

- ActivateAndExpectForFrameHostForUrl(driver(), main_rfh(), url,

- should_activate);

- content::RenderFrameHostTester::For(main_rfh())

- ->SimulateNavigationCommit(url);

- }

+ for (size_t i = 1; i < navigation_chain.size(); ++i) {

+ const GURL url = navigation_chain[i];

+ if (i < blacklisted_urls.size() && blacklisted_urls[i]) {

+ factory()->OnMainResourceMatchedSafeBrowsingBlacklist(

+ url, navigation_chain, threat_type, threat_type_metadata);

+ }

+ rfh_tester->SimulateRedirect(url);

+ }

+ EXPECT_CALL(*driver(),

+ ActivateForProvisionalLoad(::testing::_, ::testing::_))

+ .Times(expected_activation);

+ if (!content::IsBrowserSideNavigationEnabled()) {

+ factory()->ReadyToCommitNavigationInternal(main_rfh(),

+ navigation_chain.back());

+ }

- void ActivateAndExpectForFrameHostForUrl(MockSubresourceFilterDriver* driver,

- content::RenderFrameHost* rfh,

- const GURL& url,

- bool should_activate) {

- EXPECT_CALL(*driver, ActivateForProvisionalLoad(::testing::_, ::testing::_))

- .Times(should_activate);

- factory()->ReadyToCommitNavigationInternal(rfh, url);

- ::testing::Mock::VerifyAndClearExpectations(driver);

+ rfh_tester->SimulateNavigationCommit(navigation_chain.back());

+ ::testing::Mock::VerifyAndClearExpectations(driver());

+ if (extected_pattern != EMPTY) {

+ EXPECT_THAT(tester.GetAllSamples(kMatchesPatternHistogramName),

+ ::testing::ElementsAre(base::Bucket(extected_pattern, 1)));

+ EXPECT_THAT(

+ tester.GetAllSamples(kNavigationChainSize),

+ ::testing::ElementsAre(base::Bucket(navigation_chain.size(), 1)));

+ } else {

+ EXPECT_THAT(tester.GetAllSamples(kMatchesPatternHistogramName),

+ ::testing::IsEmpty());

+ EXPECT_THAT(tester.GetAllSamples(kNavigationChainSize),

+ ::testing::IsEmpty());

+ }

}

- void NavigateAndCommitSubframe(const GURL& url, bool should_activate) {

+ void NavigateAndCommitSubframe(const GURL& url, bool expected_activation) {

EXPECT_CALL(*subframe_driver(),

ActivateForProvisionalLoad(::testing::_, ::testing::_))

- .Times(should_activate);

+ .Times(expected_activation);

EXPECT_CALL(*client(), ToggleNotificationVisibility(::testing::_)).Times(0);

factory()->ReadyToCommitNavigationInternal(subframe_rfh(), url);

@@ -187,20 +270,34 @@ class ContentSubresourceFilterDriverFactoryTest

::testing::Mock::VerifyAndClearExpectations(client());

}

- void BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- const GURL& bad_url,

- const std::vector<GURL>& redirects,

- const GURL& url,

- bool should_activate) {

- BlacklistURLWithRedirectsNavigateAndCommit(bad_url, redirects, url,

- should_activate);

+ 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 extected_pattern,

+ bool expected_activation) {

+ BlacklistURLWithRedirectsNavigateAndCommit(

+ blacklisted_urls, navigation_chain, threat_type, threat_type_metadata,

+ extected_pattern, expected_activation);

+ NavigateAndCommitSubframe(GURL(kExampleLoginUrl), expected_activation);

+ }

- NavigateAndCommitSubframe(GURL(kExampleLoginUrl), should_activate);

+ void NavigateAndExpectActivation(const std::vector<bool>& blacklisted_urls,

+ const std::vector<GURL>& navigation_chain,

+ RedirectChainMatchPattern extected_pattern,

+ bool expected_activation) {

+ NavigateAndExpectActivation(

+ blacklisted_urls, navigation_chain,

+ safe_browsing::SB_THREAT_TYPE_URL_PHISHING,

+ safe_browsing::ThreatPatternType::SOCIAL_ENGINEERING_ADS,

+ extected_pattern, expected_activation);

}

- void SpecialCaseNavSeq(const GURL& bad_url,

- const std::vector<GURL>& redirects,

- bool should_activate) {

+ void EmulateInPageNavigation(const std::vector<bool>& blacklisted_urls,

+ RedirectChainMatchPattern extected_pattern,

+ bool expected_activation) {

// This test-case examinse the nevigation woth following sequence of event:

// DidStartProvisional(main, "example.com")

// ReadyToCommitMainFrameNavigation(“example.com”)

engedy 2016/11/18 14:12:04 nit: -MainFrame

melandory 2016/11/22 14:16:24 Done.

@@ -209,8 +306,8 @@ class ContentSubresourceFilterDriverFactoryTest

// DidCommitProvisional(sub, "example.com/login")

// DidCommitProvisional(main, "example.com#ref")

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- bad_url, redirects, GURL(kExampleUrl), should_activate);

+ NavigateAndExpectActivation(blacklisted_urls, {GURL(kExampleUrl)},

+ extected_pattern, expected_activation);

EXPECT_CALL(*driver(),

ActivateForProvisionalLoad(::testing::_, ::testing::_))

.Times(0);

@@ -243,197 +340,224 @@ class ContentSubresourceFilterDriverFactoryThreatTypeTest

DISALLOW_COPY_AND_ASSIGN(ContentSubresourceFilterDriverFactoryThreatTypeTest);

};

-TEST_F(ContentSubresourceFilterDriverFactoryTest,

- ActivateForFrameHostNotNeeded) {

- base::FieldTrialList field_trial_list(nullptr);

- testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(

- base::FeatureList::OVERRIDE_DISABLE_FEATURE, kActivationStateEnabled,

- kActivationScopeNoSites, kActivationListSocialEngineeringAdsInterstitial);

- ActivateAndExpectForFrameHostForUrl(driver(), main_rfh(), GURL(kTestUrl),

- false /* should_activate */);

- const GURL url(kExampleUrlWithParams);

- BlacklistURLWithRedirectsNavigateAndCommit(url, std::vector<GURL>(), url,

- false /* should_activate */);

- BlacklistURLWithRedirectsNavigateAndCommit(url, std::vector<GURL>(),

- 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,

- kActivationListSocialEngineeringAdsInterstitial);

- const GURL url(kExampleUrlWithParams);

- BlacklistURLWithRedirectsNavigateAndCommit(url, std::vector<GURL>(), url,

- true /* should_activate */);

- BlacklistURLWithRedirectsNavigateAndCommit(

- url, std::vector<GURL>(), GURL(kExampleUrl), false /* 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);

+class ContentSubresourceFilterDriverFactoryActivationScopeTest

+ : public ContentSubresourceFilterDriverFactoryTest,

+ public ::testing::WithParamInterface<ActivationScopeTestData> {

+ public:

+ ContentSubresourceFilterDriverFactoryActivationScopeTest() {}

+ ~ContentSubresourceFilterDriverFactoryActivationScopeTest() override {}

- 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"));

+ private:

+ DISALLOW_COPY_AND_ASSIGN(

+ ContentSubresourceFilterDriverFactoryActivationScopeTest);

+};

- const GURL test_url("https://example.com/nonsoceng?q=engsocnon");

+class ContentSubresourceFilterDriverFactoryActivationStateTest

+ : public ContentSubresourceFilterDriverFactoryTest,

+ public ::testing::WithParamInterface<ActivationStateTestData> {

+ public:

+ ContentSubresourceFilterDriverFactoryActivationStateTest() {}

+ ~ContentSubresourceFilterDriverFactoryActivationStateTest() override {}

- BlacklistURLWithRedirectsNavigateAndCommit(GURL::EmptyGURL(),

- std::vector<GURL>(), test_url,

- false /* should_activate */);

- EXPECT_CALL(*client(), ToggleNotificationVisibility(false)).Times(1);

- content::WebContentsTester::For(web_contents())->StartNavigation(test_url);

- ::testing::Mock::VerifyAndClearExpectations(client());

- factory()->OnMainResourceMatchedSafeBrowsingBlacklist(

- test_url, redirects, test_data.threat_type,

- test_data.threat_type_metadata);

- ActivateAndExpectForFrameHostForUrl(driver(), main_rfh(), test_url, false);

- content::RenderFrameHostTester::For(main_rfh())

- ->SimulateNavigationCommit(test_url);

+ private:

+ DISALLOW_COPY_AND_ASSIGN(

+ ContentSubresourceFilterDriverFactoryActivationStateTest);

};

TEST_F(ContentSubresourceFilterDriverFactoryTest,

- ActivationPromptNotShownForNonMainFrames) {

+ ActivateForFrameHostDisabledFeature) {

+ // Activation scope is set to NONE => no activation should happen even if URL

+ // which is visited was a SB hit.

base::FieldTrialList field_trial_list(nullptr);

testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(

- base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,

- kActivationScopeActivationList,

- kActivationListSocialEngineeringAdsInterstitial);

- BlacklistURLWithRedirectsNavigateAndCommit(

- GURL::EmptyGURL(), std::vector<GURL>(), 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,

+ base::FeatureList::OVERRIDE_DISABLE_FEATURE, kActivationStateEnabled,

kActivationScopeAllSites,

kActivationListSocialEngineeringAdsInterstitial);

const GURL url(kExampleUrlWithParams);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- url, std::vector<GURL>(), url, true /* should_activate */);

+ NavigateAndExpectActivation({true}, {url}, EMPTY,

+ false /* expected_activation */);

factory()->AddHostOfURLToWhitelistSet(url);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- url, std::vector<GURL>(), GURL(kExampleUrlWithParams),

- false /* should_activate */);

+ NavigateAndExpectActivation({true}, {url}, EMPTY,

+ false /* expected_activation */);

}

-TEST_F(ContentSubresourceFilterDriverFactoryTest,

- DidStartProvisionalLoadScopeAllSitesStateEnabled) {

+TEST_F(ContentSubresourceFilterDriverFactoryTest, NoActivationWhenNoMatch) {

base::FieldTrialList field_trial_list(nullptr);

testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(

base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,

- kActivationScopeAllSites,

+ kActivationScopeActivationList,

kActivationListSocialEngineeringAdsInterstitial);

- const GURL url(kExampleUrlWithParams);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- url, std::vector<GURL>(), url, true /* should_activate */);

- factory()->AddHostOfURLToWhitelistSet(url);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- url, std::vector<GURL>(), GURL(kExampleUrlWithParams),

- false /* should_activate */);

+ NavigateAndExpectActivation({false}, {GURL(kExampleUrl)}, EMPTY,

+ false /* should_prompt */);

}

TEST_F(ContentSubresourceFilterDriverFactoryTest,

- DidStartProvisionalLoadScopeActivationListSitesStateEnabled) {

+ SpecialCaseNavigationAllSitesEnabled) {

+ // Check that when the experiment is enabled for all site, the activation

+ // signal is always sent.

base::FieldTrialList field_trial_list(nullptr);

testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(

base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,

- kActivationScopeActivationList,

- kActivationListSocialEngineeringAdsInterstitial);

- const GURL url(kExampleUrlWithParams);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- url, std::vector<GURL>(), url, true /* should_activate */);

- factory()->AddHostOfURLToWhitelistSet(url);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- url, std::vector<GURL>(), GURL(kExampleUrlWithParams),

- false /* should_activate */);

+ kActivationScopeAllSites);

+ EmulateInPageNavigation({false}, EMPTY, true /* expected_activation */);

}

TEST_F(ContentSubresourceFilterDriverFactoryTest,

- DidStartProvisionalLoadScopeActivationListSitesStateDryRun) {

+ SpecialCaseNavigationActivationListEnabled) {

base::FieldTrialList field_trial_list(nullptr);

testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(

- base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateDryRun,

+ base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,

kActivationScopeActivationList,

kActivationListSocialEngineeringAdsInterstitial);

- const GURL url(kExampleUrlWithParams);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- url, std::vector<GURL>(), url, true /* should_activate */);

- factory()->AddHostOfURLToWhitelistSet(url);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- url, std::vector<GURL>(), url, false /* should_activate */);

+ EmulateInPageNavigation({true}, NO_REDIRECTS_HIT,

+ true /* expected_activation */);

}

-TEST_F(ContentSubresourceFilterDriverFactoryTest,

- DidStartProvisionalLoadScopeNoSites) {

+TEST_F(ContentSubresourceFilterDriverFactoryTest, RedirectPatternTest) {

base::FieldTrialList field_trial_list(nullptr);

testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(

- base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateDryRun,

- kActivationScopeNoSites, kActivationListSocialEngineeringAdsInterstitial);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- GURL::EmptyGURL(), std::vector<GURL>(), GURL(kExampleUrlWithParams),

- false /* should_activate */);

+ base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,

+ kActivationScopeActivationList,

+ kActivationListSocialEngineeringAdsInterstitial);

+ struct RedirectRedirectChainMatchPatternTestData {

+ std::vector<bool> blacklisted_urls;

+ std::vector<GURL> navigation_chain;

+ RedirectChainMatchPattern hit_extected_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)},

+ F0M1L0,

+ false},

+ {{false, true, true},

+ {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},

+ F0M1L1,

+ true},

+ {{true, false, false},

+ {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},

+ F1M0L0,

+ false},

+ {{true, false, true},

+ {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},

+ F1M0L1,

+ true},

+ {{true, true, false},

+ {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},

+ F1M1L0,

+ false},

+ {{true, true, true},

+ {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC)},

+ F1M1L1,

+ true},

+ {{false, true, false, false},

+ {GURL(kUrlA), GURL(kUrlB), GURL(kUrlC), GURL(kUrlD)},

+ F0M1L0,

+ 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_extected_pattern, test_data.expected_activation);

+ NavigateAndExpectActivation({false}, {GURL("https://dummy.com")}, EMPTY,

+ false);

+ }

}

-TEST_F(ContentSubresourceFilterDriverFactoryTest,

- DidStartProvisionalLoadScopeActivationList) {

+TEST_P(ContentSubresourceFilterDriverFactoryActivationStateTest,

+ ActivateForFrameState) {

+ const ActivationStateTestData& test_data = GetParam();

base::FieldTrialList field_trial_list(nullptr);

testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(

- base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateDisabled,

+ base::FeatureList::OVERRIDE_ENABLE_FEATURE, test_data.activation_state,

kActivationScopeActivationList,

kActivationListSocialEngineeringAdsInterstitial);

- BlacklistURLWithRedirectsNavigateMainFrameAndSubrame(

- GURL::EmptyGURL(), std::vector<GURL>(), GURL(kExampleUrlWithParams),

- false /* should_activate */);

-TEST_F(ContentSubresourceFilterDriverFactoryTest,

- SpecialCaseNavigationAllSitesDryRun) {

- base::FieldTrialList field_trial_list(nullptr);

- testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(

- base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateDryRun,

- kActivationScopeAllSites);

- SpecialCaseNavSeq(GURL::EmptyGURL(), std::vector<GURL>(),

- true /* should_activate */);

+ const GURL url(kExampleUrlWithParams);

+ NavigateAndExpectActivation({true}, {url}, NO_REDIRECTS_HIT,

+ test_data.expected_activation);

+ factory()->AddHostOfURLToWhitelistSet(url);

+ NavigateAndExpectActivation({true}, {GURL(kExampleUrlWithParams)},

+ NO_REDIRECTS_HIT,

+ false /* expected_activation */);

}

-TEST_F(ContentSubresourceFilterDriverFactoryTest,

- SpecialCaseNavigationAllSitesEnabled) {

- // Check that when the experiment is enabled for all site, the activation

- // signal is always sent.

+TEST_P(ContentSubresourceFilterDriverFactoryThreatTypeTest,

+ ActivateForTheListType) {

+ // Sets up the experiment in a way that the activation decision depends on the

+ // list for which the Safe Browsing hit has happened.

+ const ActivationListTestData& test_data = GetParam();

base::FieldTrialList field_trial_list(nullptr);

testing::ScopedSubresourceFilterFeatureToggle scoped_feature_toggle(

base::FeatureList::OVERRIDE_ENABLE_FEATURE, kActivationStateEnabled,

- kActivationScopeAllSites);

- SpecialCaseNavSeq(GURL::EmptyGURL(), std::vector<GURL>(),

- true /* should_activate */);

+ kActivationScopeActivationList, test_data.activation_list);

-TEST_F(ContentSubresourceFilterDriverFactoryTest,

- SpecialCaseNavigationActivationListEnabled) {

+ 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);

+};

+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, kActivationStateEnabled,

- kActivationScopeActivationList,

+ test_data.activation_scope,

kActivationListSocialEngineeringAdsInterstitial);

- SpecialCaseNavSeq(GURL(kExampleUrl), std::vector<GURL>(),

- true /* should_activate */);

-INSTANTIATE_TEST_CASE_P(NoSonEngHit,

+ const GURL test_url(kExampleUrlWithParams);

+ RedirectChainMatchPattern extected_pattern =

+ test_data.url_matches_activation_list ? NO_REDIRECTS_HIT : EMPTY;

+ NavigateAndExpectActivation({test_data.url_matches_activation_list},

+ {test_url}, extected_pattern,

+ test_data.expected_activation);

+ if (test_data.url_matches_activation_list) {

+ factory()->AddHostOfURLToWhitelistSet(test_url);

+ NavigateAndExpectActivation({test_data.url_matches_activation_list},

+ {GURL(kExampleUrlWithParams)}, extected_pattern,

+ false /* expected_activation */);

+ }

+};

+INSTANTIATE_TEST_CASE_P(NoSocEngHit,

ContentSubresourceFilterDriverFactoryThreatTypeTest,

::testing::ValuesIn(kActivationListTestData));

+INSTANTIATE_TEST_CASE_P(

+ ActivationScopeTest,

+ ContentSubresourceFilterDriverFactoryActivationScopeTest,

+ ::testing::ValuesIn(kActivationScopeTestData));

+INSTANTIATE_TEST_CASE_P(

+ ActivationStateTest,

+ ContentSubresourceFilterDriverFactoryActivationStateTest,

+ ::testing::ValuesIn(kActivationStateTestData));

} // namespace subresource_filter