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

chrome/browser/extensions/api/browsing_data/browsing_data_api.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.
 
 // Defines the Chrome Extensions BrowsingData API functions, which entail
 // clearing browsing data, and clearing the browser's cache (which, let's be
 // honest, are the same thing), as specified in the extension API JSON.
 
 #include "chrome/browser/extensions/api/browsing_data/browsing_data_api.h"
 
+#include <set>
 #include <string>
 #include <utility>
 
 #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/plugins/plugin_data_remover_helper.h"
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "components/browsing_data/core/browsing_data_utils.h"
 #include "components/browsing_data/core/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 
 using content::BrowserThread;
+using content::BrowsingDataType;
 
 namespace extension_browsing_data_api_constants {
 
 // Parameter name keys.
 const char kDataRemovalPermittedKey[] = "dataRemovalPermitted";
 const char kDataToRemoveKey[] = "dataToRemove";
 const char kOptionsKey[] = "options";
 
 // Type keys.
 const char kAppCacheKey[] = "appcache";
@@ skipping 22 matching lines @@
 // Errors!
 // The placeholder will be filled by the name of the affected data type (e.g.,
 // "history").
 const char kBadDataTypeDetails[] = "Invalid value for data type '%s'.";
 const char kDeleteProhibitedError[] = "Browsing history and downloads are not "
                                       "permitted to be removed.";
 
 }  // namespace extension_browsing_data_api_constants
 
 namespace {
-int MaskForKey(const char* key) {
+
+// TODO(msramek): This function could be simplified to three lines if we ensured
+// that extension API keys are the same as names specified in BrowsingDataType.
+const BrowsingDataType* TypeForKey(const char* key) {
   if (strcmp(key, extension_browsing_data_api_constants::kAppCacheKey) == 0)
-    return BrowsingDataRemover::REMOVE_APPCACHE;
+    return &kBrowsingDataTypeAppCache;
   if (strcmp(key, extension_browsing_data_api_constants::kCacheKey) == 0)
-    return BrowsingDataRemover::REMOVE_CACHE;
+    return &kBrowsingDataTypeCache;
   if (strcmp(key, extension_browsing_data_api_constants::kCookiesKey) == 0) {
-    return BrowsingDataRemover::REMOVE_COOKIES;
+    return &kBrowsingDataTypeCookies;
   }
   if (strcmp(key, extension_browsing_data_api_constants::kDownloadsKey) == 0)
-    return BrowsingDataRemover::REMOVE_DOWNLOADS;
+    return &kBrowsingDataTypeDownloads;
   if (strcmp(key, extension_browsing_data_api_constants::kFileSystemsKey) == 0)
-    return BrowsingDataRemover::REMOVE_FILE_SYSTEMS;
+    return &kBrowsingDataTypeFileSystems;
   if (strcmp(key, extension_browsing_data_api_constants::kFormDataKey) == 0)
-    return BrowsingDataRemover::REMOVE_FORM_DATA;
+    return &kBrowsingDataTypeFormData;
   if (strcmp(key, extension_browsing_data_api_constants::kHistoryKey) == 0)
-    return BrowsingDataRemover::REMOVE_HISTORY;
+    return &kBrowsingDataTypeHistory;
   if (strcmp(key, extension_browsing_data_api_constants::kIndexedDBKey) == 0)
-    return BrowsingDataRemover::REMOVE_INDEXEDDB;
+    return &kBrowsingDataTypeIndexedDB;
   if (strcmp(key, extension_browsing_data_api_constants::kLocalStorageKey) == 0)
-    return BrowsingDataRemover::REMOVE_LOCAL_STORAGE;
+    return &kBrowsingDataTypeLocalStorage;
   if (strcmp(key,
              extension_browsing_data_api_constants::kChannelIDsKey) == 0)
-    return BrowsingDataRemover::REMOVE_CHANNEL_IDS;
+    return &kBrowsingDataTypeChannelIDs;
   if (strcmp(key, extension_browsing_data_api_constants::kPasswordsKey) == 0)
-    return BrowsingDataRemover::REMOVE_PASSWORDS;
+    return &kBrowsingDataTypePasswords;
   if (strcmp(key, extension_browsing_data_api_constants::kPluginDataKey) == 0)
-    return BrowsingDataRemover::REMOVE_PLUGIN_DATA;
+    return &kBrowsingDataTypePluginData;
   if (strcmp(key, extension_browsing_data_api_constants::kServiceWorkersKey) ==
       0)
-    return BrowsingDataRemover::REMOVE_SERVICE_WORKERS;
+    return &kBrowsingDataTypeServiceWorkers;
   if (strcmp(key, extension_browsing_data_api_constants::kCacheStorageKey) == 0)
-    return BrowsingDataRemover::REMOVE_CACHE_STORAGE;
+    return &kBrowsingDataTypeCacheStorage;
   if (strcmp(key, extension_browsing_data_api_constants::kWebSQLKey) == 0)
-    return BrowsingDataRemover::REMOVE_WEBSQL;
+    return &kBrowsingDataTypeWebSQL;
 
-  return 0;
+  return nullptr;
+}
+
+inline bool MaskContains(const std::set<const BrowsingDataType*>& remove_mask,
+                         const BrowsingDataType* data_type) {
+  return remove_mask.find(data_type) != remove_mask.end();
 }
 
 // Returns false if any of the selected data types are not allowed to be
 // deleted.
-bool IsRemovalPermitted(int removal_mask, PrefService* prefs) {
+bool IsRemovalPermitted(const std::set<const BrowsingDataType*>& removal_mask,
+                        PrefService* prefs) {
   // Enterprise policy or user preference might prohibit deleting browser or
   // download history.
-  if ((removal_mask & BrowsingDataRemover::REMOVE_HISTORY) ||
-      (removal_mask & BrowsingDataRemover::REMOVE_DOWNLOADS)) {
+  if (MaskContains(removal_mask, &kBrowsingDataTypeHistory) ||
+      MaskContains(removal_mask, &kBrowsingDataTypeDownloads)) {
     return prefs->GetBoolean(prefs::kAllowDeletingBrowserHistory);
   }
   return true;
 }
 
 }  // namespace
 
 ExtensionFunction::ResponseAction BrowsingDataSettingsFunction::Run() {
   prefs_ = Profile::FromBrowserContext(browser_context())->GetPrefs();
 
@@ skipping 93 matching lines @@
   result->Set(extension_browsing_data_api_constants::kDataRemovalPermittedKey,
               permitted.release());
   return RespondNow(OneArgument(std::move(result)));
 }
 
 void BrowsingDataSettingsFunction::SetDetails(
     base::DictionaryValue* selected_dict,
     base::DictionaryValue* permitted_dict,
     const char* data_type,
     bool is_selected) {
-  bool is_permitted = IsRemovalPermitted(MaskForKey(data_type), prefs_);
+  const std::set<const BrowsingDataType*> removal_mask =
+      { TypeForKey(data_type) };
+  bool is_permitted = IsRemovalPermitted(removal_mask, prefs_);
   selected_dict->SetBoolean(data_type, is_selected && is_permitted);
   permitted_dict->SetBoolean(data_type, is_permitted);
 }
 
 BrowsingDataRemoverFunction::BrowsingDataRemoverFunction() : observer_(this) {}
 
 void BrowsingDataRemoverFunction::OnBrowsingDataRemoverDone() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   observer_.RemoveAll();
@@ skipping 22 matching lines @@
     ms_since_epoch = 0;
 
   // base::Time takes a double that represents seconds since epoch. JavaScript
   // gives developers milliseconds, so do a quick conversion before populating
   // the object. Also, Time::FromDoubleT converts double time 0 to empty Time
   // object. So we need to do special handling here.
   remove_since_ = (ms_since_epoch == 0) ?
       base::Time::UnixEpoch() :
       base::Time::FromDoubleT(ms_since_epoch / 1000.0);
 
   EXTENSION_FUNCTION_VALIDATE(GetRemovalMask(&removal_mask_));

[Bernhard Bauer, 2017/02/17 11:10:44]

You could clear the mask beforehand (unless it already is empty anyway at that
point, if the function was freshly created?), then you don't need that in every
one of the implementations.

[msramek, 2017/02/17 18:00:20]

Done. Good point.

When I have some spare cycles™, I'll want to clean this file up a bit, since
there is a lot of repetitive code.

 
   // Check for prohibited data types.
   if (!IsRemovalPermitted(removal_mask_, GetProfile()->GetPrefs())) {
     error_ = extension_browsing_data_api_constants::kDeleteProhibitedError;
     return false;
   }
 
-  if (removal_mask_ & BrowsingDataRemover::REMOVE_PLUGIN_DATA) {
+  if (MaskContains(removal_mask_, &kBrowsingDataTypePluginData)) {
     // If we're being asked to remove plugin data, check whether it's actually
     // supported.
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(
             &BrowsingDataRemoverFunction::CheckRemovingPluginDataSupported,
             this,
             PluginPrefs::GetForProfile(GetProfile())));
   } else {
     StartRemoving();
   }
 
   // Will finish asynchronously.
   return true;
 }
 
 BrowsingDataRemoverFunction::~BrowsingDataRemoverFunction() {}
 
 void BrowsingDataRemoverFunction::CheckRemovingPluginDataSupported(
     scoped_refptr<PluginPrefs> plugin_prefs) {
   if (!PluginDataRemoverHelper::IsSupported(plugin_prefs.get()))
-    removal_mask_ &= ~BrowsingDataRemover::REMOVE_PLUGIN_DATA;
+    removal_mask_.erase(&kBrowsingDataTypePluginData);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowsingDataRemoverFunction::StartRemoving, this));
 }
 
 void BrowsingDataRemoverFunction::StartRemoving() {
   BrowsingDataRemover* remover =
       BrowsingDataRemoverFactory::GetForBrowserContext(GetProfile());
   // Add a ref (Balanced in OnBrowsingDataRemoverDone)
@@ skipping 56 matching lines @@
       *origin_type_mask |= value ? BrowsingDataHelper::EXTENSION : 0;
     }
   }
 
   return true;
 }
 
 // Parses the |dataToRemove| argument to generate the removal mask.
 // Returns false if parse was not successful, i.e. if 'dataToRemove' is not
 // present or any data-type keys don't have supported (boolean) values.
-bool BrowsingDataRemoveFunction::GetRemovalMask(int* removal_mask) {
+bool BrowsingDataRemoveFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
   base::DictionaryValue* data_to_remove;
   if (!args_->GetDictionary(1, &data_to_remove))
     return false;
 
-  *removal_mask = 0;
+  removal_mask->clear();
   for (base::DictionaryValue::Iterator i(*data_to_remove);
        !i.IsAtEnd();
        i.Advance()) {
     bool selected = false;
     if (!i.value().GetAsBoolean(&selected))
       return false;
     if (selected)
-      *removal_mask |= MaskForKey(i.key().c_str());
+      removal_mask->insert(TypeForKey(i.key().c_str()));
   }
 
   return true;
 }
 
-bool BrowsingDataRemoveAppcacheFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_APPCACHE;
+bool BrowsingDataRemoveAppcacheFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeAppCache);
   return true;
 }
 
-bool BrowsingDataRemoveCacheFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_CACHE;
+bool BrowsingDataRemoveCacheFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeCache);
   return true;
 }
 
-bool BrowsingDataRemoveCookiesFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_COOKIES |
-                  BrowsingDataRemover::REMOVE_CHANNEL_IDS;
+bool BrowsingDataRemoveCookiesFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeCookies);
+  removal_mask->insert(&kBrowsingDataTypeChannelIDs);
   return true;
 }
 
-bool BrowsingDataRemoveDownloadsFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_DOWNLOADS;
+bool BrowsingDataRemoveDownloadsFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeDownloads);
   return true;
 }
 
-bool BrowsingDataRemoveFileSystemsFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_FILE_SYSTEMS;
+bool BrowsingDataRemoveFileSystemsFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeFileSystems);
   return true;
 }
 
-bool BrowsingDataRemoveFormDataFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_FORM_DATA;
+bool BrowsingDataRemoveFormDataFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeFormData);
   return true;
 }
 
-bool BrowsingDataRemoveHistoryFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_HISTORY;
+bool BrowsingDataRemoveHistoryFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeHistory);
   return true;
 }
 
-bool BrowsingDataRemoveIndexedDBFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_INDEXEDDB;
+bool BrowsingDataRemoveIndexedDBFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeIndexedDB);
   return true;
 }
 
-bool BrowsingDataRemoveLocalStorageFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_LOCAL_STORAGE;
+bool BrowsingDataRemoveLocalStorageFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeLocalStorage);
   return true;
 }
 
-bool BrowsingDataRemovePluginDataFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_PLUGIN_DATA;
+bool BrowsingDataRemovePluginDataFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypePluginData);
   return true;
 }
 
-bool BrowsingDataRemovePasswordsFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_PASSWORDS;
+bool BrowsingDataRemovePasswordsFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypePasswords);
   return true;
 }
 
 bool BrowsingDataRemoveServiceWorkersFunction::GetRemovalMask(
-    int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_SERVICE_WORKERS;
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeServiceWorkers);
   return true;
 }
 
-bool BrowsingDataRemoveCacheStorageFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_CACHE_STORAGE;
+bool BrowsingDataRemoveCacheStorageFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeCacheStorage);
   return true;
 }
 
-bool BrowsingDataRemoveWebSQLFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::REMOVE_WEBSQL;
+bool BrowsingDataRemoveWebSQLFunction::GetRemovalMask(
+    std::set<const BrowsingDataType*>* removal_mask) {
+  removal_mask->clear();
+  removal_mask->insert(&kBrowsingDataTypeWebSQL);
   return true;
 }