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

chrome/browser/extensions/api/browsing_data/browsing_data_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <memory>
 #include <string>
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
+#include "chrome/browser/browsing_data/chrome_browsing_data_types.h"
 #include "chrome/browser/extensions/api/browsing_data/browsing_data_api.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "components/browsing_data/core/browsing_data_utils.h"
 #include "components/browsing_data/core/pref_names.h"
 #include "components/prefs/pref_service.h"
 
 using extension_function_test_utils::RunFunctionAndReturnError;
 using extension_function_test_utils::RunFunctionAndReturnSingleResult;
+using content::BrowsingDataType;
 
 namespace {
 
 enum OriginTypeMask {
   UNPROTECTED_WEB = BrowsingDataHelper::UNPROTECTED_WEB,
   PROTECTED_WEB = BrowsingDataHelper::PROTECTED_WEB,
   EXTENSION = BrowsingDataHelper::EXTENSION
 };
 
 const char kRemoveEverythingArguments[] =
     "[{\"since\": 1000}, {"
     "\"appcache\": true, \"cache\": true, \"cookies\": true, "
     "\"downloads\": true, \"fileSystems\": true, \"formData\": true, "
     "\"history\": true, \"indexedDB\": true, \"localStorage\": true, "
     "\"serverBoundCertificates\": true, \"passwords\": true, "
     "\"pluginData\": true, \"serviceWorkers\": true, \"cacheStorage\": true, "
     "\"webSQL\": true"
     "}]";
 
+inline bool MaskContains(const std::set<const BrowsingDataType*>& remove_mask,
+                         const BrowsingDataType* data_type) {
+  return remove_mask.find(data_type) != remove_mask.end();
+}
+
 class ExtensionBrowsingDataTest : public InProcessBrowserTest {
  public:
   const base::Time& GetBeginTime() {
     return remover_->GetLastUsedBeginTime();
   }
 
-  int GetRemovalMask() {
+  const std::set<const BrowsingDataType*>& GetRemovalMask() {
     return remover_->GetLastUsedRemovalMask();
   }
 
   int GetOriginTypeMask() {
     return remover_->GetLastUsedOriginTypeMask();
   }
 
  protected:
   void SetUpOnMainThread() override {
     remover_ =
         BrowsingDataRemoverFactory::GetForBrowserContext(browser()->profile());
   }
 
   int GetAsMask(const base::DictionaryValue* dict, std::string path,
                 int mask_value) {
     bool result;
     EXPECT_TRUE(dict->GetBoolean(path, &result)) << "for " << path;
     return result ? mask_value : 0;
   }
 
+  const BrowsingDataType* GetAsMask(
+      const base::DictionaryValue* dict, std::string path,
+      const BrowsingDataType* mask_value) {
+    bool result;
+    EXPECT_TRUE(dict->GetBoolean(path, &result)) << "for " << path;
+    return result ? mask_value : nullptr;
+  }
+
   void RunBrowsingDataRemoveFunctionAndCompareRemovalMask(
       const std::string& data_types,
-      int expected_mask) {
+      const std::set<const BrowsingDataType*>& expected_mask) {
     scoped_refptr<BrowsingDataRemoveFunction> function =
         new BrowsingDataRemoveFunction();
     SCOPED_TRACE(data_types);
     EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(
         function.get(),
         std::string("[{\"since\": 1},") + data_types + "]",
         browser()));
     EXPECT_EQ(expected_mask, GetRemovalMask());
     EXPECT_EQ(UNPROTECTED_WEB, GetOriginTypeMask());
   }
 
   void RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
       const std::string& key,
-      int expected_mask) {
+      const std::set<const BrowsingDataType*>& expected_mask) {
     RunBrowsingDataRemoveFunctionAndCompareRemovalMask(
         std::string("{\"") + key + "\": true}", expected_mask);
   }
 
   void RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
       const std::string& protectedStr,
       int expected_mask) {
     scoped_refptr<BrowsingDataRemoveFunction> function =
         new BrowsingDataRemoveFunction();
     SCOPED_TRACE(protectedStr);
     EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(
         function.get(),
         "[{\"originTypes\": " + protectedStr + "}, {\"cookies\": true}]",
         browser()));
     EXPECT_EQ(expected_mask, GetOriginTypeMask());
   }
 
   template<class ShortcutFunction>
-  void RunAndCompareRemovalMask(int expected_mask) {
+  void RunAndCompareRemovalMask(
+      const std::set<const BrowsingDataType*>& expected_mask) {
     scoped_refptr<ShortcutFunction> function =
         new ShortcutFunction();
     SCOPED_TRACE(ShortcutFunction::function_name());
     EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(
         function.get(),
         std::string("[{\"since\": 1}]"),
         browser()));
     EXPECT_EQ(expected_mask, GetRemovalMask());
     EXPECT_EQ(UNPROTECTED_WEB, GetOriginTypeMask());
   }
@@ skipping 21 matching lines @@
       expected_since = time.ToJsTime();
     }
     // Even a synchronous function takes nonzero time, but the difference
     // between when the function was called and now should be well under a
     // second, so we'll make sure the requested start time is within 10 seconds.
     // Since the smallest selectable period is an hour, that should be
     // sufficient.
     EXPECT_LE(expected_since, since + 10.0 * 1000.0);
   }
 
-  void SetPrefsAndVerifySettings(int data_type_flags,
-                                 int expected_origin_type_mask,
-                                 int expected_removal_mask) {
+  void SetPrefsAndVerifySettings(
+      const std::set<const BrowsingDataType*>& data_type_flags,
+      int expected_origin_type_mask,
+      const std::set<const BrowsingDataType*>& expected_removal_mask) {
     PrefService* prefs = browser()->profile()->GetPrefs();
     prefs->SetBoolean(browsing_data::prefs::kDeleteCache,
-        !!(data_type_flags & BrowsingDataRemover::REMOVE_CACHE));
+        MaskContains(data_type_flags, &kBrowsingDataTypeCache));
     prefs->SetBoolean(browsing_data::prefs::kDeleteCookies,
-        !!(data_type_flags & BrowsingDataRemover::REMOVE_COOKIES));
+        MaskContains(data_type_flags, &kBrowsingDataTypeCookies));
     prefs->SetBoolean(browsing_data::prefs::kDeleteBrowsingHistory,
-        !!(data_type_flags & BrowsingDataRemover::REMOVE_HISTORY));
+        MaskContains(data_type_flags, &kBrowsingDataTypeHistory));
     prefs->SetBoolean(browsing_data::prefs::kDeleteFormData,
-        !!(data_type_flags & BrowsingDataRemover::REMOVE_FORM_DATA));
+        MaskContains(data_type_flags, &kBrowsingDataTypeFormData));
     prefs->SetBoolean(browsing_data::prefs::kDeleteDownloadHistory,
-        !!(data_type_flags & BrowsingDataRemover::REMOVE_DOWNLOADS));
+        MaskContains(data_type_flags, &kBrowsingDataTypeDownloads));
     prefs->SetBoolean(browsing_data::prefs::kDeleteHostedAppsData,
-        !!(data_type_flags &
-           BrowsingDataRemover::REMOVE_HOSTED_APP_DATA_TESTONLY));
+        MaskContains(data_type_flags, &kBrowsingDataTypeHostedAppDataTestOnly));
     prefs->SetBoolean(browsing_data::prefs::kDeletePasswords,
-        !!(data_type_flags & BrowsingDataRemover::REMOVE_PASSWORDS));
+        MaskContains(data_type_flags, &kBrowsingDataTypePasswords));
     prefs->SetBoolean(prefs::kClearPluginLSODataEnabled,
-        !!(data_type_flags & BrowsingDataRemover::REMOVE_PLUGIN_DATA));
+        MaskContains(data_type_flags, &kBrowsingDataTypePluginData));
 
     scoped_refptr<BrowsingDataSettingsFunction> function =
         new BrowsingDataSettingsFunction();
     SCOPED_TRACE("settings");
     std::unique_ptr<base::Value> result_value(RunFunctionAndReturnSingleResult(
         function.get(), std::string("[]"), browser()));
 
     base::DictionaryValue* result;
     EXPECT_TRUE(result_value->GetAsDictionary(&result));
 
     base::DictionaryValue* options;
     EXPECT_TRUE(result->GetDictionary("options", &options));
     base::DictionaryValue* origin_types;
     EXPECT_TRUE(options->GetDictionary("originTypes", &origin_types));
     int origin_type_mask = GetAsMask(origin_types, "unprotectedWeb",
                                     UNPROTECTED_WEB) |
                           GetAsMask(origin_types, "protectedWeb",
                                     PROTECTED_WEB) |
                           GetAsMask(origin_types, "extension", EXTENSION);
     EXPECT_EQ(expected_origin_type_mask, origin_type_mask);
 
     base::DictionaryValue* data_to_remove;
     EXPECT_TRUE(result->GetDictionary("dataToRemove", &data_to_remove));
-    int removal_mask =
-        GetAsMask(data_to_remove, "appcache",
-                  BrowsingDataRemover::REMOVE_APPCACHE) |
-        GetAsMask(data_to_remove, "cache", BrowsingDataRemover::REMOVE_CACHE) |
-        GetAsMask(data_to_remove, "cookies",
-                  BrowsingDataRemover::REMOVE_COOKIES) |
+    std::set<const BrowsingDataType*> removal_mask;
+    removal_mask.insert(
+        GetAsMask(data_to_remove, "appcache", &kBrowsingDataTypeAppCache));
+    removal_mask.insert(
+        GetAsMask(data_to_remove, "cache", &kBrowsingDataTypeCache));
+    removal_mask.insert(
+        GetAsMask(data_to_remove, "cookies", &kBrowsingDataTypeCookies));
+    removal_mask.insert(
         GetAsMask(data_to_remove, "downloads",
-                  BrowsingDataRemover::REMOVE_DOWNLOADS) |
+                  &kBrowsingDataTypeDownloads));
+    removal_mask.insert(
         GetAsMask(data_to_remove, "fileSystems",
-                  BrowsingDataRemover::REMOVE_FILE_SYSTEMS) |
-        GetAsMask(data_to_remove, "formData",
-                  BrowsingDataRemover::REMOVE_FORM_DATA) |
-        GetAsMask(data_to_remove, "history",
-                  BrowsingDataRemover::REMOVE_HISTORY) |
-        GetAsMask(data_to_remove, "indexedDB",
-                  BrowsingDataRemover::REMOVE_INDEXEDDB) |
+                  &kBrowsingDataTypeFileSystems));
+    removal_mask.insert(
+        GetAsMask(data_to_remove, "formData", &kBrowsingDataTypeFormData));
+    removal_mask.insert(
+        GetAsMask(data_to_remove, "history", &kBrowsingDataTypeHistory));
+    removal_mask.insert(
+        GetAsMask(data_to_remove, "indexedDB", &kBrowsingDataTypeIndexedDB));
+    removal_mask.insert(
         GetAsMask(data_to_remove, "localStorage",
-                  BrowsingDataRemover::REMOVE_LOCAL_STORAGE) |
+                  &kBrowsingDataTypeLocalStorage));
+    removal_mask.insert(
         GetAsMask(data_to_remove, "pluginData",
-                  BrowsingDataRemover::REMOVE_PLUGIN_DATA) |
-        GetAsMask(data_to_remove, "passwords",
-                  BrowsingDataRemover::REMOVE_PASSWORDS) |
+                  &kBrowsingDataTypePluginData));
+    removal_mask.insert(
+        GetAsMask(data_to_remove, "passwords", &kBrowsingDataTypePasswords));
+    removal_mask.insert(
         GetAsMask(data_to_remove, "serviceWorkers",
-                  BrowsingDataRemover::REMOVE_SERVICE_WORKERS) |
+                  &kBrowsingDataTypeServiceWorkers));
+    removal_mask.insert(
         GetAsMask(data_to_remove, "cacheStorage",
-                  BrowsingDataRemover::REMOVE_CACHE_STORAGE) |
-        GetAsMask(data_to_remove, "webSQL",
-                  BrowsingDataRemover::REMOVE_WEBSQL) |
+                  &kBrowsingDataTypeCacheStorage));
+    removal_mask.insert(
+        GetAsMask(data_to_remove, "webSQL", &kBrowsingDataTypeWebSQL));
+    removal_mask.insert(
         GetAsMask(data_to_remove, "serverBoundCertificates",
-                  BrowsingDataRemover::REMOVE_CHANNEL_IDS);
+                  &kBrowsingDataTypeChannelIDs));
+
+    // GetAsMask() adds a nullptr for excluded types.
+    removal_mask.erase(nullptr);
+
     EXPECT_EQ(expected_removal_mask, removal_mask);
   }
 
   // The kAllowDeletingBrowserHistory pref must be set to false before this
   // is called.
   void CheckRemovalPermitted(const std::string& data_types, bool permitted) {
     scoped_refptr<BrowsingDataRemoveFunction> function =
         new BrowsingDataRemoveFunction();
     std::string args = "[{\"since\": 1}," + data_types + "]";
 
@@ skipping 46 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, RemoveBrowsingDataAll) {
   scoped_refptr<BrowsingDataRemoveFunction> function =
       new BrowsingDataRemoveFunction();
   EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(function.get(),
                                                    kRemoveEverythingArguments,
                                                    browser()));
 
   EXPECT_EQ(base::Time::FromDoubleT(1.0), GetBeginTime());
-  EXPECT_EQ((BrowsingDataRemover::REMOVE_SITE_DATA |
-             BrowsingDataRemover::REMOVE_CACHE |
-             BrowsingDataRemover::REMOVE_DOWNLOADS |
-             BrowsingDataRemover::REMOVE_FORM_DATA |
-             BrowsingDataRemover::REMOVE_HISTORY |
-             BrowsingDataRemover::REMOVE_PASSWORDS) &
-             // TODO(benwells): implement clearing of site usage data via the
-             // browsing data API. https://crbug.com/500801.
-             ~BrowsingDataRemover::REMOVE_SITE_USAGE_DATA &
-             // TODO(dmurph): implement clearing of durable storage permission
-             // via the browsing data API. https://crbug.com/500801.
-             ~BrowsingDataRemover::REMOVE_DURABLE_PERMISSION &
-             // We can't remove plugin data inside a test profile.
-             ~BrowsingDataRemover::REMOVE_PLUGIN_DATA,
-            GetRemovalMask());
+  std::set<const BrowsingDataType*> expected_mask =
+      kBrowsingDataTypeSetSiteData;
+  expected_mask.insert(&kBrowsingDataTypeCache);
+  expected_mask.insert(&kBrowsingDataTypeDownloads);
+  expected_mask.insert(&kBrowsingDataTypeFormData);
+  expected_mask.insert(&kBrowsingDataTypeHistory);
+  expected_mask.insert(&kBrowsingDataTypePasswords);
+  // TODO(benwells): implement clearing of site usage data via the
+  // browsing data API. https://crbug.com/500801.
+  expected_mask.erase(&kBrowsingDataTypeSiteUsageData);
+  // TODO(dmurph): implement clearing of durable storage permission
+  // via the browsing data API. https://crbug.com/500801.
+  expected_mask.erase(&kBrowsingDataTypeDurablePermission);
+  // We can't remove plugin data inside a test profile.
+  expected_mask.erase(&kBrowsingDataTypePluginData);
+
+  EXPECT_EQ(expected_mask, GetRemovalMask());
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, BrowsingDataOriginTypeMask) {
   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask("{}", 0);
 
   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
       "{\"unprotectedWeb\": true}", UNPROTECTED_WEB);
   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
       "{\"protectedWeb\": true}", PROTECTED_WEB);
   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
@@ skipping 11 matching lines @@
 
   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
       ("{\"unprotectedWeb\": true, \"protectedWeb\": true, "
        "\"extension\": true}"),
       UNPROTECTED_WEB | PROTECTED_WEB | EXTENSION);
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest,
                        BrowsingDataRemovalMask) {
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "appcache", BrowsingDataRemover::REMOVE_APPCACHE);
+      "appcache", {&kBrowsingDataTypeAppCache});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "cache", BrowsingDataRemover::REMOVE_CACHE);
+      "cache", {&kBrowsingDataTypeCache});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "cookies", BrowsingDataRemover::REMOVE_COOKIES);
+      "cookies", {&kBrowsingDataTypeCookies});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "downloads", BrowsingDataRemover::REMOVE_DOWNLOADS);
+      "downloads", {&kBrowsingDataTypeDownloads});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "fileSystems", BrowsingDataRemover::REMOVE_FILE_SYSTEMS);
+      "fileSystems", {&kBrowsingDataTypeFileSystems});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "formData", BrowsingDataRemover::REMOVE_FORM_DATA);
+      "formData", {&kBrowsingDataTypeFormData});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "history", BrowsingDataRemover::REMOVE_HISTORY);
+      "history", {&kBrowsingDataTypeHistory});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "indexedDB", BrowsingDataRemover::REMOVE_INDEXEDDB);
+      "indexedDB", {&kBrowsingDataTypeIndexedDB});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "localStorage", BrowsingDataRemover::REMOVE_LOCAL_STORAGE);
+      "localStorage", {&kBrowsingDataTypeLocalStorage});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "serverBoundCertificates",
-      BrowsingDataRemover::REMOVE_CHANNEL_IDS);
+      "serverBoundCertificates", {&kBrowsingDataTypeChannelIDs});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "passwords", BrowsingDataRemover::REMOVE_PASSWORDS);
+      "passwords", {&kBrowsingDataTypePasswords});
   // We can't remove plugin data inside a test profile.
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "serviceWorkers", BrowsingDataRemover::REMOVE_SERVICE_WORKERS);
+      "serviceWorkers", {&kBrowsingDataTypeServiceWorkers});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "cacheStorage", BrowsingDataRemover::REMOVE_CACHE_STORAGE);
+      "cacheStorage", {&kBrowsingDataTypeCacheStorage});
   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
-      "webSQL", BrowsingDataRemover::REMOVE_WEBSQL);
+      "webSQL", {&kBrowsingDataTypeWebSQL});
 }
 
 // Test an arbitrary combination of data types.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest,
                        BrowsingDataRemovalMaskCombination) {
   RunBrowsingDataRemoveFunctionAndCompareRemovalMask(
        "{\"appcache\": true, \"cookies\": true, \"history\": true}",
-       BrowsingDataRemover::REMOVE_APPCACHE |
-           BrowsingDataRemover::REMOVE_COOKIES |
-           BrowsingDataRemover::REMOVE_HISTORY);
+       {&kBrowsingDataTypeAppCache,
+           &kBrowsingDataTypeCookies,
+           &kBrowsingDataTypeHistory});
 }
 
 // Make sure the remove() function accepts the format produced by settings().
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest,
                        BrowsingDataRemovalInputFromSettings) {
   PrefService* prefs = browser()->profile()->GetPrefs();
   prefs->SetBoolean(browsing_data::prefs::kDeleteCache, true);
   prefs->SetBoolean(browsing_data::prefs::kDeleteBrowsingHistory, true);
   prefs->SetBoolean(browsing_data::prefs::kDeleteDownloadHistory, true);
   prefs->SetBoolean(browsing_data::prefs::kDeleteCookies, false);
   prefs->SetBoolean(browsing_data::prefs::kDeleteFormData, false);
   prefs->SetBoolean(browsing_data::prefs::kDeleteHostedAppsData, false);
   prefs->SetBoolean(browsing_data::prefs::kDeletePasswords, false);
   prefs->SetBoolean(prefs::kClearPluginLSODataEnabled, false);
-  int expected_mask = BrowsingDataRemover::REMOVE_CACHE |
-        BrowsingDataRemover::REMOVE_DOWNLOADS |
-        BrowsingDataRemover::REMOVE_HISTORY;
+  const std::set<const BrowsingDataType*>& expected_mask = {
+      &kBrowsingDataTypeCache,
+      &kBrowsingDataTypeDownloads,
+      &kBrowsingDataTypeHistory
+  };
   std::string json;
   // Scoping for the traces.
   {
     scoped_refptr<BrowsingDataSettingsFunction> settings_function =
         new BrowsingDataSettingsFunction();
     SCOPED_TRACE("settings_json");
     std::unique_ptr<base::Value> result_value(RunFunctionAndReturnSingleResult(
         settings_function.get(), std::string("[]"), browser()));
 
     base::DictionaryValue* result;
@@ skipping 12 matching lines @@
         remove_function.get(),
         std::string("[{\"since\": 1},") + json + "]",
         browser()));
     EXPECT_EQ(expected_mask, GetRemovalMask());
     EXPECT_EQ(UNPROTECTED_WEB, GetOriginTypeMask());
   }
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, ShortcutFunctionRemovalMask) {
   RunAndCompareRemovalMask<BrowsingDataRemoveAppcacheFunction>(
-      BrowsingDataRemover::REMOVE_APPCACHE);
+      {&kBrowsingDataTypeAppCache});
   RunAndCompareRemovalMask<BrowsingDataRemoveCacheFunction>(
-      BrowsingDataRemover::REMOVE_CACHE);
+      {&kBrowsingDataTypeCache});
   RunAndCompareRemovalMask<BrowsingDataRemoveCookiesFunction>(
-      BrowsingDataRemover::REMOVE_COOKIES |
-      BrowsingDataRemover::REMOVE_CHANNEL_IDS);
+      {&kBrowsingDataTypeCookies, &kBrowsingDataTypeChannelIDs});
   RunAndCompareRemovalMask<BrowsingDataRemoveDownloadsFunction>(
-      BrowsingDataRemover::REMOVE_DOWNLOADS);
+      {&kBrowsingDataTypeDownloads});
   RunAndCompareRemovalMask<BrowsingDataRemoveFileSystemsFunction>(
-      BrowsingDataRemover::REMOVE_FILE_SYSTEMS);
+      {&kBrowsingDataTypeFileSystems});
   RunAndCompareRemovalMask<BrowsingDataRemoveFormDataFunction>(
-      BrowsingDataRemover::REMOVE_FORM_DATA);
+      {&kBrowsingDataTypeFormData});
   RunAndCompareRemovalMask<BrowsingDataRemoveHistoryFunction>(
-      BrowsingDataRemover::REMOVE_HISTORY);
+      {&kBrowsingDataTypeHistory});
   RunAndCompareRemovalMask<BrowsingDataRemoveIndexedDBFunction>(
-      BrowsingDataRemover::REMOVE_INDEXEDDB);
+      {&kBrowsingDataTypeIndexedDB});
   RunAndCompareRemovalMask<BrowsingDataRemoveLocalStorageFunction>(
-      BrowsingDataRemover::REMOVE_LOCAL_STORAGE);
+      {&kBrowsingDataTypeLocalStorage});
   // We can't remove plugin data inside a test profile.
   RunAndCompareRemovalMask<BrowsingDataRemovePasswordsFunction>(
-      BrowsingDataRemover::REMOVE_PASSWORDS);
+      {&kBrowsingDataTypePasswords});
   RunAndCompareRemovalMask<BrowsingDataRemoveServiceWorkersFunction>(
-      BrowsingDataRemover::REMOVE_SERVICE_WORKERS);
+      {&kBrowsingDataTypeServiceWorkers});
   RunAndCompareRemovalMask<BrowsingDataRemoveWebSQLFunction>(
-      BrowsingDataRemover::REMOVE_WEBSQL);
+      {&kBrowsingDataTypeWebSQL});
 }
 
 // Test the processing of the 'delete since' preference.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionSince) {
   SetSinceAndVerify(browsing_data::ALL_TIME);
   SetSinceAndVerify(browsing_data::LAST_HOUR);
   SetSinceAndVerify(browsing_data::LAST_DAY);
   SetSinceAndVerify(browsing_data::LAST_WEEK);
   SetSinceAndVerify(browsing_data::FOUR_WEEKS);
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionEmpty) {
-  SetPrefsAndVerifySettings(0, 0, 0);
+  std::set<const BrowsingDataType*> empty_mask;
+  SetPrefsAndVerifySettings(empty_mask, 0, empty_mask);
 }
 
 // Test straightforward settings, mapped 1:1 to data types.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionSimple) {
-  SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_CACHE, 0,
-                            BrowsingDataRemover::REMOVE_CACHE);
-  SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_HISTORY, 0,
-                            BrowsingDataRemover::REMOVE_HISTORY);
-  SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_FORM_DATA, 0,
-                            BrowsingDataRemover::REMOVE_FORM_DATA);
-  SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_DOWNLOADS, 0,
-                            BrowsingDataRemover::REMOVE_DOWNLOADS);
-  SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_PASSWORDS, 0,
-                            BrowsingDataRemover::REMOVE_PASSWORDS);
+  SetPrefsAndVerifySettings({&kBrowsingDataTypeCache}, 0,
+                            {&kBrowsingDataTypeCache});
+  SetPrefsAndVerifySettings({&kBrowsingDataTypeHistory}, 0,
+                            {&kBrowsingDataTypeHistory});
+  SetPrefsAndVerifySettings({&kBrowsingDataTypeFormData}, 0,
+                            {&kBrowsingDataTypeFormData});
+  SetPrefsAndVerifySettings({&kBrowsingDataTypeDownloads}, 0,
+                            {&kBrowsingDataTypeDownloads});
+  SetPrefsAndVerifySettings({&kBrowsingDataTypePasswords}, 0,
+                            {&kBrowsingDataTypePasswords});
 }
 
 // Test cookie and app data settings.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionSiteData) {
-  int site_data_no_durable_or_usage =
-      BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_SITE_USAGE_DATA &
-      ~BrowsingDataRemover::REMOVE_DURABLE_PERMISSION;
-  int site_data_no_plugins_durable_usage =
-      site_data_no_durable_or_usage & ~BrowsingDataRemover::REMOVE_PLUGIN_DATA;
+  std::set<const BrowsingDataType*> site_data_no_durable_or_usage =
+      kBrowsingDataTypeSetSiteData;
+  site_data_no_durable_or_usage.erase(&kBrowsingDataTypeSiteUsageData);
+  site_data_no_durable_or_usage.erase(&kBrowsingDataTypeDurablePermission);
+  std::set<const BrowsingDataType*> site_data_no_plugins_durable_usage =
+      site_data_no_durable_or_usage;
+  site_data_no_plugins_durable_usage.erase(&kBrowsingDataTypePluginData);
 
-  SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_COOKIES,
-                            UNPROTECTED_WEB,
+  SetPrefsAndVerifySettings({&kBrowsingDataTypeCookies}, UNPROTECTED_WEB,
                             site_data_no_plugins_durable_usage);
   SetPrefsAndVerifySettings(
-      BrowsingDataRemover::REMOVE_HOSTED_APP_DATA_TESTONLY,
-      PROTECTED_WEB,
+      {&kBrowsingDataTypeHostedAppDataTestOnly}, PROTECTED_WEB,
       site_data_no_plugins_durable_usage);
   SetPrefsAndVerifySettings(
-      BrowsingDataRemover::REMOVE_COOKIES |
-          BrowsingDataRemover::REMOVE_HOSTED_APP_DATA_TESTONLY,
-      PROTECTED_WEB | UNPROTECTED_WEB,
-      site_data_no_plugins_durable_usage);
+      {&kBrowsingDataTypeCookies, &kBrowsingDataTypeHostedAppDataTestOnly},
+      PROTECTED_WEB | UNPROTECTED_WEB, site_data_no_plugins_durable_usage);
   SetPrefsAndVerifySettings(
-      BrowsingDataRemover::REMOVE_COOKIES |
-          BrowsingDataRemover::REMOVE_PLUGIN_DATA,
-      UNPROTECTED_WEB,
-      site_data_no_durable_or_usage);
+      {&kBrowsingDataTypeCookies, &kBrowsingDataTypePluginData},
+      UNPROTECTED_WEB, site_data_no_durable_or_usage);
 }
 
 // Test an arbitrary assortment of settings.
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionAssorted) {
-  int site_data_no_plugins_durable_usage =
-      BrowsingDataRemover::REMOVE_SITE_DATA &
-      ~BrowsingDataRemover::REMOVE_DURABLE_PERMISSION &
-      ~BrowsingDataRemover::REMOVE_SITE_USAGE_DATA &
-      ~BrowsingDataRemover::REMOVE_PLUGIN_DATA;
+  std::set<const BrowsingDataType*> site_data_no_plugins_durable_usage =
+      kBrowsingDataTypeSetSiteData;
+  site_data_no_plugins_durable_usage.erase(&kBrowsingDataTypeDurablePermission);
+  site_data_no_plugins_durable_usage.erase(&kBrowsingDataTypeSiteUsageData);
+  site_data_no_plugins_durable_usage.erase(&kBrowsingDataTypePluginData);
+
+  std::set<const BrowsingDataType*> expected_mask =
+      site_data_no_plugins_durable_usage;
+  expected_mask.insert(&kBrowsingDataTypeHistory);
+  expected_mask.insert(&kBrowsingDataTypeDownloads);
 
   SetPrefsAndVerifySettings(
-      BrowsingDataRemover::REMOVE_COOKIES |
-          BrowsingDataRemover::REMOVE_HISTORY |
-          BrowsingDataRemover::REMOVE_DOWNLOADS,
+      {&kBrowsingDataTypeCookies,
+          &kBrowsingDataTypeHistory,
+          &kBrowsingDataTypeDownloads},
     UNPROTECTED_WEB,
-    site_data_no_plugins_durable_usage |
-        BrowsingDataRemover::REMOVE_HISTORY |
-        BrowsingDataRemover::REMOVE_DOWNLOADS);
+    expected_mask);
 }