Consolidate Origin- and RegistrableDomain- FilterBuilder into one class

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc

 // Copyright 2017 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/browsing_data/chrome_browsing_data_remover_delegate.h"
 
 #include "base/guid.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/browsing_data/browsing_data_filter_builder.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_impl.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
-#include "chrome/browser/browsing_data/registrable_domain_filter_builder.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/domain_reliability/service_factory.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/permissions/permission_decision_auto_blocker.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/storage/durable_storage_permission_context.h"
 #include "chrome/common/pref_names.h"
@@ skipping 826 matching lines @@
     remover_->RemoveAndReply(
         delete_begin, delete_end, remove_mask, origin_type_mask,
         &completion_observer);
     completion_observer.BlockUntilCompletion();
   }
 
   void BlockUntilOriginDataRemoved(
       const base::Time& delete_begin,
       const base::Time& delete_end,
       int remove_mask,
-      const BrowsingDataFilterBuilder& filter_builder) {
-    BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
-
-    // TODO(crbug.com/668114): ChromeBrowsingDataRemoverTest should not know
-    // about BrowsingDataRemoverImpl. We will be able to remove this cast once
-    // BrowsingDataFilterBuilder is copyable and comparable.
+      std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) {
+    BrowsingDataRemoverCompletionObserver completion_observer(remover_);
     static_cast<BrowsingDataRemoverImpl*>(remover_)
-        ->RemoveImpl(delete_begin, delete_end, remove_mask, filter_builder,
-                     BrowsingDataHelper::UNPROTECTED_WEB);
-    completion_inhibitor.BlockUntilNearCompletion();
-    completion_inhibitor.ContinueToCompletion();
+        ->RemoveWithFilterAndReply(delete_begin, delete_end, remove_mask,
+                                   BrowsingDataHelper::UNPROTECTED_WEB,
+                                   std::move(filter_builder),
+                                   &completion_observer);
+    completion_observer.BlockUntilCompletion();
   }
 
   const base::Time& GetBeginTime() {
     return remover_->GetLastUsedBeginTime();
   }
 
   int GetRemovalMask() {
     return remover_->GetLastUsedRemovalMask();
   }
 
@@ skipping 52 matching lines @@
   // browsing cookies.
   EXPECT_TRUE(tester.ContainsCookie());
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        RemoveSafeBrowsingCookieForeverWithPredicate) {
   RemoveSafeBrowsingCookieTester tester;
 
   tester.AddCookie();
   ASSERT_TRUE(tester.ContainsCookie());
-  RegistrableDomainFilterBuilder filter(
-      RegistrableDomainFilterBuilder::BLACKLIST);
-  filter.AddRegisterableDomain(kTestRegisterableDomain1);
+  std::unique_ptr<BrowsingDataFilterBuilder> filter(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
+  filter->AddRegisterableDomain(kTestRegisterableDomain1);
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_COOKIES, filter);
+                              BrowsingDataRemover::REMOVE_COOKIES,
+                              std::move(filter));
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_TRUE(tester.ContainsCookie());
 
-  RegistrableDomainFilterBuilder filter2(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  filter2.AddRegisterableDomain(kTestRegisterableDomain1);
+  std::unique_ptr<BrowsingDataFilterBuilder> filter2(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  filter2->AddRegisterableDomain(kTestRegisterableDomain1);
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_COOKIES, filter2);
+                              BrowsingDataRemover::REMOVE_COOKIES,
+                              std::move(filter2));
   EXPECT_FALSE(tester.ContainsCookie());
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryForever) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
 
@@ skipping 117 matching lines @@
   ASSERT_TRUE(favicon_tester.Init(GetProfile()));
   favicon_tester.VisitAndAddFavicon(bookmarked_page);
   ASSERT_TRUE(favicon_tester.HasFaviconForPageURL(bookmarked_page));
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_TRUE(favicon_tester.HasExpiredFaviconForPageURL(bookmarked_page));
 }
 
-TEST_F(ChromeBrowsingDataRemoverDelegateTest, TimeBasedHistoryRemoval) {
+// TODO(crbug.com/589586): Disabled, since history is not yet marked as
+// a filterable datatype.
+TEST_F(ChromeBrowsingDataRemoverDelegateTest,
+       DISABLED_TimeBasedHistoryRemoval) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
 
   base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   tester.AddHistory(kOrigin2, two_hours_ago);
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
 
-  RegistrableDomainFilterBuilder builder(
-      RegistrableDomainFilterBuilder::BLACKLIST);
+  std::unique_ptr<BrowsingDataFilterBuilder> builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
   BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_HISTORY, builder);
+                              BrowsingDataRemover::REMOVE_HISTORY,
+                              std::move(builder));
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
 }
 
 // Verify that clearing autofill form data works.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, AutofillRemovalLastHour) {
   GetProfile()->CreateWebDataService();
@@ skipping 104 matching lines @@
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter()));
 }
 
+// TODO(crbug.com/589586): Disabled, since history is not yet marked as
+// a filterable datatype.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
-       DomainReliability_Beacons_WithFilter) {
+       DISABLED_DomainReliability_Beacons_WithFilter) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
-  RegistrableDomainFilterBuilder builder(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  builder.AddRegisterableDomain(kTestRegisterableDomain1);
+  std::unique_ptr<BrowsingDataFilterBuilder> builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  builder->AddRegisterableDomain(kTestRegisterableDomain1);
 
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_HISTORY, builder);
+                              BrowsingDataRemover::REMOVE_HISTORY,
+                              builder->Copy());
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
-      builder.BuildGeneralFilter(), tester.last_filter()));
+      builder->BuildGeneralFilter(), tester.last_filter()));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_Contexts) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter()));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        DomainReliability_Contexts_WithFilter) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
-  RegistrableDomainFilterBuilder builder(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  builder.AddRegisterableDomain(kTestRegisterableDomain1);
+  std::unique_ptr<BrowsingDataFilterBuilder> builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  builder->AddRegisterableDomain(kTestRegisterableDomain1);
 
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_COOKIES, builder);
+                              BrowsingDataRemover::REMOVE_COOKIES,
+                              builder->Copy());
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
-      builder.BuildGeneralFilter(), tester.last_filter()));
+      builder->BuildGeneralFilter(), tester.last_filter()));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_ContextsWin) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(
       base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_HISTORY | BrowsingDataRemover::REMOVE_COOKIES,
       false);
@@ skipping 40 matching lines @@
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> empty_filter;
 
   EXPECT_CALL(*tester.store(), RemoveStatisticsByOriginAndTimeImpl(
                                    ProbablySameFilter(empty_filter),
                                    base::Time(), base::Time::Max()));
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
 }
 
+// TODO(crbug.com/589586): Disabled, since history is not yet marked as
+// a filterable datatype.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
-       RemovePasswordStatisticsByOrigin) {
+       DISABLED_RemovePasswordStatisticsByOrigin) {
   RemovePasswordsTester tester(GetProfile());
 
-  RegistrableDomainFilterBuilder builder(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  builder.AddRegisterableDomain(kTestRegisterableDomain1);
-  base::Callback<bool(const GURL&)> filter = builder.BuildGeneralFilter();
+  std::unique_ptr<BrowsingDataFilterBuilder> builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  builder->AddRegisterableDomain(kTestRegisterableDomain1);
+  base::Callback<bool(const GURL&)> filter = builder->BuildGeneralFilter();
 
   EXPECT_CALL(*tester.store(),
               RemoveStatisticsByOriginAndTimeImpl(
                   ProbablySameFilter(filter), base::Time(), base::Time::Max()));
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_HISTORY, builder);
+                              BrowsingDataRemover::REMOVE_HISTORY,
+                              std::move(builder));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemovePasswordsByTimeOnly) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(*tester.store(),
               RemoveLoginsByURLAndTimeImpl(ProbablySameFilter(filter), _, _))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_PASSWORDS, false);
 }
 
-TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemovePasswordsByOrigin) {
+// Disabled, since passwords are not yet marked as a filterable datatype.
+TEST_F(ChromeBrowsingDataRemoverDelegateTest,
+       DISABLED_RemovePasswordsByOrigin) {
   RemovePasswordsTester tester(GetProfile());
-  RegistrableDomainFilterBuilder builder(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  builder.AddRegisterableDomain(kTestRegisterableDomain1);
-  base::Callback<bool(const GURL&)> filter = builder.BuildGeneralFilter();
+  std::unique_ptr<BrowsingDataFilterBuilder> builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  builder->AddRegisterableDomain(kTestRegisterableDomain1);
+  base::Callback<bool(const GURL&)> filter = builder->BuildGeneralFilter();
 
   EXPECT_CALL(*tester.store(),
               RemoveLoginsByURLAndTimeImpl(ProbablySameFilter(filter), _, _))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_PASSWORDS, builder);
+                              BrowsingDataRemover::REMOVE_PASSWORDS,
+                              std::move(builder));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DisableAutoSignIn) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> empty_filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(
       *tester.store(),
       DisableAutoSignInForOriginsImpl(ProbablySameFilter(empty_filter)))
@@ skipping 34 matching lines @@
       kOrigin2, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin3, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin4, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
 
   // Clear all except for origin1 and origin3.
-  RegistrableDomainFilterBuilder filter(
-      RegistrableDomainFilterBuilder::BLACKLIST);
-  filter.AddRegisterableDomain(kTestRegisterableDomain1);
-  filter.AddRegisterableDomain(kTestRegisterableDomain3);
+  std::unique_ptr<BrowsingDataFilterBuilder> filter(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
+  filter->AddRegisterableDomain(kTestRegisterableDomain1);
+  filter->AddRegisterableDomain(kTestRegisterableDomain3);
   BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
-                              filter);
+                              std::move(filter));
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_USAGE_DATA, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify we only have true, and they're origin1, origin3, and origin4.
   ContentSettingsForOneType host_settings;
   host_content_settings_map->GetSettingsForOneType(
       CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(), &host_settings);
   EXPECT_EQ(3u, host_settings.size());
   EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin1),
@@ skipping 12 matching lines @@
   HostContentSettingsMap* host_content_settings_map =
       HostContentSettingsMapFactory::GetForProfile(GetProfile());
 
   DurableStoragePermissionContext durable_permission(GetProfile());
   durable_permission.UpdateContentSetting(kOrigin1, GURL(),
                                           CONTENT_SETTING_ALLOW);
   durable_permission.UpdateContentSetting(kOrigin2, GURL(),
                                           CONTENT_SETTING_ALLOW);
 
   // Clear all except for origin1 and origin3.
-  RegistrableDomainFilterBuilder filter(
-      RegistrableDomainFilterBuilder::BLACKLIST);
-  filter.AddRegisterableDomain(kTestRegisterableDomain1);
-  filter.AddRegisterableDomain(kTestRegisterableDomain3);
+  std::unique_ptr<BrowsingDataFilterBuilder> filter(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
+  filter->AddRegisterableDomain(kTestRegisterableDomain1);
+  filter->AddRegisterableDomain(kTestRegisterableDomain3);
   BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_DURABLE_PERMISSION,
-                              filter);
+                              std::move(filter));
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_DURABLE_PERMISSION, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify we only have allow for the first origin.
   ContentSettingsForOneType host_settings;
   host_content_settings_map->GetSettingsForOneType(
       CONTENT_SETTINGS_TYPE_DURABLE_STORAGE, std::string(), &host_settings);
 
   ASSERT_EQ(2u, host_settings.size());
@@ skipping 32 matching lines @@
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_PASSWORDS, false);
 
   EXPECT_EQ(nullptr, http_auth_cache->Lookup(kOrigin1, kTestRealm,
                                              net::HttpAuth::AUTH_SCHEME_BASIC));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, ClearPermissionPromptCounts) {
   RemovePermissionPromptCountsTest tester(GetProfile());
 
-  RegistrableDomainFilterBuilder filter_builder_1(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  filter_builder_1.AddRegisterableDomain(kTestRegisterableDomain1);
+  std::unique_ptr<BrowsingDataFilterBuilder> filter_builder_1(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  filter_builder_1->AddRegisterableDomain(kTestRegisterableDomain1);
 
-  RegistrableDomainFilterBuilder filter_builder_2(
-      RegistrableDomainFilterBuilder::BLACKLIST);
-  filter_builder_2.AddRegisterableDomain(kTestRegisterableDomain1);
+  std::unique_ptr<BrowsingDataFilterBuilder> filter_builder_2(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
+  filter_builder_2->AddRegisterableDomain(kTestRegisterableDomain1);
 
   {
     // Test REMOVE_HISTORY.
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin1,
                                      content::PermissionType::GEOLOCATION));
     EXPECT_EQ(2, tester.RecordIgnore(kOrigin1,
                                      content::PermissionType::GEOLOCATION));
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin1,
                                      content::PermissionType::NOTIFICATIONS));
     tester.ShouldChangeDismissalToBlock(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX);
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin2,
                                      content::PermissionType::DURABLE_STORAGE));
     tester.ShouldChangeDismissalToBlock(kOrigin2,
                                         content::PermissionType::NOTIFICATIONS);
 
     BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
-                                filter_builder_1);
+                                std::move(filter_builder_1));
 
     // kOrigin1 should be gone, but kOrigin2 remains.
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::GEOLOCATION));
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::NOTIFICATIONS));
     EXPECT_EQ(0, tester.GetDismissCount(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX));
     EXPECT_EQ(1, tester.GetIgnoreCount(
                      kOrigin2, content::PermissionType::DURABLE_STORAGE));
@@ skipping 25 matching lines @@
                                      content::PermissionType::NOTIFICATIONS));
     tester.ShouldChangeDismissalToBlock(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX);
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin2,
                                      content::PermissionType::DURABLE_STORAGE));
     tester.ShouldChangeDismissalToBlock(kOrigin2,
                                         content::PermissionType::NOTIFICATIONS);
 
     BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
-                                filter_builder_2);
+                                std::move(filter_builder_2));
 
     // kOrigin2 should be gone, but kOrigin1 remains.
     EXPECT_EQ(2, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::GEOLOCATION));
     EXPECT_EQ(1, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::NOTIFICATIONS));
     EXPECT_EQ(1, tester.GetDismissCount(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX));
     EXPECT_EQ(0, tester.GetIgnoreCount(
                      kOrigin2, content::PermissionType::DURABLE_STORAGE));
@@ skipping 24 matching lines @@
 
   tester.AddDomain(kOrigin1.host());
   tester.AddDomain(kOrigin2.host());
   tester.AddDomain(kOrigin3.host());
 
   std::vector<std::string> expected = {
       kOrigin1.host(), kOrigin2.host(), kOrigin3.host() };
   EXPECT_EQ(expected, tester.GetDomains());
 
   // Delete data with a filter for the registrable domain of |kOrigin3|.
-  RegistrableDomainFilterBuilder filter_builder(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  filter_builder.AddRegisterableDomain(kTestRegisterableDomain3);
+  std::unique_ptr<BrowsingDataFilterBuilder> filter_builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  filter_builder->AddRegisterableDomain(kTestRegisterableDomain3);
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_PLUGIN_DATA,
-                              filter_builder);
+                              std::move(filter_builder));
 
   // Plugin data for |kOrigin3.host()| should have been removed.
   expected.pop_back();
   EXPECT_EQ(expected, tester.GetDomains());
 
   // TODO(msramek): Mock PluginDataRemover and test the complete deletion
   // of plugin data as well.
 }
 #endif
 
@@ skipping 54 matching lines @@
   completion_observer.BlockUntilCompletion();
 
   // There should be only 1 recently visited bookmarks.
   std::vector<const bookmarks::BookmarkNode*> remaining_nodes =
       ntp_snippets::GetRecentlyVisitedBookmarks(
           bookmark_model, 3, base::Time::UnixEpoch(),
           /*consider_visits_from_desktop=*/true);
   EXPECT_THAT(remaining_nodes, SizeIs(1));
   EXPECT_THAT(remaining_nodes[0]->url().spec(), Eq("http://foo-2.org/"));
 }