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

content/browser/storage_partition_impl_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 51 matching lines @@
 const storage::StorageType kPersistent = storage::kStorageTypePersistent;
 
 const storage::QuotaClient::ID kClientFile = storage::QuotaClient::kFileSystem;
 
 const uint32_t kAllQuotaRemoveMask =
     StoragePartition::REMOVE_DATA_MASK_APPCACHE |
     StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
     StoragePartition::REMOVE_DATA_MASK_INDEXEDDB |
     StoragePartition::REMOVE_DATA_MASK_WEBSQL;
 
+bool AlwaysTrueCookiePredicate(const net::CanonicalCookie& cookie) {
+  return true;
+}
+
+bool AlwaysFalseCookiePredicate(const net::CanonicalCookie& cookie) {
+  return false;
+}
+
 class AwaitCompletionHelper {
  public:
   AwaitCompletionHelper() : start_(false), already_quit_(false) {}
   virtual ~AwaitCompletionHelper() {}
 
   void BlockUntilNotified() {
     if (!already_quit_) {
       DCHECK(!start_);
       start_ = true;
       base::MessageLoop::current()->Run();
@@ skipping 212 matching lines @@
                   const base::Time delete_begin,
                   const base::Time delete_end,
                   base::RunLoop* run_loop) {
   partition->ClearData(
       StoragePartition::REMOVE_DATA_MASK_COOKIES,
       StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
       GURL(), StoragePartition::OriginMatcherFunction(),
       delete_begin, delete_end, run_loop->QuitClosure());
 }
 
+void ClearCookiesWithMatcher(
+    content::StoragePartition* partition,
+    const base::Time delete_begin,
+    const base::Time delete_end,
+    const StoragePartition::CookieMatcherFunction& cookie_matcher,
+    base::RunLoop* run_loop) {
+  partition->ClearData(StoragePartition::REMOVE_DATA_MASK_COOKIES,
+                       StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
+                       StoragePartition::OriginMatcherFunction(),
+                       cookie_matcher, delete_begin, delete_end,
+                       run_loop->QuitClosure());
+}
+
 void ClearStuff(uint32_t remove_mask,
                 content::StoragePartition* partition,
                 const base::Time delete_begin,
                 const base::Time delete_end,
                 const StoragePartition::OriginMatcherFunction& origin_matcher,
                 base::RunLoop* run_loop) {
   partition->ClearData(
       remove_mask, StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
       GURL(), origin_matcher, delete_begin, delete_end,
       run_loop->QuitClosure());
@@ skipping 508 matching lines @@
 
   base::RunLoop run_loop;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&ClearCookies, partition, an_hour_ago,
                             base::Time::Max(), &run_loop));
   run_loop.Run();
 
   EXPECT_FALSE(tester.ContainsCookie());
 }
 
+TEST_F(StoragePartitionImplTest, RemoveCookieWithMatcher) {
+  RemoveCookieTester tester(browser_context());
+  StoragePartition::CookieMatcherFunction true_predicate =
+      base::Bind(&AlwaysTrueCookiePredicate);
+
+  StoragePartition::CookieMatcherFunction false_predicate =
+      base::Bind(&AlwaysFalseCookiePredicate);
+
+  tester.AddCookie();
+  ASSERT_TRUE(tester.ContainsCookie());
+
+  StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
+      BrowserContext::GetDefaultStoragePartition(browser_context()));
+  partition->SetURLRequestContext(browser_context()->GetRequestContext());
+
+  // Return false from our predicate, and make sure the cookies is still around.
+  base::RunLoop run_loop;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&ClearCookiesWithMatcher, partition, base::Time(),
+                            base::Time::Max(), false_predicate, &run_loop));
+  run_loop.RunUntilIdle();
+  EXPECT_TRUE(tester.ContainsCookie());
+
+  // Now we return true from our predicate.
+  base::RunLoop run_loop2;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&ClearCookiesWithMatcher, partition, base::Time(),
+                            base::Time::Max(), true_predicate, &run_loop2));
+  run_loop2.RunUntilIdle();
+  EXPECT_FALSE(tester.ContainsCookie());
+}
+
 TEST_F(StoragePartitionImplTest, RemoveUnprotectedLocalStorageForever) {
   // Protect kOrigin1.
   scoped_refptr<MockSpecialStoragePolicy> mock_policy =
       new MockSpecialStoragePolicy;
   mock_policy->AddProtected(kOrigin1.GetOrigin());
 
   RemoveLocalStorageTester tester(browser_context());
 
   tester.AddDOMStorageTestData();
   EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin1));
@@ skipping 102 matching lines @@
       CanonicalCookie::Create(url2, "A=B;domain=.example.com", now, options));
   invalid_cookies.push_back(CanonicalCookie::Create(url3, "A=B", now, options));
 
   for (const auto& cookie : valid_cookies)
     EXPECT_TRUE(predicate.Run(*cookie)) << cookie->DebugString();
   for (const auto& cookie : invalid_cookies)
     EXPECT_FALSE(predicate.Run(*cookie)) << cookie->DebugString();
 }
 
 }  // namespace content