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

ios/net/cookies/cookie_store_ios.mm

 // Copyright 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 "ios/net/cookies/cookie_store_ios.h"
 
 #import <Foundation/Foundation.h>
 #include <stddef.h>
 
 #include "base/bind.h"
@@ skipping 232 matching lines @@
                             base::Time time_end,
                             NSHTTPCookie* cookie,
                             base::Time creation_time) {
   return time_begin <= creation_time &&
          (time_end.is_null() || creation_time <= time_end);
 }
 
 // Tests whether the |creation_time| of |cookie| is in the time range defined
 // by |time_begin| and |time_end| and the cookie host match |host|. A null
 // |time_end| means end-of-time.
-bool IsCookieCreatedBetweenForHost(base::Time time_begin,
-                                   base::Time time_end,
-                                   NSString* host,
-                                   NSHTTPCookie* cookie,
-                                   base::Time creation_time) {
-  NSString* domain = [cookie domain];
-  return [domain characterAtIndex:0] != '.' &&
-         [domain caseInsensitiveCompare:host] == NSOrderedSame &&
-         IsCookieCreatedBetween(time_begin, time_end, cookie, creation_time);
+bool IsCookieCreatedBetweenWithPredicate(
+    base::Time time_begin,
+    base::Time time_end,
+    const net::CookieStore::CookiePredicate& predicate,
+    NSHTTPCookie* cookie,
+    base::Time creation_time) {
+  if (predicate.is_null())
+    return false;
+  CanonicalCookie canonical_cookie =
+      CanonicalCookieFromSystemCookie(cookie, creation_time);
+  return IsCookieCreatedBetween(time_begin, time_end, cookie, creation_time) &&
+         predicate.Run(canonical_cookie);
 }
 
 // Adds cookies in |cookies| with name |name| to |filtered|.
 void OnlyCookiesWithName(const net::CookieList& cookies,
                          const std::string& name,
                          net::CookieList* filtered) {
   for (const auto& cookie : cookies) {
     if (cookie.Name() == name)
       filtered->push_back(cookie);
   }
@@ skipping 409 matching lines @@
                      WrapDeleteCallback(callback)));
       break;
     case SYNCHRONIZED:
       CookieFilterFunction filter =
           base::Bind(&IsCookieCreatedBetween, delete_begin, delete_end);
       DeleteCookiesWithFilter(filter, callback);
       break;
   }
 }
 
-void CookieStoreIOS::DeleteAllCreatedBetweenForHostAsync(
-    const base::Time delete_begin,
-    const base::Time delete_end,
-    const GURL& url,
+void CookieStoreIOS::DeleteAllCreatedBetweenWithPredicateAsync(
+    const base::Time& delete_begin,
+    const base::Time& delete_end,
+    const CookiePredicate& predicate,
     const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
-      cookie_monster_->DeleteAllCreatedBetweenForHostAsync(
-          delete_begin, delete_end, url, WrapDeleteCallback(callback));
+      cookie_monster_->DeleteAllCreatedBetweenWithPredicateAsync(
+          delete_begin, delete_end, predicate, WrapDeleteCallback(callback));
       break;
     case SYNCHRONIZING:
       tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::DeleteAllCreatedBetweenForHostAsync,
-                     weak_factory_.GetWeakPtr(), delete_begin, delete_end, url,
-                     WrapDeleteCallback(callback)));
+          base::Bind(&CookieStoreIOS::DeleteAllCreatedBetweenWithPredicateAsync,
+                     weak_factory_.GetWeakPtr(), delete_begin, delete_end,
+                     predicate, WrapDeleteCallback(callback)));
       break;
     case SYNCHRONIZED:
-      NSString* host = base::SysUTF8ToNSString(url.host());
-      CookieFilterFunction filter = base::Bind(IsCookieCreatedBetweenForHost,
-                                               delete_begin, delete_end, host);
+      CookieFilterFunction filter =
+          base::Bind(IsCookieCreatedBetweenWithPredicate, delete_begin,
+                     delete_end, predicate);
       DeleteCookiesWithFilter(filter, callback);
       break;
   }
 }
 
 void CookieStoreIOS::DeleteSessionCookiesAsync(const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
@@ skipping 427 matching lines @@
                     weak_factory_.GetWeakPtr(), callback);
 }
 
 base::Closure CookieStoreIOS::WrapClosure(const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Bind(&CookieStoreIOS::UpdateCachesAfterClosure,
                     weak_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace net