Split browsing data masks 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 23 matching lines @@
 #include "chrome/browser/browsing_data/browsing_data_remover_impl.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browsing_data_filter_builder.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/storage_partition.h"
 #include "content/public/test/mock_download_manager.h"
+#include "content/public/test/mock_special_storage_policy.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/features/features.h"
 #include "net/cookies/cookie_store.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/channel_id_store.h"
 #include "net/ssl/ssl_client_cert_type.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ppapi/features/features.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/origin.h"
 
-#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::StoragePartition;
 using testing::_;
 using testing::ByRef;
 using testing::Eq;
 using testing::Invoke;
 using testing::IsEmpty;
 using testing::Matcher;
@@ skipping 466 matching lines @@
     // will have no delegate. For now, explicitly set it to nullptr.
     remover_ = static_cast<BrowsingDataRemoverImpl*>(
         BrowsingDataRemoverFactory::GetForBrowserContext(
             browser_context_.get()));
     remover_->SetEmbedderDelegate(nullptr);
   }
 
   ~BrowsingDataRemoverImplTest() override {}
 
   void TearDown() override {
-#if BUILDFLAG(ENABLE_EXTENSIONS)
     mock_policy_ = nullptr;
-#endif
 
     // 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) {
     TestStoragePartition storage_partition;
     remover_->OverrideStoragePartitionForTesting(&storage_partition);
 
-    int origin_type_mask = BrowsingDataHelper::UNPROTECTED_WEB;
+    int origin_type_mask = BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB;
     if (include_protected_origins)
-      origin_type_mask |= BrowsingDataHelper::PROTECTED_WEB;
+      origin_type_mask |= BrowsingDataRemover::ORIGIN_TYPE_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,
       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,
+        BrowsingDataRemover::ORIGIN_TYPE_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 10 matching lines @@
   }
 
   int GetOriginTypeMask() {
     return remover_->GetLastUsedOriginTypeMask();
   }
 
   StoragePartitionRemovalData GetStoragePartitionRemovalData() {
     return storage_partition_removal_data_;
   }
 
-  MockExtensionSpecialStoragePolicy* CreateMockPolicy() {
-#if BUILDFLAG(ENABLE_EXTENSIONS)
-    mock_policy_ = new MockExtensionSpecialStoragePolicy;
+  content::MockSpecialStoragePolicy* CreateMockPolicy() {
+    mock_policy_ = new content::MockSpecialStoragePolicy();
     return mock_policy_.get();
-#else
-    NOTREACHED();
-    return nullptr;
-#endif
   }
 
-  storage::SpecialStoragePolicy* mock_policy() {
-#if BUILDFLAG(ENABLE_EXTENSIONS)
+  content::MockSpecialStoragePolicy* mock_policy() {
     return mock_policy_.get();
-#else
-    return nullptr;
-#endif
   }
 
-  // If |kOrigin1| is protected when extensions are enabled, the expected
-  // result for tests where the OriginMatcherFunction result is variable.
-  bool ShouldRemoveForProtectedOriginOne() const {
-#if BUILDFLAG(ENABLE_EXTENSIONS)
-    return false;
-#else
-    return true;
-#endif
+  bool Match(const GURL& origin,
+             int mask,
+             storage::SpecialStoragePolicy* policy) {
+    return remover_->DoesOriginMatchMask(mask, origin, policy);
   }
 
  private:
   // Cached pointer to BrowsingDataRemoverImpl for access to testing methods.
   BrowsingDataRemoverImpl* remover_;
 
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<BrowserContext> browser_context_;
 
   StoragePartitionRemovalData storage_partition_removal_data_;
 
-#if BUILDFLAG(ENABLE_EXTENSIONS)
-  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy_;
-#endif
+  scoped_refptr<content::MockSpecialStoragePolicy> mock_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverImplTest);
 };
 
 // Tests ---------------------------------------------------------------------
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveCookieForever) {
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_COOKIES, false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      BrowsingDataRemover::DATA_TYPE_COOKIES, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_COOKIES,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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);
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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,
+                              BrowsingDataRemover::DATA_TYPE_COOKIES,
                               std::move(filter));
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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());
@@ skipping 24 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);
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, 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);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_CHANNEL_IDS, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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);
+                                BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS,
+                                false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_CHANNEL_IDS, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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,
+                              BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS,
                               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();
+  content::MockSpecialStoragePolicy* policy = CreateMockPolicy();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
-#endif
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
+                                BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE,
                                 false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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_FALSE(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();
+  content::MockSpecialStoragePolicy* policy = CreateMockPolicy();
   policy->AddProtected(kOrigin1.GetOrigin());
-#endif
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
+                                BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE,
                                 true);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB |
-            BrowsingDataHelper::PROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB |
+                BrowsingDataRemover::ORIGIN_TYPE_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);
+      BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE, GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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;
+  int removal_mask = BrowsingDataRemover::DATA_TYPE_DOWNLOADS |
+                     BrowsingDataRemover::DATA_TYPE_COOKIES;
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 removal_mask, false);
 
   EXPECT_EQ(removal_mask, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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,
+      BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+          BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
       false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+                BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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,
+      BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+          BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
       false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+                BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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,
+      BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+          BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
       false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+                BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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,
+      BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+          BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
       false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+                BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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,
-                              std::move(builder));
+  BlockUntilOriginDataRemoved(
+      base::Time(), base::Time::Max(),
+      BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL,
+      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,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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,
+      BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+          BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
       false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+                BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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,
+      BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+          BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
       false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+                BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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();
+  content::MockSpecialStoragePolicy* 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,
+      BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+          BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
       false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_WEBSQL |
-                BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_INDEXEDDB,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL |
+                BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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.
-  EXPECT_EQ(ShouldRemoveForProtectedOriginOne(),
-            removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
+  EXPECT_FALSE(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, RemoveQuotaManagedProtectedSpecificOrigin) {
-#if BUILDFLAG(ENABLE_EXTENSIONS)
-  MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
+  content::MockSpecialStoragePolicy* 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,
-                              std::move(builder));
+  BlockUntilOriginDataRemoved(
+      base::Time(), base::Time::Max(),
+      BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL,
+      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,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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.
-  EXPECT_EQ(ShouldRemoveForProtectedOriginOne(),
-            removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
+  EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
   // Since we use the matcher function to validate origins now, this should
   // return false for the origins we're not trying to clear.
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedProtectedOrigins) {
-#if BUILDFLAG(ENABLE_EXTENSIONS)
-  MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
+  content::MockSpecialStoragePolicy* 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,
+      BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL,
       true);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_INDEXEDDB |
-                BrowsingDataRemover::REMOVE_WEBSQL,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::PROTECTED_WEB |
-      BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB |
+      BrowsingDataRemover::ORIGIN_TYPE_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,
+      BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+          BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+          BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+          BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+          BrowsingDataRemover::DATA_TYPE_INDEXED_DB |
+          BrowsingDataRemover::DATA_TYPE_WEB_SQL,
       false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
-                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
-                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
-                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
-                BrowsingDataRemover::REMOVE_INDEXEDDB |
-                BrowsingDataRemover::REMOVE_WEBSQL,
+  EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_APP_CACHE |
+                BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS |
+                BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE |
+                BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS |
+                BrowsingDataRemover::DATA_TYPE_INDEXED_DB |
+                BrowsingDataRemover::DATA_TYPE_WEB_SQL,
             GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_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 |
@@ 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,
+                          BrowsingDataRemover::DATA_TYPE_COOKIES,
+                          BrowsingDataRemover::ORIGIN_TYPE_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,
+                          BrowsingDataRemover::DATA_TYPE_COOKIES,
+                          BrowsingDataRemover::ORIGIN_TYPE_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);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      BrowsingDataRemover::DATA_TYPE_DOWNLOADS, 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,
+                              BrowsingDataRemover::DATA_TYPE_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:
@@ skipping 54 matching lines @@
       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,
+                     BrowsingDataRemover::DATA_TYPE_DOWNLOADS,
+                     BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
                      BrowsingDataFilterBuilder::Create(
                          BrowsingDataFilterBuilder::BLACKLIST),
                      observer.target_a());
   tasks.emplace_back(base::Time(), base::Time::Max(),
-                     BrowsingDataRemover::REMOVE_COOKIES,
-                     BrowsingDataHelper::PROTECTED_WEB,
+                     BrowsingDataRemover::DATA_TYPE_COOKIES,
+                     BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB,
                      BrowsingDataFilterBuilder::Create(
                          BrowsingDataFilterBuilder::BLACKLIST),
                      nullptr);
   tasks.emplace_back(
       base::Time::Now(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_PASSWORDS, BrowsingDataHelper::ALL,
+      BrowsingDataRemover::DATA_TYPE_DOWNLOADS,
+      BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB |
+          BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB,
       BrowsingDataFilterBuilder::Create(
           BrowsingDataFilterBuilder::BLACKLIST),
       observer.target_b());
   tasks.emplace_back(
       base::Time(), base::Time::UnixEpoch(),
-      BrowsingDataRemover::REMOVE_WEBSQL,
-      BrowsingDataHelper::UNPROTECTED_WEB,
+      BrowsingDataRemover::DATA_TYPE_WEB_SQL,
+      BrowsingDataRemover::ORIGIN_TYPE_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,
+      BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS,
+      BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB |
+          BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB,
       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,
@@ skipping 41 matching lines @@
 // 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,
+      BrowsingDataRemover::DATA_TYPE_COOKIES,
+      BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE,
+      BrowsingDataRemover::DATA_TYPE_COOKIES,
+      BrowsingDataRemover::DATA_TYPE_COOKIES,
+      BrowsingDataRemover::DATA_TYPE_COOKIES,
+      BrowsingDataRemover::DATA_TYPE_DOWNLOADS,
+      BrowsingDataRemover::DATA_TYPE_DOWNLOADS,
+      BrowsingDataRemover::DATA_TYPE_DOWNLOADS,
+      BrowsingDataRemover::DATA_TYPE_COOKIES |
+          BrowsingDataRemover::DATA_TYPE_DOWNLOADS,
+      BrowsingDataRemover::DATA_TYPE_COOKIES |
+          BrowsingDataRemover::DATA_TYPE_DOWNLOADS,
+      BrowsingDataRemover::DATA_TYPE_COOKIES |
+          BrowsingDataRemover::DATA_TYPE_DOWNLOADS |
+          BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE,
+      BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE,
+      BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE,
   };
 
   for (int removal_mask : test_removal_masks) {
     remover->Remove(base::Time(), base::Time::Max(), removal_mask,
-                    BrowsingDataHelper::UNPROTECTED_WEB);
+                    BrowsingDataRemover::ORIGIN_TYPE_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);
+      BrowsingDataRemover::DATA_TYPE_COOKIES,
+      BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB);
 
   EXPECT_FALSE(remover->is_removing());
 }