[CookieStore] Upgrading host-based deleting to predicate-based deleting.

net/cookies/cookie_store_unittest.h

 // 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.
 
 #ifndef NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 #define NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 230 matching lines @@
     callback.WaitUntilDone();
     return callback.result();
   }
 
   int DeleteAllCreatedBetweenForHost(CookieStore* cs,
                                      const base::Time delete_begin,
                                      const base::Time delete_end,
                                      const GURL& url) {
     DCHECK(cs);
     ResultSavingCookieCallback<int> callback;
-    cs->DeleteAllCreatedBetweenForHostAsync(
-        delete_begin, delete_end, url,
-        base::Bind(
-            &ResultSavingCookieCallback<int>::Run,
-            base::Unretained(&callback)));
+    cs->DeleteAllCreatedBetweenWithPredicateAsync(
+        delete_begin, delete_end,
+        CookieStore::CreatePredicateForHostCookies(url),
+        base::Bind(&ResultSavingCookieCallback<int>::Run,
+                   base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
+
+  int DeleteAllCreatedBetweenWithPredicate(
+      CookieStore* cs,
+      const base::Time delete_begin,
+      const base::Time delete_end,
+      const CookieStore::CookiePredicate& predicate) {
+    DCHECK(cs);
+    ResultSavingCookieCallback<int> callback;
+    cs->DeleteAllCreatedBetweenWithPredicateAsync(
+        delete_begin, delete_end, predicate,
+        base::Bind(&ResultSavingCookieCallback<int>::Run,
+                   base::Unretained(&callback)));
+    callback.WaitUntilDone();
+    return callback.result();
+  }
 
   int DeleteSessionCookies(CookieStore* cs) {
     DCHECK(cs);
     ResultSavingCookieCallback<int> callback;
     cs->DeleteSessionCookiesAsync(
         base::Bind(
             &ResultSavingCookieCallback<int>::Run,
             base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
@@ skipping 787 matching lines @@
 
   // This cookie does not match host.
   EXPECT_TRUE(this->SetCookie(cs, url_not_google, "E=F"));
 
   // Delete cookies.
   EXPECT_EQ(3,  // Deletes A=B, C=D, Y=Z
             this->DeleteAllCreatedBetweenForHost(cs, now, base::Time::Max(),
                                                  this->http_www_google_.url()));
 }
 
+namespace {
+static bool CookieHasValue(const std::string& value,
+                           const CanonicalCookie& cookie) {
+  return cookie.Value() == value;
+}
+}
+
+TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetweenWithPredicate) {
+  CookieStore* cs = this->GetCookieStore();
+  GURL url_not_google("http://www.notgoogle.com");

[Mike West, 2016/04/01 07:40:52]

Nit: You could use `this->http_foo_com_.url()` instead.

[dmurph, 2016/04/01 23:16:46]

done.

+  base::Time now = base::Time::Now();
+  std::string desired_value("B");
+
+  // These 3 cookies match the time range and host.
+  EXPECT_TRUE(this->SetCookie(cs, this->http_www_google_.url(), "A=B"));
+  EXPECT_TRUE(this->SetCookie(cs, this->http_www_google_.url(), "C=D"));
+  EXPECT_TRUE(this->SetCookie(cs, this->http_www_google_.url(), "Y=Z"));
+
+  // This cookie does not match host.
+  EXPECT_TRUE(this->SetCookie(cs, url_not_google, "E=B"));
+
+  // Delete cookies.
+  EXPECT_EQ(2,  // Deletes A=B, C=D, Y=Z

[Mike West, 2016/04/01 07:40:52]

This doesn't delete `A=B`, does it?

It would be good to add some checks here to verify that the correct cookies were
removed.

It would also be good to verify the time semantics. That is, if a cookie that
matches the predicate doesn't fall within the created-between span, it shouldn't
be removed.

[dmurph, 2016/04/01 23:16:46]

Done.

+            this->DeleteAllCreatedBetweenWithPredicate(
+                cs, now, base::Time::Max(),
+                base::Bind(&CookieHasValue, desired_value)));
+}
+
 TYPED_TEST_P(CookieStoreTest, TestSecure) {
   CookieStore* cs = this->GetCookieStore();
 
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_google_.url(), "A=B"));
   this->MatchCookieLines("A=B",
                          this->GetCookies(cs, this->http_www_google_.url()));
   this->MatchCookieLines("A=B",
                          this->GetCookies(cs, this->https_www_google_.url()));
 
   EXPECT_TRUE(
@@ skipping 290 matching lines @@
                            TestHostEndsWithDot,
                            InvalidScheme,
                            InvalidScheme_Read,
                            PathTest,
                            EmptyExpires,
                            HttpOnlyTest,
                            TestCookieDeletion,
                            TestDeleteAll,
                            TestDeleteAllCreatedBetween,
                            TestDeleteAllCreatedBetweenForHost,
+                           TestDeleteAllCreatedBetweenWithPredicate,
                            TestSecure,
                            NetUtilCookieTest,
                            OverwritePersistentCookie,
                            CookieOrdering,
                            GetAllCookiesAsync,
                            DeleteCookieAsync,
                            DeleteCanonicalCookieAsync,
                            DeleteSessionCookie);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_STORE_UNITTEST_H_