Split browsing data masks 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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
-#include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/browsing_data/content/storage_partition_http_cache_data_remover.h"
 #include "components/prefs/pref_service.h"
 #include "components/web_cache/browser/web_cache_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/browsing_data_filter_builder.h"
 #include "content/public/browser/content_browser_client.h"
@@ skipping 27 matching lines @@
   callback.Run();
 }
 
 // Another convenience method to turn a callback without arguments into one that
 // accepts (and ignores) a single argument.
 template <typename T>
 base::Callback<void(T)> IgnoreArgument(const base::Closure& callback) {
   return base::Bind(&IgnoreArgumentHelper<T>, callback);
 }
 
-// Helper to create callback for BrowsingDataRemoverImpl::DoesOriginMatchMask.
 bool DoesOriginMatchMaskAndUrls(
+    const base::WeakPtr<BrowsingDataRemoverImpl>& remover_weak_ptr,
     int origin_type_mask,
     const base::Callback<bool(const GURL&)>& predicate,
     const GURL& origin,
     storage::SpecialStoragePolicy* special_storage_policy) {
+  // If BrowsingDataRemoverImpl is null, it is not possible to determine which
+  // origins should have their data deleted, and so we do not delete
+  // anything. This is not a problem, because this can only happen shortly
+  // before shutdown and thus the deletion would likely not be able to
+  // finish anyway.
+  if (!remover_weak_ptr)
+    return false;
+
   return predicate.Run(origin) &&
-         BrowsingDataHelper::DoesOriginMatchMask(origin, origin_type_mask,
-                                                 special_storage_policy);
+         remover_weak_ptr->DoesOriginMatchMask(origin_type_mask, origin,
+                                               special_storage_policy);
 }
 
 void ClearHttpAuthCacheOnIOThread(
     scoped_refptr<net::URLRequestContextGetter> context_getter,
     base::Time delete_begin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   net::HttpNetworkSession* http_session = context_getter->GetURLRequestContext()
                                               ->http_transaction_factory()
                                               ->GetSession();
@@ skipping 112 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();
 }
 
+bool BrowsingDataRemoverImpl::DoesOriginMatchMask(
+    int origin_type_mask,
+    const GURL& origin,
+    storage::SpecialStoragePolicy* policy) const {
+  const std::vector<std::string>& schemes = url::GetWebStorageSchemes();
+  bool is_web_scheme =
+      (std::find(schemes.begin(), schemes.end(), origin.GetOrigin().scheme()) !=
+       schemes.end());
+
+  // If a websafe origin is unprotected, it matches iff UNPROTECTED_WEB.
+  if ((!policy || !policy->IsStorageProtected(origin.GetOrigin())) &&
+      is_web_scheme && (origin_type_mask & ORIGIN_TYPE_UNPROTECTED_WEB)) {
+    return true;
+  }
+  origin_type_mask &= ~ORIGIN_TYPE_UNPROTECTED_WEB;
+
+  // Hosted applications (protected and websafe origins) iff PROTECTED_WEB.
+  if (policy && policy->IsStorageProtected(origin.GetOrigin()) &&
+      is_web_scheme && (origin_type_mask & ORIGIN_TYPE_PROTECTED_WEB)) {
+    return true;
+  }
+  origin_type_mask &= ~ORIGIN_TYPE_PROTECTED_WEB;
+
+  DCHECK(embedder_delegate_ || !origin_type_mask)
+      << "The mask contains embedder-defined origin types, but there is no "
+      << "embedder delegate to process them.";
+
+  if (embedder_delegate_) {
+    return embedder_delegate_->DoesOriginMatchEmbedderMask(origin_type_mask,
+                                                           origin, policy);
+  }
+
+  return false;
+}
+
 void BrowsingDataRemoverImpl::Remove(const base::Time& delete_begin,
                                  const base::Time& delete_end,
                                  int 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,
     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,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) {
-  DCHECK_EQ(0, remove_mask & ~FILTERABLE_DATATYPES);
   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,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer) {
-  DCHECK_EQ(0, remove_mask & ~FILTERABLE_DATATYPES);
   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,
@@ skipping 60 matching lines @@
 
   // crbug.com/140910: Many places were calling this with base::Time() as
   // delete_end, even though they should've used base::Time::Max().
   DCHECK_NE(base::Time(), delete_end);
 
   delete_begin_ = delete_begin;
   delete_end_ = delete_end;
   remove_mask_ = remove_mask;
   origin_type_mask_ = origin_type_mask;
 
-  if (origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
-    content::RecordAction(
-        UserMetricsAction("ClearBrowsingData_MaskContainsUnprotectedWeb"));
-  }
-  if (origin_type_mask_ & BrowsingDataHelper::PROTECTED_WEB) {
-    content::RecordAction(
-        UserMetricsAction("ClearBrowsingData_MaskContainsProtectedWeb"));
-  }
-  if (origin_type_mask_ & BrowsingDataHelper::EXTENSION) {
-    content::RecordAction(
-        UserMetricsAction("ClearBrowsingData_MaskContainsExtension"));
-  }
-  // 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 &&
-      origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
-    choice = remove_mask & REMOVE_CACHE ? BOTH_COOKIES_AND_CACHE
-                                        : ONLY_COOKIES;
-  } else if (remove_mask & REMOVE_CACHE) {
+  if (remove_mask & DATA_TYPE_COOKIES &&
+      origin_type_mask_ & ORIGIN_TYPE_UNPROTECTED_WEB) {
+    choice =
+        remove_mask & DATA_TYPE_CACHE ? BOTH_COOKIES_AND_CACHE : ONLY_COOKIES;
+  } else if (remove_mask & DATA_TYPE_CACHE) {
     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) {
+  // DATA_TYPE_DOWNLOADS
+  if ((remove_mask & DATA_TYPE_DOWNLOADS) && 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
+  // DATA_TYPE_CHANNEL_IDS
   // 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 &&
-      origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
+  if (remove_mask & DATA_TYPE_CHANNEL_IDS &&
+      origin_type_mask_ & ORIGIN_TYPE_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
+  // We ignore the DATA_TYPE_COOKIES request if UNPROTECTED_WEB is not set,
+  // so that callers who request DATA_TYPE_SITE_DATA with another origin type
   // 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 &&
-      origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
+  // between UNPROTECTED_WEB and other origin types.
+  if (remove_mask & DATA_TYPE_COOKIES &&
+      origin_type_mask_ & ORIGIN_TYPE_UNPROTECTED_WEB) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_COOKIES;
   }
-  if (remove_mask & REMOVE_LOCAL_STORAGE) {
+  if (remove_mask & DATA_TYPE_LOCAL_STORAGE) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
   }
-  if (remove_mask & REMOVE_INDEXEDDB) {
+  if (remove_mask & DATA_TYPE_INDEXED_DB) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
   }
-  if (remove_mask & REMOVE_WEBSQL) {
+  if (remove_mask & DATA_TYPE_WEB_SQL) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_WEBSQL;
   }
-  if (remove_mask & REMOVE_APPCACHE) {
+  if (remove_mask & DATA_TYPE_APP_CACHE) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_APPCACHE;
   }
-  if (remove_mask & REMOVE_SERVICE_WORKERS) {
+  if (remove_mask & DATA_TYPE_SERVICE_WORKERS) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS;
   }
-  if (remove_mask & REMOVE_CACHE_STORAGE) {
+  if (remove_mask & DATA_TYPE_CACHE_STORAGE) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE;
   }
-  if (remove_mask & REMOVE_FILE_SYSTEMS) {
+  if (remove_mask & DATA_TYPE_FILE_SYSTEMS) {
     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 (remove_mask & DATA_TYPE_MEDIA_LICENSES) {
     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_;
     } else {
       storage_partition =
           BrowserContext::GetDefaultStoragePartition(browser_context_);
     }
 
     uint32_t quota_storage_remove_mask =
         ~content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
 
     if (delete_begin_ == base::Time() ||
-        origin_type_mask_ &
-          (BrowsingDataHelper::PROTECTED_WEB | BrowsingDataHelper::EXTENSION)) {
+        ((origin_type_mask_ & ~ORIGIN_TYPE_UNPROTECTED_WEB) != 0)) {
       // If we're deleting since the beginning of time, or we're removing
       // protected origins, then remove persistent quota data.
       quota_storage_remove_mask |=
           content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
     }
 
     // If cookies are supposed to be conditionally deleted from the storage
     // partition, create a cookie matcher function.
     content::StoragePartition::CookieMatcherFunction cookie_matcher;
     if (!filter_builder.IsEmptyBlacklist() &&
         (storage_partition_remove_mask &
             content::StoragePartition::REMOVE_DATA_MASK_COOKIES)) {
       cookie_matcher = filter_builder.BuildCookieFilter();
     }
 
     storage_partition->ClearData(
         storage_partition_remove_mask, quota_storage_remove_mask,
-        base::Bind(&DoesOriginMatchMaskAndUrls, origin_type_mask_, filter),
+        base::Bind(&DoesOriginMatchMaskAndUrls, weak_ptr_factory_.GetWeakPtr(),
+                   origin_type_mask_, filter),
         cookie_matcher, delete_begin_, delete_end_,
         clear_storage_partition_data_.GetCompletionCallback());
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // CACHE
-  if (remove_mask & REMOVE_CACHE) {
+  if (remove_mask & DATA_TYPE_CACHE) {
     // 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 (remove_mask & DATA_TYPE_COOKIES) {
     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 116 matching lines @@
 
   if (completion_inhibitor_) {
     completion_inhibitor_->OnBrowsingDataRemoverWouldComplete(
         this, base::Bind(&BrowsingDataRemoverImpl::Notify,
                          weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   Notify();
 }