Convert RemoveDataMask from enum to pointers and split it between content and embedder

chrome/browser/browsing_data/browsing_data_remover_impl_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 <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 #include <set>
@@ skipping 49 matching lines @@
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/mock_extension_special_storage_policy.h"
 #endif
 
 class MockExtensionSpecialStoragePolicy;
 
 using content::BrowserThread;
 using content::BrowserContext;
 using content::BrowsingDataFilterBuilder;
+using content::BrowsingDataType;
 using content::StoragePartition;
 using testing::_;
 using testing::ByRef;
 using testing::Eq;
 using testing::Invoke;
 using testing::IsEmpty;
 using testing::Matcher;
 using testing::MakeMatcher;
 using testing::MatcherInterface;
 using testing::MatchResultListener;
@@ skipping 221 matching lines @@
 
 inline Matcher<const base::Callback<bool(const GURL&)>&> ProbablySameFilter(
     const base::Callback<bool(const GURL&)>& filter) {
   return MakeMatcher(new ProbablySameFilterMatcher(filter));
 }
 
 base::Time AnHourAgo() {
   return base::Time::Now() - base::TimeDelta::FromHours(1);
 }
 
+const std::set<const BrowsingDataType*> kQuotaMask = {
+    &content::kBrowsingDataTypeFileSystems,
+    &content::kBrowsingDataTypeWebSQL,
+    &content::kBrowsingDataTypeAppCache,
+    &content::kBrowsingDataTypeServiceWorkers,
+    &content::kBrowsingDataTypeCacheStorage,
+    &content::kBrowsingDataTypeIndexedDB};
+
+// A wrapper to typecast a const initializer to std::set in ambiguous
+// situations, such as the EXPECT macros.
+inline const std::set<const BrowsingDataType*> Mask(
+    const std::set<const BrowsingDataType*> mask) {
+  return mask;
+}
+
 }  // namespace
 
 // Testers -------------------------------------------------------------------
 
 class RemoveCookieTester {
  public:
   RemoveCookieTester() {}
 
   // Returns true, if the given cookie exists in the cookie store.
   bool ContainsCookie() {
@@ skipping 235 matching lines @@
 
     // BrowserContext contains a DOMStorageContext. BrowserContext's
     // destructor posts a message to the WEBKIT thread to delete some of its
     // member variables. We need to ensure that the browser context is
     // destroyed, and that the message loop is cleared out, before destroying
     // the threads and loop. Otherwise we leak memory.
     browser_context_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
-  void BlockUntilBrowsingDataRemoved(const base::Time& delete_begin,
-                                     const base::Time& delete_end,
-                                     int remove_mask,
-                                     bool include_protected_origins) {
+  void BlockUntilBrowsingDataRemoved(
+      const base::Time& delete_begin,
+      const base::Time& delete_end,
+      const std::set<const BrowsingDataType*> remove_mask,
+      bool include_protected_origins) {
     TestStoragePartition storage_partition;
     remover_->OverrideStoragePartitionForTesting(&storage_partition);
 
     int origin_type_mask = BrowsingDataHelper::UNPROTECTED_WEB;
     if (include_protected_origins)
       origin_type_mask |= BrowsingDataHelper::PROTECTED_WEB;
 
     BrowsingDataRemoverCompletionObserver completion_observer(remover_);
     remover_->RemoveAndReply(
         delete_begin, delete_end, remove_mask, origin_type_mask,
         &completion_observer);
     completion_observer.BlockUntilCompletion();
 
     // 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 std::set<const BrowsingDataType*> remove_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) {
     TestStoragePartition storage_partition;
     remover_->OverrideStoragePartitionForTesting(&storage_partition);
 
     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();
   }
 
   void DestroyBrowserContext() { browser_context_.reset(); }
 
   const base::Time& GetBeginTime() {
     return remover_->GetLastUsedBeginTime();
   }
 
-  int GetRemovalMask() {
+  const std::set<const content::BrowsingDataType*>& GetRemovalMask() {
     return remover_->GetLastUsedRemovalMask();
   }
 
   int GetOriginTypeMask() {
     return remover_->GetLastUsedOriginTypeMask();
   }
 
   StoragePartitionRemovalData GetStoragePartitionRemovalData() {
     return storage_partition_removal_data_;
   }
@@ skipping 39 matching lines @@
   scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverImplTest);
 };
 
 // Tests ---------------------------------------------------------------------
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveCookieForever) {
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_COOKIES, false);
+                                Mask({&content::kBrowsingDataTypeCookies}),
+                                false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
+  EXPECT_EQ(Mask({&content::kBrowsingDataTypeCookies}), 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);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveCookieLastHour) {
   BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_COOKIES, false);
+                                Mask({&content::kBrowsingDataTypeCookies}),
+                                false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
+  EXPECT_EQ(Mask({&content::kBrowsingDataTypeCookies}), 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.
   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) {
   std::unique_ptr<BrowsingDataFilterBuilder> filter(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
   filter->AddRegisterableDomain(kTestRegisterableDomain1);
   filter->AddRegisterableDomain(kTestRegisterableDomain3);
   BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_COOKIES,
+                              {&content::kBrowsingDataTypeCookies},
                               std::move(filter));
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
+  EXPECT_EQ(Mask({&content::kBrowsingDataTypeCookies}), 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.
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT);
@@ skipping 25 matching lines @@
   net::HttpAuthCache* http_auth_cache = http_session->http_auth_cache();
   http_auth_cache->Add(kOrigin1, kTestRealm, net::HttpAuth::AUTH_SCHEME_BASIC,
                        "test challenge",
                        net::AuthCredentials(base::ASCIIToUTF16("foo"),
                                             base::ASCIIToUTF16("bar")),
                        "/");
   CHECK(http_auth_cache->Lookup(kOrigin1, kTestRealm,
                                 net::HttpAuth::AUTH_SCHEME_BASIC));
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_COOKIES, false);
+                                {&content::kBrowsingDataTypeCookies}, false);
 
   EXPECT_EQ(nullptr, http_auth_cache->Lookup(kOrigin1, kTestRealm,
                                              net::HttpAuth::AUTH_SCHEME_BASIC));
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveChannelIDForever) {
   RemoveChannelIDTester tester(GetBrowserContext());
 
   tester.AddChannelID(kTestOrigin1);
   EXPECT_EQ(0, tester.ssl_config_changed_count());
   EXPECT_EQ(1, tester.ChannelIDCount());
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_CHANNEL_IDS, false);
+                                {&content::kBrowsingDataTypeChannelIDs}, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_CHANNEL_IDS, GetRemovalMask());
+  EXPECT_EQ(Mask({&content::kBrowsingDataTypeChannelIDs}), GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_EQ(1, tester.ssl_config_changed_count());
   EXPECT_EQ(0, tester.ChannelIDCount());
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveChannelIDLastHour) {
   RemoveChannelIDTester tester(GetBrowserContext());
 
   base::Time now = base::Time::Now();
   tester.AddChannelID(kTestOrigin1);
   tester.AddChannelIDWithTimes(kTestOrigin2,
                                now - base::TimeDelta::FromHours(2));
   EXPECT_EQ(0, tester.ssl_config_changed_count());
   EXPECT_EQ(2, tester.ChannelIDCount());
 
   BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_CHANNEL_IDS, false);
+                                {&content::kBrowsingDataTypeChannelIDs}, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_CHANNEL_IDS, GetRemovalMask());
+  EXPECT_EQ(Mask({&content::kBrowsingDataTypeChannelIDs}), GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_EQ(1, tester.ssl_config_changed_count());
   ASSERT_EQ(1, tester.ChannelIDCount());
   net::ChannelIDStore::ChannelIDList channel_ids;
   tester.GetChannelIDList(&channel_ids);
   ASSERT_EQ(1U, channel_ids.size());
   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());
 
   std::unique_ptr<BrowsingDataFilterBuilder> filter_builder(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
   filter_builder->AddRegisterableDomain(kTestRegisterableDomain1);
 
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_CHANNEL_IDS,
+                              {&content::kBrowsingDataTypeChannelIDs},
                               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();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
+                                {&content::kBrowsingDataTypeLocalStorage},
                                 false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
+  EXPECT_EQ(Mask({&content::kBrowsingDataTypeLocalStorage}), GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the data correctly.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 
   // Check origin matcher.
   EXPECT_EQ(ShouldRemoveForProtectedOriginOne(),
             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()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveProtectedLocalStorageForever) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   // Protect kOrigin1.
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
+                                {&content::kBrowsingDataTypeLocalStorage},
                                 true);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
+  EXPECT_EQ(Mask({&content::kBrowsingDataTypeLocalStorage}), GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB |
             BrowsingDataHelper::PROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the data correctly.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 
   // Check origin matcher all http origin will match since we specified
   // both protected and unprotected.
   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()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveLocalStorageForLastWeek) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
   BlockUntilBrowsingDataRemoved(
       base::Time::Now() - base::TimeDelta::FromDays(7), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_LOCAL_STORAGE, false);
+      {&content::kBrowsingDataTypeLocalStorage}, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
+  EXPECT_EQ(Mask({&content::kBrowsingDataTypeLocalStorage}), GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the data correctly.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE);
   // Persistent storage won't be deleted.
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 
   // Check origin matcher.
   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()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveMultipleTypes) {
   // Downloads should be deleted through the DownloadManager, assure it would
   // be called.
   RemoveDownloadsTester downloads_tester(GetBrowserContext());
   EXPECT_CALL(*downloads_tester.download_manager(),
               RemoveDownloadsByURLAndTime(_, _, _));
 
-  int removal_mask = BrowsingDataRemover::REMOVE_DOWNLOADS |
-                     BrowsingDataRemover::REMOVE_COOKIES;
+  std::set<const BrowsingDataType*> removal_mask = {
+      &content::kBrowsingDataTypeDownloads, &content::kBrowsingDataTypeCookies};
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 removal_mask, false);
 
   EXPECT_EQ(removal_mask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // The cookie would be deleted throught the StorageParition, check if the
   // partition was requested to remove cookie.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_COOKIES);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForeverBoth) {
-  BlockUntilBrowsingDataRemoved(
-      base::Time(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-          BrowsingDataRemover::REMOVE_WEBSQL |
-          BrowsingDataRemover::REMOVE_APPCACHE |
-          BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-          BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-          BrowsingDataRemover::REMOVE_INDEXEDDB,
-      false);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask,
+                                false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
-            GetRemovalMask());
+  EXPECT_EQ(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
                 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
                 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
 }
 
 TEST_F(BrowsingDataRemoverImplTest,
        RemoveQuotaManagedDataForeverOnlyTemporary) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
-  BlockUntilBrowsingDataRemoved(
-      base::Time(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-          BrowsingDataRemover::REMOVE_WEBSQL |
-          BrowsingDataRemover::REMOVE_APPCACHE |
-          BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-          BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-          BrowsingDataRemover::REMOVE_INDEXEDDB,
-      false);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask,
+                                false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
-            GetRemovalMask());
+  EXPECT_EQ(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
                 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
                 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
 
   // 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,
        RemoveQuotaManagedDataForeverOnlyPersistent) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
-  BlockUntilBrowsingDataRemoved(
-      base::Time(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-          BrowsingDataRemover::REMOVE_WEBSQL |
-          BrowsingDataRemover::REMOVE_APPCACHE |
-          BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-          BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-          BrowsingDataRemover::REMOVE_INDEXEDDB,
-      false);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask,
+                                false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
-            GetRemovalMask());
+  EXPECT_EQ(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
                 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
                 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
 
   // 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, RemoveQuotaManagedDataForeverNeither) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
-  BlockUntilBrowsingDataRemoved(
-      base::Time(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-          BrowsingDataRemover::REMOVE_WEBSQL |
-          BrowsingDataRemover::REMOVE_APPCACHE |
-          BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-          BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-          BrowsingDataRemover::REMOVE_INDEXEDDB,
-      false);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask,
+                                false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
-            GetRemovalMask());
+  EXPECT_EQ(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
                 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
                 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
 
   // 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) {
   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,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), kQuotaMask,
                               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(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
                 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
                 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin4, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForLastHour) {
-  BlockUntilBrowsingDataRemoved(
-      AnHourAgo(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-          BrowsingDataRemover::REMOVE_WEBSQL |
-          BrowsingDataRemover::REMOVE_APPCACHE |
-          BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-          BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-          BrowsingDataRemover::REMOVE_INDEXEDDB,
-      false);
+  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), kQuotaMask,
+                                false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
-            GetRemovalMask());
+  EXPECT_EQ(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
                 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
                 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
 
   // Persistent data would be left out since we are not removing from
   // beginning of time.
   uint32_t expected_quota_mask =
       ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
   EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask);
   // Check removal begin time.
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForLastWeek) {
   BlockUntilBrowsingDataRemoved(
       base::Time::Now() - base::TimeDelta::FromDays(7), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-          BrowsingDataRemover::REMOVE_WEBSQL |
-          BrowsingDataRemover::REMOVE_APPCACHE |
-          BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-          BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-          BrowsingDataRemover::REMOVE_INDEXEDDB,
-      false);
+      kQuotaMask, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
-            GetRemovalMask());
+  EXPECT_EQ(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
                 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
                 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
 
   // Persistent data would be left out since we are not removing from
   // beginning of time.
   uint32_t expected_quota_mask =
       ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
   EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask);
   // Check removal begin time.
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedUnprotectedOrigins) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
-  BlockUntilBrowsingDataRemoved(
-      base::Time(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-          BrowsingDataRemover::REMOVE_WEBSQL |
-          BrowsingDataRemover::REMOVE_APPCACHE |
-          BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-          BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-          BrowsingDataRemover::REMOVE_INDEXEDDB,
-      false);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask,
+                                false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
-            GetRemovalMask());
+  EXPECT_EQ(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
@@ skipping 14 matching lines @@
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
   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,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), kQuotaMask,
                               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(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
@@ skipping 12 matching lines @@
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedProtectedOrigins) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
   // Try to remove kOrigin1. Expect success.
-  BlockUntilBrowsingDataRemoved(
-      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,
-      true);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask,
+                                true);
 
-  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(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::PROTECTED_WEB |
       BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
                 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
                 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
 
   // Check OriginMatcherFunction, |kOrigin1| would match mask since we
   // would have 'protected' specified in origin_type_mask.
   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,
        RemoveQuotaManagedIgnoreExtensionsAndDevTools) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
-  BlockUntilBrowsingDataRemoved(
-      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,
-      false);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask,
+                                false);
 
-  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(kQuotaMask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify storage partition related stuffs.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
 
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
                 StoragePartition::REMOVE_DATA_MASK_WEBSQL |
                 StoragePartition::REMOVE_DATA_MASK_APPCACHE |
                 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
@@ skipping 28 matching lines @@
 };
 
 TEST_F(BrowsingDataRemoverImplTest, CompletionInhibition) {
   // The |completion_inhibitor| on the stack should prevent removal sessions
   // from completing until after ContinueToCompletion() is called.
   BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
 
   BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>(
       BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext()));
   InspectableCompletionObserver completion_observer(remover);
-  remover->RemoveAndReply(base::Time(), base::Time::Max(),
-                          BrowsingDataRemover::REMOVE_HISTORY,
-                          BrowsingDataHelper::UNPROTECTED_WEB,
-                          &completion_observer);
+  remover->RemoveAndReply(
+      base::Time(), base::Time::Max(), {&content::kBrowsingDataTypeCookies},
+      BrowsingDataHelper::UNPROTECTED_WEB, &completion_observer);
 
   // Process messages until the inhibitor is notified, and then some, to make
   // sure we do not complete asynchronously before ContinueToCompletion() is
   // called.
   completion_inhibitor.BlockUntilNearCompletion();
   base::RunLoop().RunUntilIdle();
 
   // Verify that the removal has not yet been completed and the observer has
   // not been called.
   EXPECT_TRUE(remover->is_removing());
   EXPECT_FALSE(completion_observer.called());
 
   // Now run the removal process until completion, and verify that observers are
   // now notified, and the notifications is sent out.
   completion_inhibitor.ContinueToCompletion();
   completion_observer.BlockUntilCompletion();
 
   EXPECT_FALSE(remover->is_removing());
   EXPECT_TRUE(completion_observer.called());
 }
 
 TEST_F(BrowsingDataRemoverImplTest, EarlyShutdown) {
   BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>(
       BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext()));
   InspectableCompletionObserver completion_observer(remover);
   BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
-  remover->RemoveAndReply(base::Time(), base::Time::Max(),
-                          BrowsingDataRemover::REMOVE_HISTORY,
-                          BrowsingDataHelper::UNPROTECTED_WEB,
-                          &completion_observer);
+  remover->RemoveAndReply(
+      base::Time(), base::Time::Max(), {&content::kBrowsingDataTypeCookies},
+      BrowsingDataHelper::UNPROTECTED_WEB, &completion_observer);
 
   completion_inhibitor.BlockUntilNearCompletion();
 
   // Verify that the deletion has not yet been completed and the observer has
   // not been called.
   EXPECT_TRUE(remover->is_removing());
   EXPECT_FALSE(completion_observer.called());
 
   // Destroying the profile should trigger the notification.
   DestroyBrowserContext();
 
   EXPECT_TRUE(completion_observer.called());
 
   // Finishing after shutdown shouldn't break anything.
   completion_inhibitor.ContinueToCompletion();
   completion_observer.BlockUntilCompletion();
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveDownloadsByTimeOnly) {
   RemoveDownloadsTester tester(GetBrowserContext());
   base::Callback<bool(const GURL&)> filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(
       *tester.download_manager(),
       RemoveDownloadsByURLAndTime(ProbablySameFilter(filter), _, _));
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_DOWNLOADS, false);
+                                {&content::kBrowsingDataTypeDownloads}, false);
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveDownloadsByOrigin) {
   RemoveDownloadsTester tester(GetBrowserContext());
   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,
+                              {&content::kBrowsingDataTypeDownloads},
                               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:
@@ skipping 53 matching lines @@
   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,
-                     BrowsingDataFilterBuilder::Create(
-                         BrowsingDataFilterBuilder::BLACKLIST),
-                     observer.target_a());
-  tasks.emplace_back(base::Time(), base::Time::Max(),
-                     BrowsingDataRemover::REMOVE_COOKIES,
-                     BrowsingDataHelper::PROTECTED_WEB,
-                     BrowsingDataFilterBuilder::Create(
-                         BrowsingDataFilterBuilder::BLACKLIST),
-                     nullptr);
+  tasks.emplace_back(
+      base::Time(), base::Time::Max(),
+      Mask({&content::kBrowsingDataTypeCookies}),
+      BrowsingDataHelper::UNPROTECTED_WEB,
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST),
+      observer.target_a());
+  tasks.emplace_back(
+      base::Time(), base::Time::Max(),
+      Mask({&content::kBrowsingDataTypeCookies}),
+      BrowsingDataHelper::PROTECTED_WEB,
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST),
+      nullptr);
   tasks.emplace_back(
       base::Time::Now(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_PASSWORDS, BrowsingDataHelper::ALL,
-      BrowsingDataFilterBuilder::Create(
-          BrowsingDataFilterBuilder::BLACKLIST),
+      Mask({&content::kBrowsingDataTypeDownloads}), BrowsingDataHelper::ALL,
+      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,
-      BrowsingDataHelper::ALL,
-      std::move(filter_builder_2),
-      nullptr);
+  tasks.emplace_back(base::Time(), base::Time::UnixEpoch(),
+                     Mask({&content::kBrowsingDataTypeWebSQL}),
+                     BrowsingDataHelper::UNPROTECTED_WEB,
+                     std::move(filter_builder_1), observer.target_b());
+  tasks.emplace_back(base::Time::UnixEpoch(), base::Time::Now(),
+                     Mask({&content::kBrowsingDataTypeChannelIDs}),
+                     BrowsingDataHelper::ALL, std::move(filter_builder_2),
+                     nullptr);
 
   for (BrowsingDataRemoverImpl::RemovalTask& task : tasks) {
     // All tasks can be directly translated to a RemoveInternal() call. Since
     // that is a private method, we must call the four public versions of
     // Remove.* instead. This also serves as a test that those methods are all
     // correctly reduced to RemoveInternal().
     if (!task.observer && task.filter_builder->IsEmptyBlacklist()) {
       remover->Remove(task.delete_begin, task.delete_end,
                       task.remove_mask, task.origin_type_mask);
     } else if (task.filter_builder->IsEmptyBlacklist()) {
@@ skipping 38 matching lines @@
 // The previous test, BrowsingDataRemoverTest.MultipleTasks, tests that the
 // tasks are not mixed up and they are executed in a correct order. However,
 // the completion inhibitor kept synchronizing the execution in order to verify
 // the parameters. This test demonstrates that even running the tasks without
 // inhibition is executed correctly and doesn't crash.
 TEST_F(BrowsingDataRemoverImplTest, MultipleTasksInQuickSuccession) {
   BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>(
       BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext()));
   EXPECT_FALSE(remover->is_removing());
 
-  int test_removal_masks[] = {
-      BrowsingDataRemover::REMOVE_COOKIES,
-      BrowsingDataRemover::REMOVE_PASSWORDS,
-      BrowsingDataRemover::REMOVE_COOKIES,
-      BrowsingDataRemover::REMOVE_COOKIES,
-      BrowsingDataRemover::REMOVE_COOKIES,
-      BrowsingDataRemover::REMOVE_HISTORY,
-      BrowsingDataRemover::REMOVE_HISTORY,
-      BrowsingDataRemover::REMOVE_HISTORY,
-      BrowsingDataRemover::REMOVE_COOKIES | BrowsingDataRemover::REMOVE_HISTORY,
-      BrowsingDataRemover::REMOVE_COOKIES | BrowsingDataRemover::REMOVE_HISTORY,
-      BrowsingDataRemover::REMOVE_COOKIES |
-          BrowsingDataRemover::REMOVE_HISTORY |
-          BrowsingDataRemover::REMOVE_PASSWORDS,
-      BrowsingDataRemover::REMOVE_PASSWORDS,
-      BrowsingDataRemover::REMOVE_PASSWORDS,
+  std::set<const BrowsingDataType*> test_removal_masks[] = {
+      {&content::kBrowsingDataTypeCookies},
+      {&content::kBrowsingDataTypeChannelIDs},
+      {&content::kBrowsingDataTypeCookies},
+      {&content::kBrowsingDataTypeCookies},
+      {&content::kBrowsingDataTypeCookies},
+      {&content::kBrowsingDataTypeDownloads},
+      {&content::kBrowsingDataTypeDownloads},
+      {&content::kBrowsingDataTypeDownloads},
+      {&content::kBrowsingDataTypeCookies,
+       &content::kBrowsingDataTypeDownloads},
+      {&content::kBrowsingDataTypeCookies,
+       &content::kBrowsingDataTypeDownloads},
+      {&content::kBrowsingDataTypeCookies, &content::kBrowsingDataTypeDownloads,
+       &content::kBrowsingDataTypeChannelIDs},
+      {&content::kBrowsingDataTypeChannelIDs},
+      {&content::kBrowsingDataTypeChannelIDs},
   };
 
-  for (int removal_mask : test_removal_masks) {
+  for (const std::set<const BrowsingDataType*>& removal_mask :
+       test_removal_masks) {
     remover->Remove(base::Time(), base::Time::Max(), removal_mask,
                     BrowsingDataHelper::UNPROTECTED_WEB);
   }
 
   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);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
+                                {&content::kBrowsingDataTypeCookies},
+                                BrowsingDataHelper::UNPROTECTED_WEB);
 
   EXPECT_FALSE(remover->is_removing());
 }