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

chrome/browser/android/preferences/pref_service_bridge.cc

 // Copyright 2014 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/android/preferences/pref_service_bridge.h"
 
 #include <jni.h>
 #include <stddef.h>
 
+#include <algorithm>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/jni_weak_ref.h"
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.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/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/engagement/important_sites_util.h"
 #include "chrome/browser/history/web_history_service_factory.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/translate/chrome_translate_client.h"
 #include "chrome/browser/ui/android/android_about_app_info.h"
 #include "chrome/common/channel_info.h"
@@ skipping 570 matching lines @@
     const JavaParamRef<jobjectArray>& jexcluding_domains,
     const JavaParamRef<jintArray>& jexcluding_domain_reasons,
     const JavaParamRef<jobjectArray>& jignoring_domains,
     const JavaParamRef<jintArray>& jignoring_domain_reasons) {
   BrowsingDataRemover* browsing_data_remover =
       BrowsingDataRemoverFactory::GetForBrowserContext(GetOriginalProfile());
 
   std::vector<int> data_types_vector;
   base::android::JavaIntArrayToIntVector(env, data_types, &data_types_vector);
 
-  int remove_mask = 0;
+  std::set<const content::BrowsingDataType*> remove_mask;
   for (const int data_type : data_types_vector) {
     switch (static_cast<browsing_data::BrowsingDataType>(data_type)) {
       case browsing_data::HISTORY:
-        remove_mask |= BrowsingDataRemover::REMOVE_HISTORY;
+        remove_mask.insert(&kBrowsingDataTypeHistory);
         break;
       case browsing_data::CACHE:
-        remove_mask |= BrowsingDataRemover::REMOVE_CACHE;
+        remove_mask.insert(&kBrowsingDataTypeCache);
         break;
       case browsing_data::COOKIES:
-        remove_mask |= BrowsingDataRemover::REMOVE_COOKIES;
-        remove_mask |= BrowsingDataRemover::REMOVE_SITE_DATA;
+        remove_mask.insert(&kBrowsingDataTypeCookies);
+        remove_mask.insert(kBrowsingDataTypeSetSiteData.begin(),
+                           kBrowsingDataTypeSetSiteData.end());
         break;
       case browsing_data::PASSWORDS:
-        remove_mask |= BrowsingDataRemover::REMOVE_PASSWORDS;
+        remove_mask.insert(&kBrowsingDataTypePasswords);
         break;
       case browsing_data::FORM_DATA:
-        remove_mask |= BrowsingDataRemover::REMOVE_FORM_DATA;
+        remove_mask.insert(&kBrowsingDataTypeFormData);
         break;
       case browsing_data::BOOKMARKS:
         // Bookmarks are deleted separately on the Java side.
         NOTREACHED();
         break;
       case browsing_data::NUM_TYPES:
         NOTREACHED();
     }
   }
   std::vector<std::string> excluding_domains;
@@ skipping 16 matching lines @@
   }
 
   if (!excluding_domains.empty() || !ignoring_domains.empty()) {
     ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
         GetOriginalProfile(), excluding_domains, excluding_domain_reasons,
         ignoring_domains, ignoring_domain_reasons);
   }
 
   // Delete the types protected by Important Sites with a filter,
   // and the rest completely.
-  int filterable_mask =
-      remove_mask & BrowsingDataRemover::IMPORTANT_SITES_DATATYPES;
-  int nonfilterable_mask = remove_mask &
-      ~BrowsingDataRemover::IMPORTANT_SITES_DATATYPES;
+  std::set<const content::BrowsingDataType*> filterable_mask;
+  std::set_intersection(
+      remove_mask.begin(), remove_mask.end(),
+      kBrowsingDataTypeSetImportantSites.begin(),
+      kBrowsingDataTypeSetImportantSites.end(),
+      std::inserter(filterable_mask, filterable_mask.begin()));
+
+  std::set<const content::BrowsingDataType*> nonfilterable_mask;
+  std::set_difference(
+      remove_mask.begin(), remove_mask.end(),
+      filterable_mask.begin(), filterable_mask.end(),
+      std::inserter(nonfilterable_mask, nonfilterable_mask.begin()));
 
   // ClearBrowsingDataObserver deletes itself when |browsing_data_remover| is
   // done with both removal tasks.
   ClearBrowsingDataObserver* observer = new ClearBrowsingDataObserver(
       env, obj, browsing_data_remover, 2 /* tasks_count */);
 
   browsing_data::TimePeriod period =
       static_cast<browsing_data::TimePeriod>(time_period);
   browsing_data::RecordDeletionForPeriod(period);
 
-  if (filterable_mask) {
+  if (!filterable_mask.empty()) {
     browsing_data_remover->RemoveWithFilterAndReply(
         browsing_data::CalculateBeginDeleteTime(period),
         browsing_data::CalculateEndDeleteTime(period),
         filterable_mask, BrowsingDataHelper::UNPROTECTED_WEB,
         std::move(filter_builder), observer);
   } else {
     // Make sure |observer| doesn't wait for the filtered task.
     observer->OnBrowsingDataRemoverDone();
   }
 
-  if (nonfilterable_mask) {
+  if (!nonfilterable_mask.empty()) {
     browsing_data_remover->RemoveAndReply(
         browsing_data::CalculateBeginDeleteTime(period),
         browsing_data::CalculateEndDeleteTime(period),
         nonfilterable_mask, BrowsingDataHelper::UNPROTECTED_WEB, observer);
   } else {
     // Make sure |observer| doesn't wait for the non-filtered task.
     observer->OnBrowsingDataRemoverDone();
   }
 }
 
@@ skipping 520 matching lines @@
 
   return ConvertJavaStringToUTF8(android_permission);
 }
 
 static void SetSupervisedUserId(JNIEnv* env,
                                 const JavaParamRef<jobject>& obj,
                                 const JavaParamRef<jstring>& pref) {
   GetPrefService()->SetString(prefs::kSupervisedUserId,
                               ConvertJavaStringToUTF8(env, pref));
 }