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 55 matching lines @@
         end,
         base::Bind(&OnClearedCookies, callback));
   } else {
     cookie_store->DeleteAllCreatedBetweenForHostAsync(
         begin,
         end,
         storage_origin, base::Bind(&OnClearedCookies, callback));
   }
 }
 
+void ClearCookiesOnIOThreadWithCookieMatcher(
+    const scoped_refptr<net::URLRequestContextGetter>& rq_context,
+    const base::Time begin,
+    const base::Time end,
+    const StoragePartition::CookieMatcherFunction& cookie_matcher,
+    const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  net::CookieStore* cookie_store =
+      rq_context->GetURLRequestContext()->cookie_store();
+  if (cookie_matcher.is_null()) {
+    cookie_store->DeleteAllCreatedBetweenAsync(
+        begin, end, base::Bind(&OnClearedCookies, callback));
+  } else {
+    cookie_store->DeleteAllCreatedBetweenWithPredicateAsync(
+        begin, end, cookie_matcher, 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();
   }
 }
 
 void OnQuotaManagedOriginDeleted(const GURL& origin,
@@ skipping 154 matching lines @@
   void DecrementTaskCountOnIO();
 
   void ClearDataOnIOThread(
       const scoped_refptr<storage::QuotaManager>& quota_manager,
       const base::Time begin,
       const scoped_refptr<storage::SpecialStoragePolicy>&
           special_storage_policy,
       const StoragePartition::OriginMatcherFunction& origin_matcher);
 
   void ClearOriginsOnIOThread(
+
       storage::QuotaManager* quota_manager,
       const scoped_refptr<storage::SpecialStoragePolicy>&
           special_storage_policy,
       const StoragePartition::OriginMatcherFunction& origin_matcher,
       const base::Closure& callback,
       const std::set<GURL>& origins,
       storage::StorageType quota_storage_type);
 
   // All of these data are accessed on IO thread.
   uint32_t remove_mask;
@@ skipping 21 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 293 matching lines @@
     const mojo::String& origin,
     mojo::InterfaceRequest<LevelDBWrapper> request) {
   dom_storage_context_->OpenLocalStorage(origin, 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 124 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,
-                   decrement_callback));
+    // We will never have both a storage_origin and a cookie_matcher.
+    if (cookie_matcher.is_null()) {
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::Bind(&ClearCookiesOnIOThread, make_scoped_refptr(rq_context),
+                     begin, end, storage_origin, decrement_callback));
+    } else {
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::Bind(&ClearCookiesOnIOThreadWithCookieMatcher,
+                     make_scoped_refptr(rq_context), begin, end, 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();
     BrowserThread::PostTask(
@@ skipping 53 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