Add the client for accessing Subresource Filter only list.

chrome/browser/subresource_filter/subresource_filter_browsertest.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 <map>
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 72 matching lines @@
     "SubresourceFilter.PageLoad.SubresourceEvaluation.TotalCPUDuration";
 constexpr const char kEvaluationTotalWallDurationForDocument[] =
     "SubresourceFilter.DocumentLoad.SubresourceEvaluation.TotalWallDuration";
 constexpr const char kEvaluationTotalCPUDurationForDocument[] =
     "SubresourceFilter.DocumentLoad.SubresourceEvaluation.TotalCPUDuration";
 constexpr const char kEvaluationWallDuration[] =
     "SubresourceFilter.SubresourceLoad.Evaluation.WallDuration";
 constexpr const char kEvaluationCPUDuration[] =
     "SubresourceFilter.SubresourceLoad.Evaluation.CPUDuration";
 
+// Names of navigation chain patterns diagram.
+const char kMatchesPatternHistogramName[] =

[vakh (use Gerrit instead), 2017/02/10 03:00:12]

Didn't look closely at the changes in this file.
You might want to get it reviewed by someone who understands the SubResource
filter details better.

+    "SubresourceFilter.PageLoad.RedirectChainMatchPattern";
+const char kNavigationChainSize[] =
+    "SubresourceFilter.PageLoad.RedirectChainLength";
+const char kSubresourceFilterOnlySuffix[] = ".SubresourceFilterOnly";
+
 // Other histograms.
 const char kSubresourceFilterPromptHistogram[] =
     "SubresourceFilter.Prompt.NumVisibility";
 
+// 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,
+};
+
 // Database manager that allows any URL to be configured as blacklisted for
 // testing.
 class FakeSafeBrowsingDatabaseManager
     : public safe_browsing::TestSafeBrowsingDatabaseManager {
  public:
   FakeSafeBrowsingDatabaseManager() {}
 
   void AddBlacklistedURL(const GURL& url,
                          safe_browsing::SBThreatType threat_type) {
     url_to_threat_type_[url] = threat_type;
@@ skipping 11 matching lines @@
         base::Bind(&Client::OnCheckBrowseUrlResult, base::Unretained(client),
                    url, url_to_threat_type_[url],
                    safe_browsing::ThreatMetadata()));
     return false;
   }
 
   bool CheckResourceUrl(const GURL& url, Client* client) override {
     return true;
   }
 
+  bool CheckUrlForSubresourceFilter(const GURL& url, Client* client) override {
+    if (!url_to_threat_type_.count(url))
+      return true;
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&Client::OnCheckBrowseUrlResult, base::Unretained(client),
+                   url, url_to_threat_type_[url],
+                   safe_browsing::ThreatMetadata()));
+    return false;
+  }
+
   bool IsSupported() const override { return true; }
   bool ChecksAreAlwaysAsync() const override { return false; }
   bool CanCheckResourceType(
       content::ResourceType /* resource_type */) const override {
     return true;
   }
 
   safe_browsing::ThreatSource GetThreatSource() const override {
     return safe_browsing::ThreatSource::LOCAL_PVER4;
   }
@@ skipping 72 matching lines @@
   // called after ChromeBrowserMainParts::PreBrowserStart(), which instantiates
   // the RulesetService.
   //
   // On the other hand, setting up field trials in this method would be too
   // early, as it is called before BrowserMain, which expects no FieldTrialList
   // singleton to exist. There are no other hooks we could use either.
   //
   // As a workaround, enable the feature here, then enable the feature once
   // again + set up the field trials later.
   void SetUpCommandLine(base::CommandLine* command_line) override {
-    command_line->AppendSwitchASCII(switches::kEnableFeatures,
-                                    kSafeBrowsingSubresourceFilter.name);
+    command_line->AppendSwitchASCII(
+        switches::kEnableFeatures,
+        std::string(kSafeBrowsingSubresourceFilter.name) +
+            ", SafeBrowsingV4OnlyEnabled");
   }
 
   void SetUpInProcessBrowserTestFixture() override {
     fake_safe_browsing_database_ = new FakeSafeBrowsingDatabaseManager();
     test_safe_browsing_factory_.SetTestDatabaseManager(
         fake_safe_browsing_database_.get());
     test_safe_browsing_factory_.SetTestUIManager(new FakeSafeBrowsingUIManager);
     safe_browsing::SafeBrowsingService::RegisterFactory(
         &test_safe_browsing_factory_);
   }
@@ skipping 15 matching lines @@
 
   GURL GetTestUrl(const std::string& path) {
     return embedded_test_server()->base_url().Resolve(path);
   }
 
   void ConfigureAsPhishingURL(const GURL& url) {
     fake_safe_browsing_database_->AddBlacklistedURL(
         url, safe_browsing::SB_THREAT_TYPE_URL_PHISHING);
   }
 
+  void ConfigureAsSubresourceFilterOnlyURL(const GURL& url) {
+    fake_safe_browsing_database_->AddBlacklistedURL(
+        url, safe_browsing::SB_THREAT_TYPE_SUBRESOURCE_FILTER);
+  }
+
   content::WebContents* web_contents() {
     return browser()->tab_strip_model()->GetActiveWebContents();
   }
 
   content::RenderFrameHost* FindFrameByName(const std::string& name) {
     for (content::RenderFrameHost* frame : web_contents()->GetAllFrames()) {
       if (frame->GetFrameName() == name)
         return frame;
     }
     return nullptr;
@@ skipping 452 matching lines @@
   tester.ExpectTotalCount(kSubresourceLoadsEvaluated, 0);
   tester.ExpectTotalCount(kSubresourceLoadsMatchedRules, 0);
   tester.ExpectTotalCount(kSubresourceLoadsDisallowed, 0);
 
   // Although SubresourceFilterAgents still record the activation decision.
   tester.ExpectUniqueSample(
       kDocumentLoadActivationLevel,
       static_cast<base::Histogram::Sample>(ActivationLevel::DISABLED), 6);
 }
 
+IN_PROC_BROWSER_TEST_F(
+    SubresourceFilterBrowserTest,
+    ExpectRedirectPatternHistogramsAreRecordedForSubresourceFilterOnlyMatch) {
+  ASSERT_NO_FATAL_FAILURE(SetRulesetToDisallowURLsWithPathSuffix(
+      "suffix-that-does-not-match-anything"));
+
+  GURL url(GetTestUrl("subresource_filter/frame_with_included_script.html"));
+  ConfigureAsSubresourceFilterOnlyURL(url);
+
+  base::HistogramTester tester;
+  ui_test_utils::NavigateToURL(browser(), url);
+
+  EXPECT_THAT(tester.GetAllSamples(std::string(kMatchesPatternHistogramName) +
+                                   std::string(kSubresourceFilterOnlySuffix)),
+              ::testing::ElementsAre(base::Bucket(NO_REDIRECTS_HIT, 1)));
+  EXPECT_THAT(tester.GetAllSamples(std::string(kNavigationChainSize) +
+                                   std::string(kSubresourceFilterOnlySuffix)),
+              ::testing::ElementsAre(base::Bucket(1, 1)));
+}
+
+IN_PROC_BROWSER_TEST_F(
+    SubresourceFilterBrowserTest,
+    ExpectRedirectPatternHistogramsAreRecordedForSubresourceFilterOnlyWithRedirects) {
+  ASSERT_NO_FATAL_FAILURE(
+      SetRulesetToDisallowURLsWithPathSuffix("included_script.js"));
+  std::string initial_host("a.com");
+  std::string redirected_host("b.com");
+
+  GURL redirect_url(embedded_test_server()->GetURL(redirected_host, "/"));
+  GURL url(embedded_test_server()->GetURL(
+      initial_host, "/client-redirect?" + redirect_url.spec()));
+
+  ConfigureAsSubresourceFilterOnlyURL(redirect_url);
+  base::HistogramTester tester;
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), url, 2);
+  EXPECT_THAT(tester.GetAllSamples(std::string(kMatchesPatternHistogramName) +
+                                   std::string(kSubresourceFilterOnlySuffix)),
+              ::testing::ElementsAre(base::Bucket(NO_REDIRECTS_HIT, 1)));
+
+  EXPECT_THAT(tester.GetAllSamples(std::string(kNavigationChainSize) +
+                                   std::string(kSubresourceFilterOnlySuffix)),
+              ::testing::ElementsAre(base::Bucket(1, 1)));
+}
+
+IN_PROC_BROWSER_TEST_F(
+    SubresourceFilterBrowserTest,
+    ExpectRedirectPatternHistogramsAreRecordedForSubresourceFilterOnlyRedirectMatch) {
+  ASSERT_NO_FATAL_FAILURE(
+      SetRulesetToDisallowURLsWithPathSuffix("included_script.js"));
+  std::string initial_host("a.com");
+  std::string redirected_host("b.com");
+
+  GURL redirect_url(embedded_test_server()->GetURL(
+      redirected_host, "/subresource_filter/frame_with_included_script.html"));
+  GURL url(embedded_test_server()->GetURL(
+      initial_host, "/client-redirect?" + redirect_url.spec()));
+
+  ConfigureAsSubresourceFilterOnlyURL(GURL(url.host()));
+  base::HistogramTester tester;
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), url, 2);
+  EXPECT_THAT(tester.GetAllSamples(std::string(kMatchesPatternHistogramName) +
+                                   std::string(kSubresourceFilterOnlySuffix)),
+              ::testing::IsEmpty());
+
+  EXPECT_THAT(tester.GetAllSamples(std::string(kNavigationChainSize) +
+                                   std::string(kSubresourceFilterOnlySuffix)),
+              ::testing::IsEmpty());
+}
+
 }  // namespace subresource_filter