Convert SupervisedUserResourceThrottle to a NavigationThrottle.

chrome/browser/supervised_user/supervised_user_url_filter_unittest.cc

 // Copyright 2014 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 "chrome/browser/supervised_user/supervised_user_url_filter.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/supervised_user/supervised_user_site_list.h"
 #include "extensions/features/features.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 class SupervisedUserURLFilterTest : public ::testing::Test,
                                     public SupervisedUserURLFilter::Observer {
  public:
-  SupervisedUserURLFilterTest() : filter_(new SupervisedUserURLFilter) {
-    filter_->SetDefaultFilteringBehavior(SupervisedUserURLFilter::BLOCK);
-    filter_->AddObserver(this);
+  SupervisedUserURLFilterTest() {
+    filter_.SetDefaultFilteringBehavior(SupervisedUserURLFilter::BLOCK);
+    filter_.AddObserver(this);
   }
 
-  ~SupervisedUserURLFilterTest() override { filter_->RemoveObserver(this); }
+  ~SupervisedUserURLFilterTest() override { filter_.RemoveObserver(this); }
 
   // SupervisedUserURLFilter::Observer:
   void OnSiteListUpdated() override { run_loop_.Quit(); }
 
  protected:
   bool IsURLWhitelisted(const std::string& url) {
-    return filter_->GetFilteringBehaviorForURL(GURL(url)) ==
+    return filter_.GetFilteringBehaviorForURL(GURL(url)) ==
            SupervisedUserURLFilter::ALLOW;
   }
 
   GURL GetEmbeddedURL(const std::string& url) {
-    return filter_->GetEmbeddedURL(GURL(url));
+    return filter_.GetEmbeddedURL(GURL(url));
   }
 
   base::MessageLoop message_loop_;
   base::RunLoop run_loop_;
-  scoped_refptr<SupervisedUserURLFilter> filter_;
+  SupervisedUserURLFilter filter_;
 };
 
 TEST_F(SupervisedUserURLFilterTest, Basic) {
   std::vector<std::string> list;
   // Allow domain and all subdomains, for any filtered scheme.
   list.push_back("google.com");
-  filter_->SetFromPatternsForTesting(list);
+  filter_.SetFromPatternsForTesting(list);
   run_loop_.Run();
 
   EXPECT_TRUE(IsURLWhitelisted("http://google.com"));
   EXPECT_TRUE(IsURLWhitelisted("http://google.com/"));
   EXPECT_TRUE(IsURLWhitelisted("http://google.com/whatever"));
   EXPECT_TRUE(IsURLWhitelisted("https://google.com/"));
   EXPECT_FALSE(IsURLWhitelisted("http://notgoogle.com/"));
   EXPECT_TRUE(IsURLWhitelisted("http://mail.google.com"));
   EXPECT_TRUE(IsURLWhitelisted("http://x.mail.google.com"));
   EXPECT_TRUE(IsURLWhitelisted("https://x.mail.google.com/"));
   EXPECT_TRUE(IsURLWhitelisted("http://x.y.google.com/a/b"));
   EXPECT_FALSE(IsURLWhitelisted("http://youtube.com/"));
 
   EXPECT_TRUE(IsURLWhitelisted("bogus://youtube.com/"));
   EXPECT_TRUE(IsURLWhitelisted("chrome://youtube.com/"));
   EXPECT_TRUE(IsURLWhitelisted("chrome://extensions/"));
   EXPECT_TRUE(IsURLWhitelisted("chrome-extension://foo/main.html"));
   EXPECT_TRUE(IsURLWhitelisted("file:///home/chronos/user/Downloads/img.jpg"));
 }
 
 TEST_F(SupervisedUserURLFilterTest, EffectiveURL) {
   std::vector<std::string> list;
   // Allow domain and all subdomains, for any filtered scheme.
   list.push_back("example.com");
-  filter_->SetFromPatternsForTesting(list);
+  filter_.SetFromPatternsForTesting(list);
   run_loop_.Run();
 
   ASSERT_TRUE(IsURLWhitelisted("http://example.com"));
   ASSERT_TRUE(IsURLWhitelisted("https://example.com"));
 
   // AMP Cache URLs.
   EXPECT_FALSE(IsURLWhitelisted("https://cdn.ampproject.org"));
   EXPECT_TRUE(IsURLWhitelisted("https://cdn.ampproject.org/c/example.com"));
   EXPECT_TRUE(IsURLWhitelisted("https://cdn.ampproject.org/c/www.example.com"));
   EXPECT_TRUE(
@@ skipping 53 matching lines @@
       "https://translate.googleusercontent.com/translate?u=example.com"));
   EXPECT_TRUE(IsURLWhitelisted(
       "https://translate.google.com/translate?u=www.example.com"));
   EXPECT_TRUE(IsURLWhitelisted(
       "https://translate.google.com/translate?u=https://example.com"));
   EXPECT_FALSE(
       IsURLWhitelisted("https://translate.google.com/translate?u=other.com"));
 }
 
 TEST_F(SupervisedUserURLFilterTest, Inactive) {
-  filter_->SetDefaultFilteringBehavior(SupervisedUserURLFilter::ALLOW);
+  filter_.SetDefaultFilteringBehavior(SupervisedUserURLFilter::ALLOW);
 
   std::vector<std::string> list;
   list.push_back("google.com");
-  filter_->SetFromPatternsForTesting(list);
+  filter_.SetFromPatternsForTesting(list);
   run_loop_.Run();
 
   // If the filter is inactive, every URL should be whitelisted.
   EXPECT_TRUE(IsURLWhitelisted("http://google.com"));
   EXPECT_TRUE(IsURLWhitelisted("https://www.example.com"));
 }
 
 TEST_F(SupervisedUserURLFilterTest, Scheme) {
   std::vector<std::string> list;
   // Filter only http, ftp and ws schemes.
   list.push_back("http://secure.com");
   list.push_back("ftp://secure.com");
   list.push_back("ws://secure.com");
-  filter_->SetFromPatternsForTesting(list);
+  filter_.SetFromPatternsForTesting(list);
   run_loop_.Run();
 
   EXPECT_TRUE(IsURLWhitelisted("http://secure.com"));
   EXPECT_TRUE(IsURLWhitelisted("http://secure.com/whatever"));
   EXPECT_TRUE(IsURLWhitelisted("ftp://secure.com/"));
   EXPECT_TRUE(IsURLWhitelisted("ws://secure.com"));
   EXPECT_FALSE(IsURLWhitelisted("https://secure.com/"));
   EXPECT_FALSE(IsURLWhitelisted("wss://secure.com"));
   EXPECT_TRUE(IsURLWhitelisted("http://www.secure.com"));
   EXPECT_FALSE(IsURLWhitelisted("https://www.secure.com"));
   EXPECT_FALSE(IsURLWhitelisted("wss://www.secure.com"));
 }
 
 TEST_F(SupervisedUserURLFilterTest, Path) {
   std::vector<std::string> list;
   // Filter only a certain path prefix.
   list.push_back("path.to/ruin");
-  filter_->SetFromPatternsForTesting(list);
+  filter_.SetFromPatternsForTesting(list);
   run_loop_.Run();
 
   EXPECT_TRUE(IsURLWhitelisted("http://path.to/ruin"));
   EXPECT_TRUE(IsURLWhitelisted("https://path.to/ruin"));
   EXPECT_TRUE(IsURLWhitelisted("http://path.to/ruins"));
   EXPECT_TRUE(IsURLWhitelisted("http://path.to/ruin/signup"));
   EXPECT_TRUE(IsURLWhitelisted("http://www.path.to/ruin"));
   EXPECT_FALSE(IsURLWhitelisted("http://path.to/fortune"));
 }
 
 TEST_F(SupervisedUserURLFilterTest, PathAndScheme) {
   std::vector<std::string> list;
   // Filter only a certain path prefix and scheme.
   list.push_back("https://s.aaa.com/path");
-  filter_->SetFromPatternsForTesting(list);
+  filter_.SetFromPatternsForTesting(list);
   run_loop_.Run();
 
   EXPECT_TRUE(IsURLWhitelisted("https://s.aaa.com/path"));
   EXPECT_TRUE(IsURLWhitelisted("https://s.aaa.com/path/bbb"));
   EXPECT_FALSE(IsURLWhitelisted("http://s.aaa.com/path"));
   EXPECT_FALSE(IsURLWhitelisted("https://aaa.com/path"));
   EXPECT_FALSE(IsURLWhitelisted("https://x.aaa.com/path"));
   EXPECT_FALSE(IsURLWhitelisted("https://s.aaa.com/bbb"));
   EXPECT_FALSE(IsURLWhitelisted("https://s.aaa.com/"));
 }
 
 TEST_F(SupervisedUserURLFilterTest, Host) {
   std::vector<std::string> list;
   // Filter only a certain hostname, without subdomains.
   list.push_back(".www.example.com");
-  filter_->SetFromPatternsForTesting(list);
+  filter_.SetFromPatternsForTesting(list);
   run_loop_.Run();
 
   EXPECT_TRUE(IsURLWhitelisted("http://www.example.com"));
   EXPECT_FALSE(IsURLWhitelisted("http://example.com"));
   EXPECT_FALSE(IsURLWhitelisted("http://subdomain.example.com"));
 }
 
 TEST_F(SupervisedUserURLFilterTest, IPAddress) {
   std::vector<std::string> list;
   // Filter an ip address.
   list.push_back("123.123.123.123");
-  filter_->SetFromPatternsForTesting(list);
+  filter_.SetFromPatternsForTesting(list);
   run_loop_.Run();
 
   EXPECT_TRUE(IsURLWhitelisted("http://123.123.123.123/"));
   EXPECT_FALSE(IsURLWhitelisted("http://123.123.123.124/"));
 }
 
 TEST_F(SupervisedUserURLFilterTest, Canonicalization) {
   // We assume that the hosts and URLs are already canonicalized.
   std::map<std::string, bool> hosts;
   hosts["www.moose.org"] = true;
   hosts["www.xn--n3h.net"] = true;
   std::map<GURL, bool> urls;
   urls[GURL("http://www.example.com/foo/")] = true;
   urls[GURL("http://www.example.com/%C3%85t%C3%B8mstr%C3%B6m")] = true;
-  filter_->SetManualHosts(&hosts);
-  filter_->SetManualURLs(&urls);
+  filter_.SetManualHosts(std::move(hosts));
+  filter_.SetManualURLs(std::move(urls));
 
   // Base cases.
   EXPECT_TRUE(IsURLWhitelisted("http://www.example.com/foo/"));
   EXPECT_TRUE(IsURLWhitelisted(
       "http://www.example.com/%C3%85t%C3%B8mstr%C3%B6m"));
 
   // Verify that non-URI characters are escaped.
   EXPECT_TRUE(IsURLWhitelisted(
       "http://www.example.com/\xc3\x85t\xc3\xb8mstr\xc3\xb6m"));
 
@@ skipping 150 matching lines @@
   std::map<std::string, bool> hosts;
 
   // Initally, the second rule is ignored because has the same value as the
   // default (block). When we change the default to allow, the first rule is
   // ignored instead.
   hosts["*.google.com"] = true;
   hosts["www.google.*"] = false;
 
   hosts["accounts.google.com"] = false;
   hosts["mail.google.com"] = true;
-  filter_->SetManualHosts(&hosts);
+  filter_.SetManualHosts(std::move(hosts));
 
   // Initially, the default filtering behavior is BLOCK.
   EXPECT_TRUE(IsURLWhitelisted("http://www.google.com/foo/"));
   EXPECT_FALSE(IsURLWhitelisted("http://accounts.google.com/bar/"));
   EXPECT_FALSE(IsURLWhitelisted("http://www.google.co.uk/blurp/"));
   EXPECT_TRUE(IsURLWhitelisted("http://mail.google.com/moose/"));
 
-  filter_->SetDefaultFilteringBehavior(SupervisedUserURLFilter::ALLOW);
+  filter_.SetDefaultFilteringBehavior(SupervisedUserURLFilter::ALLOW);
   EXPECT_FALSE(IsURLWhitelisted("http://www.google.com/foo/"));
   EXPECT_FALSE(IsURLWhitelisted("http://accounts.google.com/bar/"));
   EXPECT_FALSE(IsURLWhitelisted("http://www.google.co.uk/blurp/"));
   EXPECT_TRUE(IsURLWhitelisted("http://mail.google.com/moose/"));
 }
 
 TEST_F(SupervisedUserURLFilterTest, WhitelistsPatterns) {
   std::vector<std::string> patterns1;
   patterns1.push_back("google.com");
   patterns1.push_back("example.com");
@@ skipping 13 matching lines @@
       new SupervisedUserSiteList(id1, title1, entry_point, base::FilePath(),
                                  patterns1, hostname_hashes));
   scoped_refptr<SupervisedUserSiteList> site_list2 = make_scoped_refptr(
       new SupervisedUserSiteList(id2, title2, entry_point, base::FilePath(),
                                  patterns2, hostname_hashes));
 
   std::vector<scoped_refptr<SupervisedUserSiteList>> site_lists;
   site_lists.push_back(site_list1);
   site_lists.push_back(site_list2);
 
-  filter_->SetFromSiteListsForTesting(site_lists);
-  filter_->SetDefaultFilteringBehavior(SupervisedUserURLFilter::BLOCK);
+  filter_.SetFromSiteListsForTesting(site_lists);
+  filter_.SetDefaultFilteringBehavior(SupervisedUserURLFilter::BLOCK);
   run_loop_.Run();
 
   std::map<std::string, base::string16> expected_whitelists;
   expected_whitelists[id1] = title1;
   expected_whitelists[id2] = title2;
 
   std::map<std::string, base::string16> actual_whitelists =
-      filter_->GetMatchingWhitelistTitles(GURL("https://example.com"));
+      filter_.GetMatchingWhitelistTitles(GURL("https://example.com"));
   ASSERT_EQ(expected_whitelists, actual_whitelists);
 
   expected_whitelists.erase(id2);
 
   actual_whitelists =
-      filter_->GetMatchingWhitelistTitles(GURL("https://google.com"));
+      filter_.GetMatchingWhitelistTitles(GURL("https://google.com"));
   ASSERT_EQ(expected_whitelists, actual_whitelists);
 }
 
 TEST_F(SupervisedUserURLFilterTest, WhitelistsHostnameHashes) {
   std::vector<std::string> patterns1;
   patterns1.push_back("google.com");
   patterns1.push_back("example.com");
 
   std::vector<std::string> patterns2;
   patterns2.push_back("secure.com");
@@ skipping 25 matching lines @@
                                  patterns2, hostname_hashes2));
   scoped_refptr<SupervisedUserSiteList> site_list3 = make_scoped_refptr(
       new SupervisedUserSiteList(id3, title3, entry_point, base::FilePath(),
                                  patterns3, hostname_hashes3));
 
   std::vector<scoped_refptr<SupervisedUserSiteList>> site_lists;
   site_lists.push_back(site_list1);
   site_lists.push_back(site_list2);
   site_lists.push_back(site_list3);
 
-  filter_->SetFromSiteListsForTesting(site_lists);
-  filter_->SetDefaultFilteringBehavior(SupervisedUserURLFilter::BLOCK);
+  filter_.SetFromSiteListsForTesting(site_lists);
+  filter_.SetDefaultFilteringBehavior(SupervisedUserURLFilter::BLOCK);
   run_loop_.Run();
 
   std::map<std::string, base::string16> expected_whitelists;
   expected_whitelists[id1] = title1;
   expected_whitelists[id2] = title2;
   expected_whitelists[id3] = title3;
 
   std::map<std::string, base::string16> actual_whitelists =
-      filter_->GetMatchingWhitelistTitles(GURL("http://example.com"));
+      filter_.GetMatchingWhitelistTitles(GURL("http://example.com"));
   ASSERT_EQ(expected_whitelists, actual_whitelists);
 
   expected_whitelists.erase(id1);
 
   actual_whitelists =
-      filter_->GetMatchingWhitelistTitles(GURL("https://secure.com"));
+      filter_.GetMatchingWhitelistTitles(GURL("https://secure.com"));
   ASSERT_EQ(expected_whitelists, actual_whitelists);
 }
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 TEST_F(SupervisedUserURLFilterTest, ChromeWebstoreDownloadsAreAlwaysAllowed) {
   // When installing an extension from Chrome Webstore, it tries to download the
   // crx file from "https://clients2.google.com/service/update2/", which
   // redirects to "https://clients2.googleusercontent.com/crx/blobs/"
   // or "https://chrome.google.com/webstore/download/".
   // All URLs should be whitelisted regardless from the default filtering
   // behavior.
   GURL crx_download_url1(
       "https://clients2.google.com/service/update2/"
       "crx?response=redirect&os=linux&arch=x64&nacl_arch=x86-64&prod="
       "chromiumcrx&prodchannel=&prodversion=55.0.2882.0&lang=en-US&x=id%"
       "3Dciniambnphakdoflgeamacamhfllbkmo%26installsource%3Dondemand%26uc");
   GURL crx_download_url2(
       "https://clients2.googleusercontent.com/crx/blobs/"
       "QgAAAC6zw0qH2DJtnXe8Z7rUJP1iCQF099oik9f2ErAYeFAX7_"
       "CIyrNH5qBru1lUSBNvzmjILCGwUjcIBaJqxgegSNy2melYqfodngLxKtHsGBehAMZSmuWSg6"
       "FupAcPS3Ih6NSVCOB9KNh6Mw/extension_2_0.crx");
   GURL crx_download_url3(
       "https://chrome.google.com/webstore/download/"
       "QgAAAC6zw0qH2DJtnXe8Z7rUJP1iCQF099oik9f2ErAYeFAX7_"
       "CIyrNH5qBru1lUSBNvzmjILCGwUjcIBaJqxgegSNy2melYqfodngLxKtHsGBehAMZSmuWSg6"
       "FupAcPS3Ih6NSVCOB9KNh6Mw/extension_2_0.crx");
 
-  filter_->SetDefaultFilteringBehavior(SupervisedUserURLFilter::BLOCK);
+  filter_.SetDefaultFilteringBehavior(SupervisedUserURLFilter::BLOCK);
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
-            filter_->GetFilteringBehaviorForURL(crx_download_url1));
+            filter_.GetFilteringBehaviorForURL(crx_download_url1));
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
-            filter_->GetFilteringBehaviorForURL(crx_download_url2));
+            filter_.GetFilteringBehaviorForURL(crx_download_url2));
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
-            filter_->GetFilteringBehaviorForURL(crx_download_url3));
+            filter_.GetFilteringBehaviorForURL(crx_download_url3));
 
   // Set explicit host rules to block those website, and make sure the
   // update URLs still work.
   std::map<std::string, bool> hosts;
   hosts["clients2.google.com"] = false;
   hosts["clients2.googleusercontent.com"] = false;
-  filter_->SetManualHosts(&hosts);
-  filter_->SetDefaultFilteringBehavior(SupervisedUserURLFilter::ALLOW);
+  filter_.SetManualHosts(std::move(hosts));
+  filter_.SetDefaultFilteringBehavior(SupervisedUserURLFilter::ALLOW);
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
-            filter_->GetFilteringBehaviorForURL(crx_download_url1));
+            filter_.GetFilteringBehaviorForURL(crx_download_url1));
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
-            filter_->GetFilteringBehaviorForURL(crx_download_url2));
+            filter_.GetFilteringBehaviorForURL(crx_download_url2));
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
-            filter_->GetFilteringBehaviorForURL(crx_download_url3));
+            filter_.GetFilteringBehaviorForURL(crx_download_url3));
 }
 #endif
 
 TEST_F(SupervisedUserURLFilterTest, GetEmbeddedURLAmpCache) {
   // Base case.
   EXPECT_EQ(GURL("http://example.com"),
             GetEmbeddedURL("https://cdn.ampproject.org/c/example.com"));
   // "s/" means "use https".
   EXPECT_EQ(GURL("https://example.com"),
             GetEmbeddedURL("https://cdn.ampproject.org/c/s/example.com"));
@@ skipping 149 matching lines @@
             GetEmbeddedURL(
                 "https://translate2.googleusercontent.com/path?u=example.com"));
   // Different TLD is not supported for googleusercontent.
   EXPECT_EQ(GURL(),
             GetEmbeddedURL(
                 "https://translate.googleusercontent.de/path?u=example.com"));
   // Query parameter ("u=...") is missing.
   EXPECT_EQ(GURL(),
             GetEmbeddedURL("https://translate.google.com/path?t=example.com"));
 }