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

chrome/browser/browsing_data/browsing_data_remover_impl.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 "chrome/browser/browsing_data/browsing_data_remover_impl.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 28 matching lines @@
 #include "net/ssl/channel_id_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ppapi/features/features.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "url/origin.h"
 
 using base::UserMetricsAction;
 using content::BrowserContext;
 using content::BrowserThread;
+using content::BrowsingDataType;
 using content::BrowsingDataFilterBuilder;
 using content::DOMStorageContext;
 
 namespace {
 
 template <typename T>
 void IgnoreArgumentHelper(const base::Closure& callback, T unused_argument) {
   callback.Run();
 }
 
@@ skipping 51 matching lines @@
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::ChannelIDService* channel_id_service =
       rq_context->GetURLRequestContext()->channel_id_service();
   channel_id_service->GetChannelIDStore()->DeleteForDomainsCreatedBetween(
       domain_predicate, delete_begin, delete_end,
       base::Bind(&OnClearedChannelIDsOnIOThread,
                  base::RetainedRef(std::move(rq_context)), callback));
 }
 
+bool IsFilterable(const std::set<const BrowsingDataType*>& remove_mask) {
+  for (const BrowsingDataType* data_type : remove_mask) {
+    if (data_type && !data_type->filterable)

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

Why the null check?

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

In browsing_data_api.cc, there is one place where we need a "datatype or
nothing", which I replaced with "BrowsingDataType non-null or null".

I rewrote that part a bit so that we can DCHECK here.

+      return false;
+  }
+
+  return true;
+}
+
+inline bool MaskContains(const std::set<const BrowsingDataType*>& remove_mask,

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

You could use base::ContainsValue (from base/stl_util.h) instead of this.

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

Done. Thanks!

+                         const BrowsingDataType* data_type) {
+  return remove_mask.find(data_type) != remove_mask.end();
+}
+
 }  // namespace
 
 BrowsingDataRemoverImpl::CompletionInhibitor*
     BrowsingDataRemoverImpl::completion_inhibitor_ = nullptr;
 
 BrowsingDataRemoverImpl::SubTask::SubTask(const base::Closure& forward_callback)
     : is_pending_(false),
       forward_callback_(forward_callback),
       weak_ptr_factory_(this) {
   DCHECK(!forward_callback_.is_null());
@@ skipping 15 matching lines @@
 void BrowsingDataRemoverImpl::SubTask::CompletionCallback() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(is_pending_);
   is_pending_ = false;
   forward_callback_.Run();
 }
 
 BrowsingDataRemoverImpl::BrowsingDataRemoverImpl(
     content::BrowserContext* browser_context)
     : browser_context_(browser_context),
-      remove_mask_(-1),
       origin_type_mask_(-1),
       is_removing_(false),
       sub_task_forward_callback_(
           base::Bind(&BrowsingDataRemoverImpl::NotifyIfDone,
                      base::Unretained(this))),
       synchronous_clear_operations_(sub_task_forward_callback_),
       clear_embedder_data_(sub_task_forward_callback_),
       clear_cache_(sub_task_forward_callback_),
       clear_channel_ids_(sub_task_forward_callback_),
       clear_http_auth_cache_(sub_task_forward_callback_),
@@ skipping 31 matching lines @@
 void BrowsingDataRemoverImpl::SetEmbedderDelegate(
     std::unique_ptr<BrowsingDataRemoverDelegate> embedder_delegate) {
   embedder_delegate_ = std::move(embedder_delegate);
 }
 
 BrowsingDataRemoverDelegate*
 BrowsingDataRemoverImpl::GetEmbedderDelegate() const {
   return embedder_delegate_.get();
 }
 
-void BrowsingDataRemoverImpl::Remove(const base::Time& delete_begin,
-                                 const base::Time& delete_end,
-                                 int remove_mask,
-                                 int origin_type_mask) {
+void BrowsingDataRemoverImpl::Remove(
+    const base::Time& delete_begin,
+    const base::Time& delete_end,
+    const std::set<const BrowsingDataType*>& remove_mask,
+    int origin_type_mask) {
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::unique_ptr<BrowsingDataFilterBuilder>(), nullptr);
 }
 
 void BrowsingDataRemoverImpl::RemoveAndReply(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
+    const std::set<const BrowsingDataType*>& remove_mask,
     int origin_type_mask,
     Observer* observer) {
   DCHECK(observer);
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::unique_ptr<BrowsingDataFilterBuilder>(), observer);
 }
 
 void BrowsingDataRemoverImpl::RemoveWithFilter(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
+    const std::set<const BrowsingDataType*>& remove_mask,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) {
-  DCHECK_EQ(0, remove_mask & ~FILTERABLE_DATATYPES);
+  DCHECK(IsFilterable(remove_mask));
   DCHECK(filter_builder);
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::move(filter_builder), nullptr);
 }
 
 void BrowsingDataRemoverImpl::RemoveWithFilterAndReply(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
+    const std::set<const BrowsingDataType*>& remove_mask,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer) {
-  DCHECK_EQ(0, remove_mask & ~FILTERABLE_DATATYPES);
+  DCHECK(IsFilterable(remove_mask));
   DCHECK(filter_builder);
   DCHECK(observer);
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::move(filter_builder), observer);
 }
 
 void BrowsingDataRemoverImpl::RemoveInternal(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
+    const std::set<const BrowsingDataType*>& remove_mask,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer) {
   DCHECK(!observer || observer_list_.HasObserver(observer))
       << "Every observer must register itself (by calling AddObserver()) "
       << "before observing a removal task.";
 
   // Remove() and RemoveAndReply() pass a null pointer to indicate no filter.
   // No filter is equivalent to one that |IsEmptyBlacklist()|.
   if (!filter_builder) {
@@ skipping 26 matching lines @@
   RemoveImpl(removal_task.delete_begin,
              removal_task.delete_end,
              removal_task.remove_mask,
              *removal_task.filter_builder,
              removal_task.origin_type_mask);
 }
 
 void BrowsingDataRemoverImpl::RemoveImpl(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
+    const std::set<const BrowsingDataType*>& remove_mask,
     const BrowsingDataFilterBuilder& filter_builder,
     int origin_type_mask) {
   // =============== README before adding more storage backends ===============
   //
   // If you're adding a data storage backend that is included among
   // RemoveDataMask::FILTERABLE_DATATYPES, you must do one of the following:
   // 1. Support one of the filters generated by |filter_builder|.
   // 2. Add a comment explaining why is it acceptable in your case to delete all
   //    data without filtering URLs / origins / domains.
   // 3. Do not support partial deletion, i.e. only delete your data if
@@ skipping 25 matching lines @@
   // If this fires, we added a new BrowsingDataHelper::OriginTypeMask without
   // updating the user metrics above.
   static_assert(
       BrowsingDataHelper::ALL == (BrowsingDataHelper::UNPROTECTED_WEB |
                                   BrowsingDataHelper::PROTECTED_WEB |
                                   BrowsingDataHelper::EXTENSION),
       "OriginTypeMask has been updated without updating user metrics");
 
   // Record the combined deletion of cookies and cache.
   CookieOrCacheDeletionChoice choice = NEITHER_COOKIES_NOR_CACHE;
-  if (remove_mask & REMOVE_COOKIES &&
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeCookies) &&
       origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
-    choice = remove_mask & REMOVE_CACHE ? BOTH_COOKIES_AND_CACHE
-                                        : ONLY_COOKIES;
-  } else if (remove_mask & REMOVE_CACHE) {
+    choice = MaskContains(remove_mask, &content::kBrowsingDataTypeCache)
+        ? BOTH_COOKIES_AND_CACHE : ONLY_COOKIES;
+  } else if (MaskContains(remove_mask, &content::kBrowsingDataTypeCache)) {
     choice = ONLY_CACHE;
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "History.ClearBrowsingData.UserDeletedCookieOrCache",
       choice, MAX_CHOICE_VALUE);
 
   // Managed devices and supervised users can have restrictions on history
   // deletion.
   // TODO(crbug.com/668114): This should be provided via ContentBrowserClient
   // once BrowsingDataRemoverImpl moves to content.
   PrefService* prefs =
       Profile::FromBrowserContext(browser_context_)->GetPrefs();
   bool may_delete_history =
       prefs->GetBoolean(prefs::kAllowDeletingBrowserHistory);
 
   //////////////////////////////////////////////////////////////////////////////
   // INITIALIZATION
   base::Callback<bool(const GURL& url)> filter =
       filter_builder.BuildGeneralFilter();
 
   //////////////////////////////////////////////////////////////////////////////
-  // REMOVE_DOWNLOADS
-  if ((remove_mask & REMOVE_DOWNLOADS) && may_delete_history) {
+  // kBrowsingDataTypeDownloads
+  if ((MaskContains(remove_mask, &content::kBrowsingDataTypeDownloads))
+          && may_delete_history) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Downloads"));
     content::DownloadManager* download_manager =
         BrowserContext::GetDownloadManager(browser_context_);
     download_manager->RemoveDownloadsByURLAndTime(filter,
                                                   delete_begin_, delete_end_);
   }
 
   //////////////////////////////////////////////////////////////////////////////
-  // REMOVE_CHANNEL_IDS
+  // kBrowsingDataTypeChannelIDs
   // Channel IDs are not separated for protected and unprotected web
   // origins. We check the origin_type_mask_ to prevent unintended deletion.
-  if (remove_mask & REMOVE_CHANNEL_IDS &&
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeChannelIDs) &&
       origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     content::RecordAction(
         UserMetricsAction("ClearBrowsingData_ChannelIDs"));
     // Since we are running on the UI thread don't call GetURLRequestContext().
     scoped_refptr<net::URLRequestContextGetter> rq_context =
         content::BrowserContext::GetDefaultStoragePartition(browser_context_)->
           GetURLRequestContext();
     clear_channel_ids_.Start();
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ClearChannelIDsOnIOThread,
                    filter_builder.BuildChannelIDFilter(),
                    delete_begin_, delete_end_, std::move(rq_context),
                    clear_channel_ids_.GetCompletionCallback()));
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // STORAGE PARTITION DATA
   uint32_t storage_partition_remove_mask = 0;
 
   // We ignore the REMOVE_COOKIES request if UNPROTECTED_WEB is not set,
   // so that callers who request REMOVE_SITE_DATA with PROTECTED_WEB
   // don't accidentally remove the cookies that are associated with the
   // UNPROTECTED_WEB origin. This is necessary because cookies are not separated
   // between UNPROTECTED_WEB and PROTECTED_WEB.
-  if (remove_mask & REMOVE_COOKIES &&
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeCookies) &&
       origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_COOKIES;
   }
-  if (remove_mask & REMOVE_LOCAL_STORAGE) {
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeLocalStorage)) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
   }
-  if (remove_mask & REMOVE_INDEXEDDB) {
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeIndexedDB)) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
   }
-  if (remove_mask & REMOVE_WEBSQL) {
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeWebSQL)) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_WEBSQL;
   }
-  if (remove_mask & REMOVE_APPCACHE) {
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeAppCache)) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_APPCACHE;
   }
-  if (remove_mask & REMOVE_SERVICE_WORKERS) {
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeServiceWorkers)) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS;
   }
-  if (remove_mask & REMOVE_CACHE_STORAGE) {
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeCacheStorage)) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE;
   }
-  if (remove_mask & REMOVE_FILE_SYSTEMS) {
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeFileSystems)) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
   }
 
   // Content Decryption Modules used by Encrypted Media store licenses in a
   // private filesystem. These are different than content licenses used by
   // Flash (which are deleted father down in this method).
-  if (remove_mask & REMOVE_MEDIA_LICENSES) {
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeMediaLicenses)) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_PLUGIN_PRIVATE_DATA;
   }
 
   if (storage_partition_remove_mask) {
     clear_storage_partition_data_.Start();
 
     content::StoragePartition* storage_partition;
     if (storage_partition_for_testing_) {
       storage_partition = storage_partition_for_testing_;
@@ skipping 24 matching lines @@
     }
 
     storage_partition->ClearData(
         storage_partition_remove_mask, quota_storage_remove_mask,
         base::Bind(&DoesOriginMatchMaskAndUrls, origin_type_mask_, filter),
         cookie_matcher, delete_begin_, delete_end_,
         clear_storage_partition_data_.GetCompletionCallback());
   }
 
   //////////////////////////////////////////////////////////////////////////////
-  // CACHE
-  if (remove_mask & REMOVE_CACHE) {
+  // kBrowsingDataTypeCache
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeCache)) {
     // Tell the renderers to clear their cache.
     web_cache::WebCacheManager::GetInstance()->ClearCache();
 
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Cache"));
 
     clear_cache_.Start();
     // StoragePartitionHttpCacheDataRemover deletes itself when it is done.
     if (filter_builder.IsEmptyBlacklist()) {
       browsing_data::StoragePartitionHttpCacheDataRemover::CreateForRange(
           BrowserContext::GetDefaultStoragePartition(browser_context_),
           delete_begin_, delete_end_)
           ->Remove(clear_cache_.GetCompletionCallback());
     } else {
       browsing_data::StoragePartitionHttpCacheDataRemover::
           CreateForURLsAndRange(
               BrowserContext::GetDefaultStoragePartition(browser_context_),
               filter, delete_begin_, delete_end_)
               ->Remove(clear_cache_.GetCompletionCallback());
     }
 
     // Tell the shader disk cache to clear.
     content::RecordAction(UserMetricsAction("ClearBrowsingData_ShaderCache"));
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE;
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // Auth cache.
-  if (remove_mask & REMOVE_COOKIES) {
+  if (MaskContains(remove_mask, &content::kBrowsingDataTypeCookies)) {
     scoped_refptr<net::URLRequestContextGetter> request_context =
         BrowserContext::GetDefaultStoragePartition(browser_context_)
             ->GetURLRequestContext();
     clear_http_auth_cache_.Start();
     BrowserThread::PostTaskAndReply(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ClearHttpAuthCacheOnIOThread, std::move(request_context),
                    delete_begin_),
         clear_http_auth_cache_.GetCompletionCallback());
   }
@@ skipping 29 matching lines @@
 }
 
 const base::Time& BrowsingDataRemoverImpl::GetLastUsedBeginTime() {
   return delete_begin_;
 }
 
 const base::Time& BrowsingDataRemoverImpl::GetLastUsedEndTime() {
   return delete_end_;
 }
 
-int BrowsingDataRemoverImpl::GetLastUsedRemovalMask() {
+const std::set<const BrowsingDataType*>&
+BrowsingDataRemoverImpl::GetLastUsedRemovalMask() {
   return remove_mask_;
 }
 
 int BrowsingDataRemoverImpl::GetLastUsedOriginTypeMask() {
   return origin_type_mask_;
 }
 
 BrowsingDataRemoverImpl::RemovalTask::RemovalTask(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    int remove_mask,
+    const std::set<const BrowsingDataType*>& remove_mask,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer)
     : delete_begin(delete_begin),
       delete_end(delete_end),
       remove_mask(remove_mask),
       origin_type_mask(origin_type_mask),
       filter_builder(std::move(filter_builder)),
       observer(observer) {}
 
@@ skipping 55 matching lines @@
 
   if (completion_inhibitor_) {
     completion_inhibitor_->OnBrowsingDataRemoverWouldComplete(
         this, base::Bind(&BrowsingDataRemoverImpl::Notify,
                          weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   Notify();
 }