Add removal filter support for Cookies, Storage, and Content Settings.

content/browser/storage_partition_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 "content/browser/storage_partition_impl.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 39 matching lines @@
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&OnClearedCookies, callback, num_deleted));
     return;
   }
 
   callback.Run();
 }
 
+// Cookie matcher and storage_origin are never both populated.
 void ClearCookiesOnIOThread(
     const scoped_refptr<net::URLRequestContextGetter>& rq_context,
     const base::Time begin,
     const base::Time end,
     const GURL& storage_origin,
+    const StoragePartition::CookieMatcherFunction& cookie_matcher,
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  net::CookieStore* cookie_store = rq_context->
-      GetURLRequestContext()->cookie_store();
-  if (storage_origin.is_empty()) {
-    cookie_store->DeleteAllCreatedBetweenAsync(
-        begin,
-        end,
-        base::Bind(&OnClearedCookies, callback));
-  } else {
+  DCHECK(cookie_matcher.is_null() || storage_origin.is_empty());
+  net::CookieStore* cookie_store =
+      rq_context->GetURLRequestContext()->cookie_store();
+  if (!cookie_matcher.is_null()) {
+    cookie_store->DeleteAllCreatedBetweenWithPredicateAsync(
+        begin, end, cookie_matcher, base::Bind(&OnClearedCookies, callback));
+    return;
+  }
+  if (!storage_origin.is_empty()) {
     // TODO(mkwst): It's not clear whether removing host cookies is the correct
     // behavior. We might want to remove all domain-matching cookies instead.
     // Also, this code path may be dead anyways.
     cookie_store->DeleteAllCreatedBetweenWithPredicateAsync(
         begin, end,
         StoragePartitionImpl::CreatePredicateForHostCookies(storage_origin),
         base::Bind(&OnClearedCookies, callback));
+    return;
   }
+  cookie_store->DeleteAllCreatedBetweenAsync(
+      begin, end, base::Bind(&OnClearedCookies, callback));
 }
 
 void CheckQuotaManagedDataDeletionStatus(size_t* deletion_task_count,
                                          const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (*deletion_task_count == 0) {
     delete deletion_task_count;
     callback.Run();
   }
 }
@@ skipping 203 matching lines @@
         quota_storage_remove_mask(quota_storage_remove_mask),
         callback(callback),
         task_count(0) {}
 
   void IncrementTaskCountOnUI();
   void DecrementTaskCountOnUI();
 
   void ClearDataOnUIThread(
       const GURL& storage_origin,
       const OriginMatcherFunction& origin_matcher,
+      const CookieMatcherFunction& cookie_matcher,
       const base::FilePath& path,
       net::URLRequestContextGetter* rq_context,
       DOMStorageContextWrapper* dom_storage_context,
       storage::QuotaManager* quota_manager,
       storage::SpecialStoragePolicy* special_storage_policy,
       WebRTCIdentityStore* webrtc_identity_store,
       const base::Time begin,
       const base::Time end);
 
   void ClearQuotaManagedDataOnIOThread(
@@ skipping 291 matching lines @@
     mojo::InterfaceRequest<mojom::LevelDBWrapper> request) {
   dom_storage_context_->OpenLocalStorage(
       origin, std::move(observer), std::move(request));
 }
 
 void StoragePartitionImpl::ClearDataImpl(
     uint32_t remove_mask,
     uint32_t quota_storage_remove_mask,
     const GURL& storage_origin,
     const OriginMatcherFunction& origin_matcher,
+    const CookieMatcherFunction& cookie_matcher,
     net::URLRequestContextGetter* rq_context,
     const base::Time begin,
     const base::Time end,
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DataDeletionHelper* helper = new DataDeletionHelper(remove_mask,
                                                       quota_storage_remove_mask,
                                                       callback);
   // |helper| deletes itself when done in
   // DataDeletionHelper::DecrementTaskCountOnUI().
-  helper->ClearDataOnUIThread(storage_origin,
-                              origin_matcher,
-                              GetPath(),
-                              rq_context,
-                              dom_storage_context_.get(),
-                              quota_manager_.get(),
-                              special_storage_policy_.get(),
-                              webrtc_identity_store_.get(),
-                              begin,
-                              end);
+  helper->ClearDataOnUIThread(
+      storage_origin, origin_matcher, cookie_matcher, GetPath(), rq_context,
+      dom_storage_context_.get(), quota_manager_.get(),
+      special_storage_policy_.get(), webrtc_identity_store_.get(), begin, end);
 }
 
 void StoragePartitionImpl::
     QuotaManagedDataDeletionHelper::IncrementTaskCountOnIO() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ++task_count;
 }
 
 void StoragePartitionImpl::
     QuotaManagedDataDeletionHelper::DecrementTaskCountOnIO() {
@@ skipping 112 matching lines @@
   --task_count;
   if (!task_count) {
     callback.Run();
     delete this;
   }
 }
 
 void StoragePartitionImpl::DataDeletionHelper::ClearDataOnUIThread(
     const GURL& storage_origin,
     const OriginMatcherFunction& origin_matcher,
+    const CookieMatcherFunction& cookie_matcher,
     const base::FilePath& path,
     net::URLRequestContextGetter* rq_context,
     DOMStorageContextWrapper* dom_storage_context,
     storage::QuotaManager* quota_manager,
     storage::SpecialStoragePolicy* special_storage_policy,
     WebRTCIdentityStore* webrtc_identity_store,
     const base::Time begin,
     const base::Time end) {
   DCHECK_NE(remove_mask, 0u);
   DCHECK(!callback.is_null());
 
   IncrementTaskCountOnUI();
   base::Closure decrement_callback = base::Bind(
       &DataDeletionHelper::DecrementTaskCountOnUI, base::Unretained(this));
 
   if (remove_mask & REMOVE_DATA_MASK_COOKIES) {
     // Handle the cookies.
     IncrementTaskCountOnUI();
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&ClearCookiesOnIOThread,
-                   make_scoped_refptr(rq_context), begin, end, storage_origin,
+        base::Bind(&ClearCookiesOnIOThread, make_scoped_refptr(rq_context),
+                   begin, end, storage_origin, cookie_matcher,
                    decrement_callback));
   }
 
   if (remove_mask & REMOVE_DATA_MASK_INDEXEDDB ||
       remove_mask & REMOVE_DATA_MASK_WEBSQL ||
       remove_mask & REMOVE_DATA_MASK_APPCACHE ||
       remove_mask & REMOVE_DATA_MASK_FILE_SYSTEMS ||
       remove_mask & REMOVE_DATA_MASK_SERVICE_WORKERS ||
       remove_mask & REMOVE_DATA_MASK_CACHE_STORAGE) {
     IncrementTaskCountOnUI();
@@ skipping 54 matching lines @@
   DecrementTaskCountOnUI();
 }
 
 void StoragePartitionImpl::ClearDataForOrigin(
     uint32_t remove_mask,
     uint32_t quota_storage_remove_mask,
     const GURL& storage_origin,
     net::URLRequestContextGetter* request_context_getter,
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  ClearDataImpl(remove_mask,
-                quota_storage_remove_mask,
-                storage_origin,
-                OriginMatcherFunction(),
-                request_context_getter,
-                base::Time(),
-                base::Time::Max(),
+  ClearDataImpl(remove_mask, quota_storage_remove_mask, storage_origin,
+                OriginMatcherFunction(), CookieMatcherFunction(),
+                request_context_getter, base::Time(), base::Time::Max(),
                 callback);
 }
 
 void StoragePartitionImpl::ClearData(
     uint32_t remove_mask,
     uint32_t quota_storage_remove_mask,
     const GURL& storage_origin,
     const OriginMatcherFunction& origin_matcher,
     const base::Time begin,
     const base::Time end,
     const base::Closure& callback) {
   ClearDataImpl(remove_mask, quota_storage_remove_mask, storage_origin,
-                origin_matcher, GetURLRequestContext(), begin, end, callback);
+                origin_matcher, CookieMatcherFunction(), GetURLRequestContext(),
+                begin, end, callback);
+}
+
+void StoragePartitionImpl::ClearData(
+    uint32_t remove_mask,
+    uint32_t quota_storage_remove_mask,
+    const OriginMatcherFunction& origin_matcher,
+    const CookieMatcherFunction& cookie_matcher,
+    const base::Time begin,
+    const base::Time end,
+    const base::Closure& callback) {
+  ClearDataImpl(remove_mask, quota_storage_remove_mask, GURL(), origin_matcher,
+                cookie_matcher, GetURLRequestContext(), begin, end, callback);
 }
 
 void StoragePartitionImpl::Flush() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (GetDOMStorageContext())
     GetDOMStorageContext()->Flush();
 }
 
 WebRTCIdentityStore* StoragePartitionImpl::GetWebRTCIdentityStore() {
   return webrtc_identity_store_.get();
@@ skipping 22 matching lines @@
     net::URLRequestContextGetter* url_request_context) {
   url_request_context_ = url_request_context;
 }
 
 void StoragePartitionImpl::SetMediaURLRequestContext(
     net::URLRequestContextGetter* media_url_request_context) {
   media_url_request_context_ = media_url_request_context;
 }
 
 }  // namespace content