Consolidate Origin- and RegistrableDomain- FilterBuilder into one class

chrome/browser/browsing_data/browsing_data_remover_impl_unittest.cc

 // Copyright 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 #include <set>
@@ skipping 15 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.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/registrable_domain_filter_builder.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
@@ skipping 533 matching lines @@
 
     // Save so we can verify later.
     storage_partition_removal_data_ =
         storage_partition.GetStoragePartitionRemovalData();
   }
 
   void BlockUntilOriginDataRemoved(
       const base::Time& delete_begin,
       const base::Time& delete_end,
       int remove_mask,
-      const BrowsingDataFilterBuilder& filter_builder) {
+      std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) {
     TestStoragePartition storage_partition;
     remover_->OverrideStoragePartitionForTesting(&storage_partition);
 
-    BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
-    remover_->RemoveImpl(delete_begin, delete_end, remove_mask, filter_builder,
-                         BrowsingDataHelper::UNPROTECTED_WEB);
-    completion_inhibitor.BlockUntilNearCompletion();
-    completion_inhibitor.ContinueToCompletion();
+    BrowsingDataRemoverCompletionObserver completion_observer(remover_);
+    remover_->RemoveWithFilterAndReply(
+        delete_begin, delete_end, remove_mask,
+        BrowsingDataHelper::UNPROTECTED_WEB,
+        std::move(filter_builder), &completion_observer);
+    completion_observer.BlockUntilCompletion();
 
     // Save so we can verify later.
     storage_partition_removal_data_ =
         storage_partition.GetStoragePartitionRemovalData();
   }
 
   BrowserContext* GetBrowserContext() {
     return browser_context_.get();
   }
 
@@ skipping 89 matching lines @@
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_COOKIES);
   // Removing with time period other than all time should not clear
   // persistent storage data.
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveCookiesDomainBlacklist) {
-  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_COOKIES, filter);
+                              BrowsingDataRemover::REMOVE_COOKIES,
+                              std::move(filter));
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the cookies.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_COOKIES);
   // Removing with time period other than all time should not clear
   // persistent storage data.
@@ skipping 79 matching lines @@
   EXPECT_EQ(kTestOrigin2, channel_ids.front().server_identifier());
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveChannelIDsForServerIdentifiers) {
   RemoveChannelIDTester tester(GetBrowserContext());
 
   tester.AddChannelID(kTestRegisterableDomain1);
   tester.AddChannelID(kTestRegisterableDomain3);
   EXPECT_EQ(2, tester.ChannelIDCount());
 
-  RegistrableDomainFilterBuilder filter_builder(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  filter_builder.AddRegisterableDomain(kTestRegisterableDomain1);
+  std::unique_ptr<BrowsingDataFilterBuilder> filter_builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  filter_builder->AddRegisterableDomain(kTestRegisterableDomain1);
 
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_CHANNEL_IDS,
-                              filter_builder);
+                              std::move(filter_builder));
 
   EXPECT_EQ(1, tester.ChannelIDCount());
   net::ChannelIDStore::ChannelIDList channel_ids;
   tester.GetChannelIDList(&channel_ids);
   EXPECT_EQ(kTestRegisterableDomain3, channel_ids.front().server_identifier());
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveUnprotectedLocalStorageForever) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
@@ skipping 270 matching lines @@
 
   // Check that all related origin data would be removed, that is, origin
   // matcher would match these origin.
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverImplTest,
        RemoveQuotaManagedDataForeverSpecificOrigin) {
-  RegistrableDomainFilterBuilder builder(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  builder.AddRegisterableDomain(kTestRegisterableDomain1);
+  std::unique_ptr<BrowsingDataFilterBuilder> builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  builder->AddRegisterableDomain(kTestRegisterableDomain1);
   // Remove Origin 1.
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_APPCACHE |
                                   BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
                                   BrowsingDataRemover::REMOVE_CACHE_STORAGE |
                                   BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                                   BrowsingDataRemover::REMOVE_INDEXEDDB |
                                   BrowsingDataRemover::REMOVE_WEBSQL,
-                              builder);
+                              std::move(builder));
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
                 BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
                 BrowsingDataRemover::REMOVE_CACHE_STORAGE |
                 BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_INDEXEDDB |
                 BrowsingDataRemover::REMOVE_WEBSQL,
             GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
@@ skipping 141 matching lines @@
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedProtectedSpecificOrigin) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
-  RegistrableDomainFilterBuilder builder(
-      RegistrableDomainFilterBuilder::WHITELIST);
-  builder.AddRegisterableDomain(kTestRegisterableDomain1);
+  std::unique_ptr<BrowsingDataFilterBuilder> builder(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  builder->AddRegisterableDomain(kTestRegisterableDomain1);
 
   // Try to remove kOrigin1. Expect failure.
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_APPCACHE |
                                   BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
                                   BrowsingDataRemover::REMOVE_CACHE_STORAGE |
                                   BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                                   BrowsingDataRemover::REMOVE_INDEXEDDB |
                                   BrowsingDataRemover::REMOVE_WEBSQL,
-                              builder);
+                              std::move(builder));
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
                 BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
                 BrowsingDataRemover::REMOVE_CACHE_STORAGE |
                 BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_INDEXEDDB |
                 BrowsingDataRemover::REMOVE_WEBSQL,
             GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
@@ skipping 198 matching lines @@
   EXPECT_CALL(
       *tester.download_manager(),
       RemoveDownloadsByURLAndTime(ProbablySameFilter(filter), _, _));
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_DOWNLOADS, false);
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveDownloadsByOrigin) {
   RemoveDownloadsTester tester(GetBrowserContext());
-  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.download_manager(),
       RemoveDownloadsByURLAndTime(ProbablySameFilter(filter), _, _));
 
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_DOWNLOADS, builder);
+                              BrowsingDataRemover::REMOVE_DOWNLOADS,
+                              std::move(builder));
 }
 
 class MultipleTasksObserver {
  public:
   // A simple implementation of BrowsingDataRemover::Observer.
   // MultipleTasksObserver will use several instances of Target to test
   // that completion callbacks are returned to the correct one.
   class Target : public BrowsingDataRemover::Observer {
    public:
     Target(MultipleTasksObserver* parent, BrowsingDataRemover* remover)
@@ skipping 40 matching lines @@
   Target target_a_;
   Target target_b_;
   Target* last_called_target_;
 };
 
 TEST_F(BrowsingDataRemoverImplTest, MultipleTasks) {
   BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>(
       BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext()));
   EXPECT_FALSE(remover->is_removing());
 
-  std::unique_ptr<RegistrableDomainFilterBuilder> filter_builder_1(
-      new RegistrableDomainFilterBuilder(
-          RegistrableDomainFilterBuilder::WHITELIST));
-  std::unique_ptr<RegistrableDomainFilterBuilder> filter_builder_2(
-      new RegistrableDomainFilterBuilder(
-          RegistrableDomainFilterBuilder::BLACKLIST));
+  std::unique_ptr<BrowsingDataFilterBuilder> filter_builder_1(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
+  std::unique_ptr<BrowsingDataFilterBuilder> filter_builder_2(
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
   filter_builder_2->AddRegisterableDomain("example.com");
 
   MultipleTasksObserver observer(remover);
   BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
 
   // Test several tasks with various configuration of masks, filters, and target
   // observers.
   std::list<BrowsingDataRemoverImpl::RemovalTask> tasks;
   tasks.emplace_back(base::Time(), base::Time::Max(),
                      BrowsingDataRemover::REMOVE_HISTORY,
                      BrowsingDataHelper::UNPROTECTED_WEB,
-                     base::MakeUnique<RegistrableDomainFilterBuilder>(
-                         RegistrableDomainFilterBuilder::BLACKLIST),
+                     BrowsingDataFilterBuilder::Create(
+                         BrowsingDataFilterBuilder::BLACKLIST),
                      observer.target_a());
   tasks.emplace_back(base::Time(), base::Time::Max(),
                      BrowsingDataRemover::REMOVE_COOKIES,
                      BrowsingDataHelper::PROTECTED_WEB,
-                     base::MakeUnique<RegistrableDomainFilterBuilder>(
-                         RegistrableDomainFilterBuilder::BLACKLIST),
+                     BrowsingDataFilterBuilder::Create(
+                         BrowsingDataFilterBuilder::BLACKLIST),
                      nullptr);
   tasks.emplace_back(
       base::Time::Now(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_PASSWORDS, BrowsingDataHelper::ALL,
-      base::MakeUnique<RegistrableDomainFilterBuilder>(
-          RegistrableDomainFilterBuilder::BLACKLIST),
+      BrowsingDataFilterBuilder::Create(
+          BrowsingDataFilterBuilder::BLACKLIST),
       observer.target_b());
   tasks.emplace_back(
       base::Time(), base::Time::UnixEpoch(),
       BrowsingDataRemover::REMOVE_WEBSQL,
       BrowsingDataHelper::UNPROTECTED_WEB,
       std::move(filter_builder_1),
       observer.target_b());
   tasks.emplace_back(
       base::Time::UnixEpoch(), base::Time::Now(),
       BrowsingDataRemover::REMOVE_CHANNEL_IDS,
@@ skipping 84 matching lines @@
   EXPECT_TRUE(remover->is_removing());
 
   // Add one more deletion and wait for it.
   BlockUntilBrowsingDataRemoved(
       base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_COOKIES,
       BrowsingDataHelper::UNPROTECTED_WEB);
 
   EXPECT_FALSE(remover->is_removing());
 }