Split browsing data masks between content and embedder

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
 
 #include "base/guid.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 64 matching lines @@
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/mock_cryptohome_client.h"
 #include "components/signin/core/account_id/account_id.h"
 #endif
 
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/mock_extension_special_storage_policy.h"
+#endif
+
 #if BUILDFLAG(ENABLE_PLUGINS)
 #include "chrome/browser/browsing_data/mock_browsing_data_flash_lso_helper.h"
 #endif
 
 using content::BrowsingDataFilterBuilder;
 using domain_reliability::CLEAR_BEACONS;
 using domain_reliability::CLEAR_CONTEXTS;
 using domain_reliability::DomainReliabilityClearMode;
 using domain_reliability::DomainReliabilityMonitor;
 using domain_reliability::DomainReliabilityService;
@@ skipping 14 matching lines @@
 using testing::WithArgs;
 
 namespace {
 
 const char kTestOrigin1[] = "http://host1.com:1/";
 const char kTestRegisterableDomain1[] = "host1.com";
 const char kTestOrigin2[] = "http://host2.com:1/";
 const char kTestOrigin3[] = "http://host3.com:1/";
 const char kTestRegisterableDomain3[] = "host3.com";
 const char kTestOrigin4[] = "https://host3.com:1/";
+const char kTestOriginExt[] = "chrome-extension://abcdefghijklmnopqrstuvwxyz/";
+const char kTestOriginDevTools[] = "chrome-devtools://abcdefghijklmnopqrstuvw/";
 
 // For HTTP auth.
 const char kTestRealm[] = "TestRealm";
 
 // For Autofill.
 const char kWebOrigin[] = "https://www.example.com/";
 
 const GURL kOrigin1(kTestOrigin1);
 const GURL kOrigin2(kTestOrigin2);
 const GURL kOrigin3(kTestOrigin3);
 const GURL kOrigin4(kTestOrigin4);
 
+const GURL kOriginExt(kTestOriginExt);
+const GURL kOriginDevTools(kTestOriginDevTools);
+
+// Shorthands for origin types.
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+const int kExtension = ChromeBrowsingDataRemoverDelegate::ORIGIN_TYPE_EXTENSION;
+#endif
+const int kProtected = BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB;
+const int kUnprotected = BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB;
+
 // Testers --------------------------------------------------------------------
 
 #if defined(OS_ANDROID)
 class TestWebappRegistry : public WebappRegistry {
  public:
   TestWebappRegistry() : WebappRegistry() { }
 
   void UnregisterWebappsForUrls(
       const base::Callback<bool(const GURL&)>& url_filter) override {
     // Mocks out a JNI call.
@@ skipping 710 matching lines @@
 
     TestingBrowserProcess::GetGlobal()->SetLocalState(nullptr);
   }
 
   ~ChromeBrowsingDataRemoverDelegateTest() override {}
 
   void BlockUntilBrowsingDataRemoved(const base::Time& delete_begin,
                                      const base::Time& delete_end,
                                      int remove_mask,
                                      bool include_protected_origins) {
-    int origin_type_mask = BrowsingDataHelper::UNPROTECTED_WEB;
-    if (include_protected_origins)
-      origin_type_mask |= BrowsingDataHelper::PROTECTED_WEB;
+    int origin_type_mask = BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB;
+    if (include_protected_origins) {
+      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();
   }
 
   void BlockUntilOriginDataRemoved(
       const base::Time& delete_begin,
       const base::Time& delete_end,
       int remove_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) {
     BrowsingDataRemoverCompletionObserver completion_observer(remover_);
-    static_cast<BrowsingDataRemoverImpl*>(remover_)
-        ->RemoveWithFilterAndReply(delete_begin, delete_end, remove_mask,
-                                   BrowsingDataHelper::UNPROTECTED_WEB,
-                                   std::move(filter_builder),
-                                   &completion_observer);
+    static_cast<BrowsingDataRemoverImpl*>(remover_)->RemoveWithFilterAndReply(
+        delete_begin, delete_end, remove_mask,
+        BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+        std::move(filter_builder), &completion_observer);
     completion_observer.BlockUntilCompletion();
   }
 
   const base::Time& GetBeginTime() {
     return remover_->GetLastUsedBeginTime();
   }
 
   int GetRemovalMask() {
     return remover_->GetLastUsedRemovalMask();
   }
 
   int GetOriginTypeMask() {
     return remover_->GetLastUsedOriginTypeMask();
   }
 
   TestingProfile* GetProfile() {
     return profile_.get();
   }
 
   const ClearDomainReliabilityTester& clear_domain_reliability_tester() {
     return clear_domain_reliability_tester_;
   }
 
+  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.
   BrowsingDataRemover* remover_;
 
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<TestingProfile> profile_;
 
   // Needed to mock out DomainReliabilityService, even for unrelated tests.
   ClearDomainReliabilityTester clear_domain_reliability_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeBrowsingDataRemoverDelegateTest);
 };
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveSafeBrowsingCookieForever) {
   RemoveSafeBrowsingCookieTester tester;
 
   tester.AddCookie();
   ASSERT_TRUE(tester.ContainsCookie());
 
   BlockUntilBrowsingDataRemoved(base::Time(), 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());
   EXPECT_FALSE(tester.ContainsCookie());
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        RemoveSafeBrowsingCookieLastHour) {
   RemoveSafeBrowsingCookieTester tester;
 
   tester.AddCookie();
   ASSERT_TRUE(tester.ContainsCookie());
 
   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());
   // Removing with time period other than all time should not clear safe
   // browsing cookies.
   EXPECT_TRUE(tester.ContainsCookie());
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        RemoveSafeBrowsingCookieForeverWithPredicate) {
   RemoveSafeBrowsingCookieTester tester;
 
   tester.AddCookie();
   ASSERT_TRUE(tester.ContainsCookie());
   std::unique_ptr<BrowsingDataFilterBuilder> filter(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
   filter->AddRegisterableDomain(kTestRegisterableDomain1);
   BlockUntilOriginDataRemoved(base::Time(), 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());
   EXPECT_TRUE(tester.ContainsCookie());
 
   std::unique_ptr<BrowsingDataFilterBuilder> filter2(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
   filter2->AddRegisterableDomain(kTestRegisterableDomain1);
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_COOKIES,
+                              BrowsingDataRemover::DATA_TYPE_COOKIES,
                               std::move(filter2));
   EXPECT_FALSE(tester.ContainsCookie());
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryForever) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
 
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+            GetOriginTypeMask());
   EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryForLastHour) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
 
   base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   tester.AddHistory(kOrigin2, two_hours_ago);
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
 
-  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
+  BlockUntilBrowsingDataRemoved(
+      AnHourAgo(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+            GetOriginTypeMask());
   EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
 }
 
 // This should crash (DCHECK) in Debug, but death tests don't work properly
 // here.
 // TODO(msramek): To make this testable, the refusal to delete history should
 // be made a part of interface (e.g. a success value) as opposed to a DCHECK.
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryProhibited) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
   PrefService* prefs = GetProfile()->GetPrefs();
   prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false);
 
   base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   tester.AddHistory(kOrigin2, two_hours_ago);
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
 
-  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  BlockUntilBrowsingDataRemoved(
+      AnHourAgo(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+            GetOriginTypeMask());
 
   // Nothing should have been deleted.
   EXPECT_TRUE(tester.HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        RemoveMultipleTypesHistoryProhibited) {
   PrefService* prefs = GetProfile()->GetPrefs();
   prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false);
 
   // Add some history.
   RemoveHistoryTester history_tester;
   ASSERT_TRUE(history_tester.Init(GetProfile()));
   history_tester.AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(history_tester.HistoryContainsURL(kOrigin1));
 
   // Expect that passwords will be deleted, as they do not depend
   // on |prefs::kAllowDeletingBrowserHistory|.
   RemovePasswordsTester tester(GetProfile());
   EXPECT_CALL(*tester.store(), RemoveLoginsByURLAndTimeImpl(_, _, _));
 
-  int removal_mask = BrowsingDataRemover::REMOVE_HISTORY |
-                     BrowsingDataRemover::REMOVE_PASSWORDS;
+  int removal_mask = ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY |
+                     ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS;
 
   BlockUntilBrowsingDataRemoved(AnHourAgo(), 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());
 
   // Verify that history was not deleted.
   EXPECT_TRUE(history_tester.HistoryContainsURL(kOrigin1));
 }
 #endif
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveExternalProtocolData) {
   TestingProfile* profile = GetProfile();
   // Add external protocol data on profile.
   base::DictionaryValue prefs;
   prefs.SetBoolean("tel", true);
   profile->GetPrefs()->Set(prefs::kExcludedSchemes, prefs);
 
   EXPECT_FALSE(
       profile->GetPrefs()->GetDictionary(prefs::kExcludedSchemes)->empty());
 
   BlockUntilBrowsingDataRemoved(
       AnHourAgo(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_EXTERNAL_PROTOCOL_DATA, false);
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_EXTERNAL_PROTOCOL_DATA,
+      false);
   EXPECT_TRUE(
       profile->GetPrefs()->GetDictionary(prefs::kExcludedSchemes)->empty());
 }
 
 // Test that clearing history deletes favicons not associated with bookmarks.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveFaviconsForever) {
   GURL page_url("http://a");
 
   RemoveFaviconTester favicon_tester;
   ASSERT_TRUE(favicon_tester.Init(GetProfile()));
   favicon_tester.VisitAndAddFavicon(page_url);
   ASSERT_TRUE(favicon_tester.HasFaviconForPageURL(page_url));
 
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+            GetRemovalMask());
   EXPECT_FALSE(favicon_tester.HasFaviconForPageURL(page_url));
 }
 
 // Test that a bookmark's favicon is expired and not deleted when clearing
 // history. Expiring the favicon causes the bookmark's favicon to be updated
 // when the user next visits the bookmarked page. Expiring the bookmark's
 // favicon is useful when the bookmark's favicon becomes incorrect (See
 // crbug.com/474421 for a sample bug which causes this).
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, ExpireBookmarkFavicons) {
   GURL bookmarked_page("http://a");
 
   TestingProfile* profile = GetProfile();
   profile->CreateBookmarkModel(true);
   bookmarks::BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForBrowserContext(profile);
   bookmarks::test::WaitForBookmarkModelToLoad(bookmark_model);
   bookmark_model->AddURL(bookmark_model->bookmark_bar_node(), 0,
                          base::ASCIIToUTF16("a"), bookmarked_page);
 
   RemoveFaviconTester favicon_tester;
   ASSERT_TRUE(favicon_tester.Init(GetProfile()));
   favicon_tester.VisitAndAddFavicon(bookmarked_page);
   ASSERT_TRUE(favicon_tester.HasFaviconForPageURL(bookmarked_page));
 
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+            GetRemovalMask());
   EXPECT_TRUE(favicon_tester.HasExpiredFaviconForPageURL(bookmarked_page));
 }
 
 // TODO(crbug.com/589586): Disabled, since history is not yet marked as
 // a filterable datatype.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        DISABLED_TimeBasedHistoryRemoval) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
 
   base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   tester.AddHistory(kOrigin2, two_hours_ago);
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
 
   std::unique_ptr<BrowsingDataFilterBuilder> builder(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
-  BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_HISTORY,
-                              std::move(builder));
+  BlockUntilOriginDataRemoved(
+      AnHourAgo(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, std::move(builder));
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+            GetOriginTypeMask());
   EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
 }
 
 // Verify that clearing autofill form data works.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, AutofillRemovalLastHour) {
   GetProfile()->CreateWebDataService();
   RemoveAutofillTester tester(GetProfile());
 
   ASSERT_FALSE(tester.HasProfile());
   tester.AddProfilesAndCards();
   ASSERT_TRUE(tester.HasProfile());
 
-  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_FORM_DATA, false);
+  BlockUntilBrowsingDataRemoved(
+      AnHourAgo(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FORM_DATA, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+            GetOriginTypeMask());
   ASSERT_FALSE(tester.HasProfile());
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, AutofillRemovalEverything) {
   GetProfile()->CreateWebDataService();
   RemoveAutofillTester tester(GetProfile());
 
   ASSERT_FALSE(tester.HasProfile());
   tester.AddProfilesAndCards();
   ASSERT_TRUE(tester.HasProfile());
 
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_FORM_DATA, false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_FORM_DATA, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+            GetOriginTypeMask());
   ASSERT_FALSE(tester.HasProfile());
 }
 
 // Verify that clearing autofill form data works.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        AutofillOriginsRemovedWithHistory) {
   GetProfile()->CreateWebDataService();
   RemoveAutofillTester tester(GetProfile());
 
   tester.AddProfilesAndCards();
   EXPECT_FALSE(tester.HasOrigin(std::string()));
   EXPECT_TRUE(tester.HasOrigin(kWebOrigin));
   EXPECT_TRUE(tester.HasOrigin(autofill::kSettingsOrigin));
 
-  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
+  BlockUntilBrowsingDataRemoved(
+      AnHourAgo(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+            GetOriginTypeMask());
   EXPECT_TRUE(tester.HasOrigin(std::string()));
   EXPECT_FALSE(tester.HasOrigin(kWebOrigin));
   EXPECT_TRUE(tester.HasOrigin(autofill::kSettingsOrigin));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, ZeroSuggestCacheClear) {
   PrefService* prefs = GetProfile()->GetPrefs();
   prefs->SetString(omnibox::kZeroSuggestCachedResults,
                    "[\"\", [\"foo\", \"bar\"]]");
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_COOKIES, false);
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, false);
 
   // Expect the prefs to be cleared when cookies are removed.
   EXPECT_TRUE(prefs->GetString(omnibox::kZeroSuggestCachedResults).empty());
-  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());
 }
 
 #if defined(OS_CHROMEOS)
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        ContentProtectionPlatformKeysRemoval) {
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service;
   chromeos::ScopedTestCrosSettings test_cros_settings;
   chromeos::MockUserManager* mock_user_manager =
       new testing::NiceMock<chromeos::MockUserManager>();
   mock_user_manager->SetActiveUser(
       AccountId::FromUserEmail("test@example.com"));
   chromeos::ScopedUserManagerEnabler user_manager_enabler(mock_user_manager);
 
   std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter =
       chromeos::DBusThreadManager::GetSetterForTesting();
   chromeos::MockCryptohomeClient* cryptohome_client =
       new chromeos::MockCryptohomeClient;
   dbus_setter->SetCryptohomeClient(
       std::unique_ptr<chromeos::CryptohomeClient>(cryptohome_client));
 
   // Expect exactly one call.  No calls means no attempt to delete keys and more
   // than one call means a significant performance problem.
   EXPECT_CALL(*cryptohome_client, TpmAttestationDeleteKeys(_, _, _, _))
       .WillOnce(WithArgs<3>(Invoke(FakeDBusCall)));
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_MEDIA_LICENSES,
+                                BrowsingDataRemover::DATA_TYPE_MEDIA_LICENSES,
                                 false);
 
   chromeos::DBusThreadManager::Shutdown();
 }
 #endif
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_Null) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   EXPECT_EQ(0u, tester.clear_count());
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_Beacons) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter()));
 }
 
 // TODO(crbug.com/589586): Disabled, since history is not yet marked as
 // a filterable datatype.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        DISABLED_DomainReliability_Beacons_WithFilter) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   std::unique_ptr<BrowsingDataFilterBuilder> builder(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
   builder->AddRegisterableDomain(kTestRegisterableDomain1);
 
-  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_HISTORY,
-                              builder->Copy());
+  BlockUntilOriginDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, builder->Copy());
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       builder->BuildGeneralFilter(), tester.last_filter()));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_Contexts) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_COOKIES, false);
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter()));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        DomainReliability_Contexts_WithFilter) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   std::unique_ptr<BrowsingDataFilterBuilder> builder(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
   builder->AddRegisterableDomain(kTestRegisterableDomain1);
 
   BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_COOKIES,
+                              BrowsingDataRemover::DATA_TYPE_COOKIES,
                               builder->Copy());
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       builder->BuildGeneralFilter(), tester.last_filter()));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_ContextsWin) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(
       base::Time(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_HISTORY | BrowsingDataRemover::REMOVE_COOKIES,
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY |
+          BrowsingDataRemover::DATA_TYPE_COOKIES,
       false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        DomainReliability_ProtectedOrigins) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_COOKIES, true);
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, true);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
 }
 
 // TODO(juliatuttle): This isn't actually testing the no-monitor case, since
 // BrowsingDataRemoverTest now creates one unconditionally, since it's needed
 // for some unrelated test cases. This should be fixed so it tests the no-
 // monitor case again.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        DISABLED_DomainReliability_NoMonitor) {
   BlockUntilBrowsingDataRemoved(
       base::Time(), base::Time::Max(),
-      BrowsingDataRemover::REMOVE_HISTORY | BrowsingDataRemover::REMOVE_COOKIES,
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY |
+          BrowsingDataRemover::DATA_TYPE_COOKIES,
       false);
 }
 
 // Tests that the deletion of downloads completes successfully and that
 // ChromeDownloadManagerDelegate is correctly created and shut down.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveDownloads) {
   RemoveDownloadsTester tester(GetProfile());
 
   EXPECT_CALL(
       *tester.download_manager(), RemoveDownloadsByURLAndTime(_, _, _));
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_DOWNLOADS, false);
+                                BrowsingDataRemover::DATA_TYPE_DOWNLOADS,
+                                false);
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemovePasswordStatistics) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> empty_filter;
 
   EXPECT_CALL(*tester.store(), RemoveStatisticsByOriginAndTimeImpl(
                                    ProbablySameFilter(empty_filter),
                                    base::Time(), base::Time::Max()));
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
 }
 
 // TODO(crbug.com/589586): Disabled, since history is not yet marked as
 // a filterable datatype.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        DISABLED_RemovePasswordStatisticsByOrigin) {
   RemovePasswordsTester tester(GetProfile());
 
   std::unique_ptr<BrowsingDataFilterBuilder> builder(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
   builder->AddRegisterableDomain(kTestRegisterableDomain1);
   base::Callback<bool(const GURL&)> filter = builder->BuildGeneralFilter();
 
   EXPECT_CALL(*tester.store(),
               RemoveStatisticsByOriginAndTimeImpl(
                   ProbablySameFilter(filter), base::Time(), base::Time::Max()));
-  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_HISTORY,
-                              std::move(builder));
+  BlockUntilOriginDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, std::move(builder));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemovePasswordsByTimeOnly) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(*tester.store(),
               RemoveLoginsByURLAndTimeImpl(ProbablySameFilter(filter), _, _))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_PASSWORDS, false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS, false);
 }
 
 // Disabled, since passwords are not yet marked as a filterable datatype.
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        DISABLED_RemovePasswordsByOrigin) {
   RemovePasswordsTester tester(GetProfile());
   std::unique_ptr<BrowsingDataFilterBuilder> builder(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
   builder->AddRegisterableDomain(kTestRegisterableDomain1);
   base::Callback<bool(const GURL&)> filter = builder->BuildGeneralFilter();
 
   EXPECT_CALL(*tester.store(),
               RemoveLoginsByURLAndTimeImpl(ProbablySameFilter(filter), _, _))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
-  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_PASSWORDS,
-                              std::move(builder));
+  BlockUntilOriginDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS,
+      std::move(builder));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DisableAutoSignIn) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> empty_filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(
       *tester.store(),
       DisableAutoSignInForOriginsImpl(ProbablySameFilter(empty_filter)))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
 
   BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_COOKIES, false);
+                                BrowsingDataRemover::DATA_TYPE_COOKIES, false);
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        DisableAutoSignInAfterRemovingPasswords) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> empty_filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(*tester.store(), RemoveLoginsByURLAndTimeImpl(_, _, _))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
   EXPECT_CALL(
       *tester.store(),
       DisableAutoSignInForOriginsImpl(ProbablySameFilter(empty_filter)))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
 
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_COOKIES |
-                                    BrowsingDataRemover::REMOVE_PASSWORDS,
-                                false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      BrowsingDataRemover::DATA_TYPE_COOKIES |
+          ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS,
+      false);
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        RemoveContentSettingsWithBlacklist) {
   // Add our settings.
   HostContentSettingsMap* host_content_settings_map =
       HostContentSettingsMapFactory::GetForProfile(GetProfile());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin1, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin2, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin3, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin4, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
 
   // Clear all except for origin1 and origin3.
   std::unique_ptr<BrowsingDataFilterBuilder> filter(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
   filter->AddRegisterableDomain(kTestRegisterableDomain1);
   filter->AddRegisterableDomain(kTestRegisterableDomain3);
-  BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
-                              std::move(filter));
+  BlockUntilOriginDataRemoved(
+      AnHourAgo(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_USAGE_DATA,
+      std::move(filter));
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_USAGE_DATA, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_USAGE_DATA,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+            GetOriginTypeMask());
 
   // Verify we only have true, and they're origin1, origin3, and origin4.
   ContentSettingsForOneType host_settings;
   host_content_settings_map->GetSettingsForOneType(
       CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(), &host_settings);
   EXPECT_EQ(3u, host_settings.size());
   EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin1),
             host_settings[0].primary_pattern)
       << host_settings[0].primary_pattern.ToString();
   EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin4),
@@ skipping 13 matching lines @@
   durable_permission.UpdateContentSetting(kOrigin1, GURL(),
                                           CONTENT_SETTING_ALLOW);
   durable_permission.UpdateContentSetting(kOrigin2, GURL(),
                                           CONTENT_SETTING_ALLOW);
 
   // Clear all except for origin1 and origin3.
   std::unique_ptr<BrowsingDataFilterBuilder> filter(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST));
   filter->AddRegisterableDomain(kTestRegisterableDomain1);
   filter->AddRegisterableDomain(kTestRegisterableDomain3);
-  BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_DURABLE_PERMISSION,
-                              std::move(filter));
+  BlockUntilOriginDataRemoved(
+      AnHourAgo(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_DURABLE_PERMISSION,
+      std::move(filter));
 
-  EXPECT_EQ(BrowsingDataRemover::REMOVE_DURABLE_PERMISSION, GetRemovalMask());
-  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+  EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_DURABLE_PERMISSION,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+            GetOriginTypeMask());
 
   // Verify we only have allow for the first origin.
   ContentSettingsForOneType host_settings;
   host_content_settings_map->GetSettingsForOneType(
       CONTENT_SETTINGS_TYPE_DURABLE_STORAGE, std::string(), &host_settings);
 
   ASSERT_EQ(2u, host_settings.size());
   // Only the first should should have a setting.
   EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin1),
             host_settings[0].primary_pattern)
@@ skipping 19 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_PASSWORDS, false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS, false);
 
   EXPECT_EQ(nullptr, http_auth_cache->Lookup(kOrigin1, kTestRealm,
                                              net::HttpAuth::AUTH_SCHEME_BASIC));
 }
 
 TEST_F(ChromeBrowsingDataRemoverDelegateTest, ClearPermissionPromptCounts) {
   RemovePermissionPromptCountsTest tester(GetProfile());
 
   std::unique_ptr<BrowsingDataFilterBuilder> filter_builder_1(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
@@ skipping 21 matching lines @@
                         CONTENT_SETTING_ASK);
     EXPECT_FALSE(tester.RecordDismissAndEmbargo(
         kOrigin2, CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
     EXPECT_FALSE(tester.RecordDismissAndEmbargo(
         kOrigin2, CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
     EXPECT_TRUE(tester.RecordDismissAndEmbargo(
         kOrigin2, CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
     tester.CheckEmbargo(kOrigin2, CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                         CONTENT_SETTING_BLOCK);
 
-    BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
-                                std::move(filter_builder_1));
+    BlockUntilOriginDataRemoved(
+        AnHourAgo(), base::Time::Max(),
+        ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_USAGE_DATA,
+        std::move(filter_builder_1));
 
     // kOrigin1 should be gone, but kOrigin2 remains.
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        CONTENT_SETTINGS_TYPE_GEOLOCATION));
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
     EXPECT_EQ(0, tester.GetDismissCount(kOrigin1,
                                         CONTENT_SETTINGS_TYPE_MIDI_SYSEX));
     EXPECT_EQ(1, tester.GetIgnoreCount(
                      kOrigin2, CONTENT_SETTINGS_TYPE_DURABLE_STORAGE));
     EXPECT_EQ(3, tester.GetDismissCount(kOrigin2,
                                         CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
     tester.CheckEmbargo(kOrigin2, CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                         CONTENT_SETTING_BLOCK);
 
-    BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
-                                  BrowsingDataRemover::REMOVE_HISTORY, false);
+    BlockUntilBrowsingDataRemoved(
+        AnHourAgo(), base::Time::Max(),
+        ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
 
     // Everything should be gone.
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        CONTENT_SETTINGS_TYPE_GEOLOCATION));
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
     EXPECT_EQ(0, tester.GetDismissCount(kOrigin1,
                                         CONTENT_SETTINGS_TYPE_MIDI_SYSEX));
     EXPECT_EQ(0, tester.GetIgnoreCount(
                      kOrigin2, CONTENT_SETTINGS_TYPE_DURABLE_STORAGE));
@@ skipping 12 matching lines @@
                                      CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
     EXPECT_FALSE(tester.RecordDismissAndEmbargo(
         kOrigin1, CONTENT_SETTINGS_TYPE_MIDI_SYSEX));
     tester.CheckEmbargo(kOrigin1, CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
                         CONTENT_SETTING_ASK);
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin2,
                                      CONTENT_SETTINGS_TYPE_DURABLE_STORAGE));
     EXPECT_FALSE(tester.RecordDismissAndEmbargo(
         kOrigin2, CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
 
-    BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
-                                std::move(filter_builder_2));
+    BlockUntilOriginDataRemoved(
+        AnHourAgo(), base::Time::Max(),
+        ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_USAGE_DATA,
+        std::move(filter_builder_2));
 
     // kOrigin2 should be gone, but kOrigin1 remains.
     EXPECT_EQ(2, tester.GetIgnoreCount(kOrigin1,
                                        CONTENT_SETTINGS_TYPE_GEOLOCATION));
     EXPECT_EQ(1, tester.GetIgnoreCount(kOrigin1,
                                        CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
     EXPECT_EQ(1, tester.GetDismissCount(kOrigin1,
                                         CONTENT_SETTINGS_TYPE_MIDI_SYSEX));
     EXPECT_EQ(0, tester.GetIgnoreCount(
                      kOrigin2, CONTENT_SETTINGS_TYPE_DURABLE_STORAGE));
     EXPECT_EQ(0, tester.GetDismissCount(
                      kOrigin2, CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
 
     EXPECT_FALSE(tester.RecordDismissAndEmbargo(
         kOrigin1, CONTENT_SETTINGS_TYPE_MIDI_SYSEX));
     EXPECT_TRUE(tester.RecordDismissAndEmbargo(
         kOrigin1, CONTENT_SETTINGS_TYPE_MIDI_SYSEX));
     EXPECT_EQ(
         3, tester.GetDismissCount(kOrigin1, CONTENT_SETTINGS_TYPE_MIDI_SYSEX));
     tester.CheckEmbargo(kOrigin1, CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
                         CONTENT_SETTING_BLOCK);
 
-    BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
-                                  BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
-                                  false);
+    BlockUntilBrowsingDataRemoved(
+        AnHourAgo(), base::Time::Max(),
+        ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_USAGE_DATA, false);
 
     // Everything should be gone.
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        CONTENT_SETTINGS_TYPE_GEOLOCATION));
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
     EXPECT_EQ(0, tester.GetDismissCount(kOrigin1,
                                         CONTENT_SETTINGS_TYPE_MIDI_SYSEX));
     EXPECT_EQ(0, tester.GetIgnoreCount(
                      kOrigin2, CONTENT_SETTINGS_TYPE_DURABLE_STORAGE));
@@ skipping 13 matching lines @@
   tester.AddDomain(kOrigin3.host());
 
   std::vector<std::string> expected = {
       kOrigin1.host(), kOrigin2.host(), kOrigin3.host() };
   EXPECT_EQ(expected, tester.GetDomains());
 
   // Delete data with a filter for the registrable domain of |kOrigin3|.
   std::unique_ptr<BrowsingDataFilterBuilder> filter_builder(
       BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST));
   filter_builder->AddRegisterableDomain(kTestRegisterableDomain3);
-  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
-                              BrowsingDataRemover::REMOVE_PLUGIN_DATA,
-                              std::move(filter_builder));
+  BlockUntilOriginDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PLUGIN_DATA,
+      std::move(filter_builder));
 
   // Plugin data for |kOrigin3.host()| should have been removed.
   expected.pop_back();
   EXPECT_EQ(expected, tester.GetDomains());
 
   // TODO(msramek): Mock PluginDataRemover and test the complete deletion
   // of plugin data as well.
 }
 #endif
 
@@ skipping 42 matching lines @@
                   bookmark_model, 2, base::Time::UnixEpoch(),
                   /*consider_visits_from_desktop=*/false),
               Not(IsEmpty()));
 
   // Inject the bookmark model into the remover.
   BrowsingDataRemover* remover =
       BrowsingDataRemoverFactory::GetForBrowserContext(&profile);
 
   BrowsingDataRemoverCompletionObserver completion_observer(remover);
   remover->RemoveAndReply(delete_begin, base::Time::Max(),
-                          BrowsingDataRemover::REMOVE_HISTORY,
-                          BrowsingDataHelper::ALL, &completion_observer);
+                          ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY,
+                          ChromeBrowsingDataRemoverDelegate::ALL_ORIGIN_TYPES,
+                          &completion_observer);
   completion_observer.BlockUntilCompletion();
 
   // There should be only 1 recently visited bookmarks.
   std::vector<const bookmarks::BookmarkNode*> remaining_nodes =
       ntp_snippets::GetRecentlyVisitedBookmarks(
           bookmark_model, 3, base::Time::UnixEpoch(),
           /*consider_visits_from_desktop=*/true);
   EXPECT_THAT(remaining_nodes, SizeIs(1));
   EXPECT_THAT(remaining_nodes[0]->url().spec(), Eq("http://foo-2.org/"));
 }
 
 // Test that the remover clears language model data (normally added by the
 // ChromeTranslateClient).
 TEST_F(ChromeBrowsingDataRemoverDelegateTest,
        LanguageModelClearedOnClearingCompleteHistory) {
   translate::LanguageModel* language_model =
       LanguageModelFactory::GetInstance()->GetForBrowserContext(GetProfile());
 
   // Simulate browsing.
   for (int i = 0; i < 100; i++) {
     language_model->OnPageVisited("en");
     language_model->OnPageVisited("en");
     language_model->OnPageVisited("en");
     language_model->OnPageVisited("es");
   }
 
   // Clearing a part of the history has no effect.
-  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
+  BlockUntilBrowsingDataRemoved(
+      AnHourAgo(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
 
   EXPECT_THAT(language_model->GetTopLanguages(), SizeIs(2));
   EXPECT_THAT(language_model->GetLanguageFrequency("en"), FloatEq(0.75));
   EXPECT_THAT(language_model->GetLanguageFrequency("es"), FloatEq(0.25));
 
   // Clearing the full history does the trick.
-  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
-                                BrowsingDataRemover::REMOVE_HISTORY, false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time(), base::Time::Max(),
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false);
 
   EXPECT_THAT(language_model->GetTopLanguages(), SizeIs(0));
   EXPECT_THAT(language_model->GetLanguageFrequency("en"), FloatEq(0.0));
   EXPECT_THAT(language_model->GetLanguageFrequency("es"), FloatEq(0.0));
 }
+
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+TEST_F(ChromeBrowsingDataRemoverDelegateTest, OriginTypeMasks) {
+  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
+      new MockExtensionSpecialStoragePolicy;
+  // Protect kOrigin1.
+  mock_policy->AddProtected(kOrigin1.GetOrigin());
+
+  EXPECT_FALSE(Match(kOrigin1, kUnprotected, mock_policy.get()));
+  EXPECT_TRUE(Match(kOrigin2, kUnprotected, mock_policy.get()));
+  EXPECT_FALSE(Match(kOriginExt, kUnprotected, mock_policy.get()));
+  EXPECT_FALSE(Match(kOriginDevTools, kUnprotected, mock_policy.get()));
+
+  EXPECT_TRUE(Match(kOrigin1, kProtected, mock_policy.get()));
+  EXPECT_FALSE(Match(kOrigin2, kProtected, mock_policy.get()));
+  EXPECT_FALSE(Match(kOriginExt, kProtected, mock_policy.get()));
+  EXPECT_FALSE(Match(kOriginDevTools, kProtected, mock_policy.get()));
+
+  EXPECT_FALSE(Match(kOrigin1, kExtension, mock_policy.get()));
+  EXPECT_FALSE(Match(kOrigin2, kExtension, mock_policy.get()));
+  EXPECT_TRUE(Match(kOriginExt, kExtension, mock_policy.get()));
+  EXPECT_FALSE(Match(kOriginDevTools, kExtension, mock_policy.get()));
+
+  EXPECT_TRUE(Match(kOrigin1, kUnprotected | kProtected, mock_policy.get()));
+  EXPECT_TRUE(Match(kOrigin2, kUnprotected | kProtected, mock_policy.get()));
+  EXPECT_FALSE(Match(kOriginExt, kUnprotected | kProtected, mock_policy.get()));
+  EXPECT_FALSE(
+      Match(kOriginDevTools, kUnprotected | kProtected, mock_policy.get()));
+
+  EXPECT_FALSE(Match(kOrigin1, kUnprotected | kExtension, mock_policy.get()));
+  EXPECT_TRUE(Match(kOrigin2, kUnprotected | kExtension, mock_policy.get()));
+  EXPECT_TRUE(Match(kOriginExt, kUnprotected | kExtension, mock_policy.get()));
+  EXPECT_FALSE(
+      Match(kOriginDevTools, kUnprotected | kExtension, mock_policy.get()));
+
+  EXPECT_TRUE(Match(kOrigin1, kProtected | kExtension, mock_policy.get()));
+  EXPECT_FALSE(Match(kOrigin2, kProtected | kExtension, mock_policy.get()));
+  EXPECT_TRUE(Match(kOriginExt, kProtected | kExtension, mock_policy.get()));
+  EXPECT_FALSE(
+      Match(kOriginDevTools, kProtected | kExtension, mock_policy.get()));
+
+  EXPECT_TRUE(Match(kOrigin1, kUnprotected | kProtected | kExtension,
+                    mock_policy.get()));
+  EXPECT_TRUE(Match(kOrigin2, kUnprotected | kProtected | kExtension,
+                    mock_policy.get()));
+  EXPECT_TRUE(Match(kOriginExt, kUnprotected | kProtected | kExtension,
+                    mock_policy.get()));
+  EXPECT_FALSE(Match(kOriginDevTools, kUnprotected | kProtected | kExtension,
+                     mock_policy.get()));
+}
+#endif
+
+// If extensions are disabled, there is no policy.
+TEST_F(ChromeBrowsingDataRemoverDelegateTest, OriginTypeMasksNoPolicy) {
+  EXPECT_TRUE(Match(kOrigin1, kUnprotected, nullptr));
+  EXPECT_FALSE(Match(kOriginExt, kUnprotected, nullptr));
+  EXPECT_FALSE(Match(kOriginDevTools, kUnprotected, nullptr));
+
+  EXPECT_FALSE(Match(kOrigin1, kProtected, nullptr));
+  EXPECT_FALSE(Match(kOriginExt, kProtected, nullptr));
+  EXPECT_FALSE(Match(kOriginDevTools, kProtected, nullptr));
+
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  EXPECT_FALSE(Match(kOrigin1, kExtension, nullptr));
+  EXPECT_TRUE(Match(kOriginExt, kExtension, nullptr));
+  EXPECT_FALSE(Match(kOriginDevTools, kExtension, nullptr));
+#endif
+}