Revert "Convert SystemCookieStore to Async."

This reverts commit 8505818b.

Reason for revert: This CL is causing CookieStoreIOSTest.SameValueDoesNotCallHook to fail on iPhone 7, iOS 11 devices.

Original change's description:
> Convert SystemCookieStore to Async.
> 
> * Converts SystemCookieStore to Async
> * Add Async functions to NSHTTPSystemCookieStore and keep the synchronous
> functions.
> * Move creation time management to systemCookieStore.
> * Update cookie_store_ios_presistent_unittest & 
> cookie_store_ios_unittests to account for SystemCookieStore changes 
> * (As CookieStoreIOS is using systemCookieStore internally).
> 
> Another CL is in progress to add WKSystemCookieStore & unit_tests for 
> systemCookieStore (to handle async methods) with template for both 
> NSHTTP & WK systemCookieStore.
> 
> Bug: 759229, 759227, 767948
> Change-Id: I1c24c82540f4781a0bec77ebfa4a861ca7433391
> Reviewed-on: https://chromium-review.googlesource.com/675804
> Commit-Queue: Mohammad Refaat <mrefaat@chromium.org>
> Reviewed-by: Eugene But <eugenebut@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#505033}

TBR=mmenke@chromium.org,eugenebut@chromium.org,mrefaat@chromium.org

Change-Id: I43c71a95910d14f4717111a66f0fb0556a91fb8f
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 759229, 759227, 767948
Reviewed-on: https://chromium-review.googlesource.com/691037Reviewed-by: Yuke Liao <liaoyuke@chromium.org>
Commit-Queue: Yuke Liao <liaoyuke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#505178}

ios/chrome/app/startup/BUILD.gn

@@ -57,7 +57,6 @@ source_set("startup") {
     "//ios/chrome/browser:browser_internal",
     "//ios/chrome/browser/browser_state",
     "//ios/chrome/browser/first_run",
-    "//ios/chrome/browser/net:net",
     "//ios/chrome/browser/ntp_snippets",
     "//ios/chrome/browser/web",
     "//ios/chrome/browser/web:web_internal",

ios/chrome/app/startup/client_registration.mm

@@ -4,9 +4,7 @@
 
 #include "ios/chrome/app/startup/client_registration.h"
 
-#include "ios/chrome/browser/net/chrome_cookie_store_ios_client.h"
 #import "ios/chrome/browser/web/chrome_web_client.h"
-#include "ios/net/cookies/cookie_store_ios_client.h"
 #import "ios/web/public/web_client.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
@@ -17,9 +15,6 @@
 
 + (void)registerClients {
   web::SetWebClient(new ChromeWebClient());
-  // Register CookieStoreIOSClient, This is used to provide CookieStoreIOSClient
-  // users with WEB::IO task runner.
-  net::SetCookieStoreIOSClient(new ChromeCookieStoreIOSClient());
 }
 
 @end

ios/chrome/browser/net/chrome_cookie_store_ios_client.h

@@ -7,18 +7,28 @@
 
 #include "base/macros.h"
 #include "base/sequenced_task_runner.h"
+#include "base/threading/thread_checker.h"
 #include "ios/net/cookies/cookie_store_ios_client.h"
 
+@protocol BrowsingDataChangeListening;
+
 // Chrome implementation of net::CookieStoreIOSClient. This class lives on the
 // IOThread.
 class ChromeCookieStoreIOSClient : public net::CookieStoreIOSClient {
  public:
-  ChromeCookieStoreIOSClient();
+  // Creates a CookieStoreIOSClient with a BrowsingDataChangeListening.
+  // |browsing_data_change_listener| cannot be nil.
+  explicit ChromeCookieStoreIOSClient(
+      id<BrowsingDataChangeListening> browsing_data_change_listener);
 
   // CookieStoreIOSClient implementation.
+  void DidChangeCookieStorage() const override;
   scoped_refptr<base::SequencedTaskRunner> GetTaskRunner() const override;
 
  private:
+  base::ThreadChecker thread_checker_;
+  // The listener that is informed of change in browsing data.
+  id<BrowsingDataChangeListening> browsing_data_change_listener_;  // Weak.
   DISALLOW_COPY_AND_ASSIGN(ChromeCookieStoreIOSClient);
 };
 

ios/chrome/browser/net/chrome_cookie_store_ios_client.mm

@@ -4,15 +4,31 @@
 
 #include "ios/chrome/browser/net/chrome_cookie_store_ios_client.h"
 
+#include "base/logging.h"
+#include "base/task_scheduler/post_task.h"
+#import "ios/chrome/browser/browsing_data/browsing_data_change_listening.h"
 #include "ios/web/public/web_thread.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
-ChromeCookieStoreIOSClient::ChromeCookieStoreIOSClient() {}
+ChromeCookieStoreIOSClient::ChromeCookieStoreIOSClient(
+    id<BrowsingDataChangeListening> browsing_data_change_listener)
+    : browsing_data_change_listener_(browsing_data_change_listener) {
+  DCHECK(browsing_data_change_listener);
+  DCHECK_CURRENTLY_ON(web::WebThread::IO);
+}
+
+void ChromeCookieStoreIOSClient::DidChangeCookieStorage() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  [browsing_data_change_listener_ didChangeCookieStorage];
+}
 
 scoped_refptr<base::SequencedTaskRunner>
 ChromeCookieStoreIOSClient::GetTaskRunner() const {
-  return web::WebThread::GetTaskRunnerForThread(web::WebThread::IO);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return base::CreateSequencedTaskRunnerWithTraits(
+      {base::MayBlock(), base::TaskPriority::BACKGROUND});
 }

ios/net/cookies/cookie_store_ios.h

@@ -31,6 +31,8 @@
 
 namespace net {
 
+class CookieCreationTimeManager;
+
 // Observer for changes on |NSHTTPCookieStorge sharedHTTPCookieStorage|.
 class CookieNotificationObserver {
  public:
@@ -156,6 +158,8 @@ class CookieStoreIOS : public net::CookieStore,
   // deleted.
   typedef base::Callback<bool(NSHTTPCookie*, base::Time)> CookieFilterFunction;
 
+  // Clears the system cookie store.
+  void ClearSystemStore();
   // Returns true if the system cookie store policy is
   // |NSHTTPCookieAcceptPolicyAlways|.
   bool SystemCookiesAllowed();
@@ -165,15 +169,12 @@ class CookieStoreIOS : public net::CookieStore,
   // Inherited CookieNotificationObserver methods.
   void OnSystemCookiesChanged() override;
 
-  void DeleteCookiesWithFilterAsync(CookieFilterFunction filter,
-                                    DeleteCallback callback);
-
-  // Flush to CookieMonster from |cookies|, and run |callback|.
-  void FlushStoreFromCookies(base::OnceClosure callback,
-                             NSArray<NSHTTPCookie*>* cookies);
+  void DeleteCookiesWithFilter(const CookieFilterFunction& filter,
+                               DeleteCallback callback);
 
   std::unique_ptr<net::CookieMonster> cookie_monster_;
   std::unique_ptr<SystemCookieStore> system_store_;
+  std::unique_ptr<CookieCreationTimeManager> creation_time_manager_;
   bool metrics_enabled_;
   base::CancelableClosure flush_closure_;
 
@@ -188,22 +189,26 @@ class CookieStoreIOS : public net::CookieStore,
   // the CookieStoreIOS is synchronized and the CookieStore when the
   // CookieStoreIOS is not synchronized.
 
-  // Updates the cookie cache with cookies named |cookie_name| from the current
-  // set of |nscookies| that would be sent with a request for |url|.
-  // |run_callbacks| Run all callbacks registered for cookie named |name| if
-  // CookieCache was changed.
-  void UpdateCacheForCookies(const GURL& gurl,
-                             const std::string& cookie_name,
-                             bool run_callbacks,
-                             NSArray<NSHTTPCookie*>* nscookies);
+  // Fetches any cookies named |name| that would be sent with a request for
+  // |url| from the system cookie store and pushes them onto the back of the
+  // vector pointed to by |cookies|. Returns true if any cookies were pushed
+  // onto the vector, and false otherwise.
+  bool GetSystemCookies(const GURL& url,
+                        const std::string& name,
+                        std::vector<net::CanonicalCookie>* cookies);
 
   // Updates the cookie cache with the current set of system cookies named
-  // |cookie_name| that would be sent with a request for |url|.
-  // |run_callbacks| Run all callbacks registered for cookie named |name| if
-  // CookieCache was changed.
-  void UpdateCacheForCookieFromSystem(const GURL& gurl,
-                                      const std::string& cookie_name,
-                                      bool run_callbacks);
+  // |name| that would be sent with a request for |url|. Returns whether the
+  // cache changed.
+  // |out_removed_cookies|, if not null, will be populated with the cookies that
+  // were removed.
+  // |out_changed_cookies|, if not null, will be populated with the cookies that
+  // were added.
+  bool UpdateCacheForCookieFromSystem(
+      const GURL& gurl,
+      const std::string& name,
+      std::vector<net::CanonicalCookie>* out_removed_cookies,
+      std::vector<net::CanonicalCookie>* out_added_cookies);
 
   // Runs all callbacks registered for cookies named |name| that would be sent
   // with a request for |url|.
@@ -223,6 +228,22 @@ class CookieStoreIOS : public net::CookieStore,
   // asynchronously invoking callbacks if necessary.
   void UpdateCachesFromCookieMonster();
 
+  // Called after cookies are cleared from NSHTTPCookieStorage so that cookies
+  // can be cleared from .binarycookies file. |callback| is called after all the
+  // cookies are deleted (with the total number of cookies deleted).
+  // |num_deleted| contains the number of cookies deleted from
+  // NSHTTPCookieStorage.
+  void DidClearNSHTTPCookieStorageCookies(DeleteCallback callback,
+                                          int num_deleted);
+  // Called after cookies are cleared from .binarycookies files. |callback| is
+  // called after all the cookies are deleted with the total number of cookies
+  // deleted.
+  // |num_deleted_from_nshttp_cookie_storage| contains the number of cookies
+  // deleted from NSHTTPCookieStorage.
+  void DidClearBinaryCookiesFileCookies(
+      DeleteCallback callback,
+      int num_deleted_from_nshttp_cookie_storage);
+
   // Callback-wrapping:
   // When this CookieStoreIOS object is synchronized with the system store,
   // OnSystemCookiesChanged is responsible for updating the cookie cache (and
@@ -250,10 +271,6 @@ class CookieStoreIOS : public net::CookieStore,
   // creation date.
   net::CookieList CanonicalCookieListFromSystemCookies(NSArray* cookies);
 
-  // Runs |callback| on CanonicalCookie List converted from cookies.
-  void RunGetCookieListCallbackOnSystemCookies(GetCookieListCallback callback,
-                                               NSArray<NSHTTPCookie*>* cookies);
-
   // Cached values of system cookies. Only cookies which have an observer added
   // with AddCallbackForCookie are kept in this cache.
   std::unique_ptr<CookieCache> cookie_cache_;

ios/net/cookies/cookie_store_ios.mm

@@ -13,7 +13,6 @@
 #include "base/ios/ios_util.h"
 #include "base/location.h"
 #include "base/logging.h"
-#import "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
@@ -27,6 +26,7 @@
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#import "ios/net/cookies/cookie_creation_time_manager.h"
 #include "ios/net/cookies/cookie_store_ios_client.h"
 #import "ios/net/cookies/ns_http_system_cookie_store.h"
 #import "ios/net/cookies/system_cookie_util.h"
@@ -102,6 +102,30 @@ NotificationTrampoline* NotificationTrampoline::g_notification_trampoline =
 
 #pragma mark Utility functions
 
+// Returns the path to Cookie.binarycookies file on the file system where
+// WKWebView flushes its cookies.
+base::FilePath GetBinaryCookiesFilePath() {
+  base::FilePath path = base::mac::GetUserLibraryPath();
+  // The relative path of the file (from the user library folder) where
+  // WKWebView stores its cookies.
+  const std::string kCookiesFilePath = "Cookies/Cookies.binarycookies";
+  return path.Append(kCookiesFilePath);
+}
+
+// Clears all cookies from the .binarycookies file.
+// Must be called from a thread where IO operations are allowed.
+// Preconditions: There must be no active WKWebViews present in the app.
+// Note that the .binarycookies file is present only on iOS8+.
+void ClearAllCookiesFromBinaryCookiesFile() {
+  base::FilePath path = GetBinaryCookiesFilePath();
+  if (base::PathExists(path)) {
+    bool success = base::DeleteFile(path, false);
+    if (!success) {
+      DLOG(WARNING) << "Failed to remove binarycookies file.";
+    }
+  }
+}
+
 // Builds a NSHTTPCookie from a header cookie line ("Set-Cookie: xxx") and a
 // URL.
 NSHTTPCookie* GetNSHTTPCookieFromCookieLine(const std::string& cookie_line,
@@ -150,28 +174,6 @@ std::string BuildCookieLineWithOptions(NSArray* cookies,
   return base::SysNSStringToUTF8([header valueForKey:@"Cookie"]);
 }
 
-// Returns an empty closure if |callback| is null callback or binds the
-// callback to |success|.
-base::OnceClosure BindSetCookiesCallback(
-    CookieStoreIOS::SetCookiesCallback* callback,
-    bool success) {
-  base::OnceClosure set_callback;
-  if (!callback->is_null()) {
-    set_callback = base::BindOnce(std::move(*callback), success);
-  }
-  return set_callback;
-}
-
-// Runs |callback| on CookieLine generated from |options| and |cookies|.
-void RunGetCookiesCallbackOnSystemCookies(
-    const net::CookieOptions& options,
-    CookieStoreIOS::GetCookiesCallback callback,
-    NSArray<NSHTTPCookie*>* cookies) {
-  if (!callback.is_null()) {
-    std::move(callback).Run(BuildCookieLineWithOptions(cookies, options));
-  }
-}
-
 // Tests whether the |cookie| is a session cookie.
 bool IsCookieSessionCookie(NSHTTPCookie* cookie, base::Time time) {
   return [cookie isSessionOnly];
@@ -297,13 +299,14 @@ void CookieStoreIOS::SetCookieWithOptionsAsync(
                  (!has_explicit_domain || has_valid_domain);
 
   if (success) {
-    system_store_->SetCookieAsync(cookie,
-                                  BindSetCookiesCallback(&callback, true));
-    return;
+    system_store_->SetCookie(cookie);
+    creation_time_manager_->SetCreationTime(
+        cookie,
+        creation_time_manager_->MakeUniqueCreationTime(base::Time::Now()));
   }
 
   if (!callback.is_null())
-    std::move(callback).Run(false);
+    std::move(callback).Run(success);
 }
 
 void CookieStoreIOS::SetCookieWithDetailsAsync(const GURL& url,
@@ -324,6 +327,8 @@ void CookieStoreIOS::SetCookieWithDetailsAsync(const GURL& url,
   // should be written there instead.
   DCHECK(SystemCookiesAllowed());
 
+  bool success = false;
+
   if (creation_time.is_null())
     creation_time = base::Time::Now();
 
@@ -367,14 +372,16 @@ void CookieStoreIOS::SetCookieWithDetailsAsync(const GURL& url,
     NSHTTPCookie* cookie = SystemCookieFromCanonicalCookie(*canonical_cookie);
 
     if (cookie != nil) {
-      system_store_->SetCookieAsync(cookie, &canonical_cookie->CreationDate(),
-                                    BindSetCookiesCallback(&callback, true));
-      return;
+      system_store_->SetCookie(cookie);
+      creation_time_manager_->SetCreationTime(
+          cookie, creation_time_manager_->MakeUniqueCreationTime(
+              canonical_cookie->CreationDate()));
+      success = true;
     }
   }
 
   if (!callback.is_null())
-    std::move(callback).Run(false);
+    std::move(callback).Run(success);
 }
 
 void CookieStoreIOS::SetCanonicalCookieAsync(
@@ -396,8 +403,14 @@ void CookieStoreIOS::SetCanonicalCookieAsync(
   NSHTTPCookie* ns_cookie = SystemCookieFromCanonicalCookie(*cookie.get());
 
   if (ns_cookie != nil) {
-    system_store_->SetCookieAsync(ns_cookie, &cookie->CreationDate(),
-                                  BindSetCookiesCallback(&callback, true));
+    system_store_->SetCookie(ns_cookie);
+    creation_time_manager_->SetCreationTime(
+        ns_cookie,
+        creation_time_manager_->MakeUniqueCreationTime(
+            cookie->CreationDate().is_null() ? base::Time::Now()
+                                             : cookie->CreationDate()));
+    if (!callback.is_null())
+      std::move(callback).Run(true);
     return;
   }
 
@@ -418,11 +431,12 @@ void CookieStoreIOS::GetCookiesWithOptionsAsync(
   // engine.
   DCHECK(!options.exclude_httponly());
 
-  // TODO(crbug.com/459154): If/when iOS supports Same-Site cookies, we'll need
-  // to pass options in here as well.
-  system_store_->GetCookiesForURLAsync(
-      url, base::BindOnce(&RunGetCookiesCallbackOnSystemCookies, options,
-                          base::Passed(&callback)));
+  // TODO(mkwst): If/when iOS supports Same-Site cookies, we'll need to pass
+  // options in here as well. https://crbug.com/459154
+  NSArray* cookies =
+      system_store_->GetCookiesForURL(url, creation_time_manager_.get());
+  if (!callback.is_null())
+    std::move(callback).Run(BuildCookieLineWithOptions(cookies, options));
 }
 
 void CookieStoreIOS::GetCookieListWithOptionsAsync(
@@ -440,10 +454,11 @@ void CookieStoreIOS::GetCookieListWithOptionsAsync(
 
   // TODO(mkwst): If/when iOS supports Same-Site cookies, we'll need to pass
   // options in here as well. https://crbug.com/459154
-  system_store_->GetCookiesForURLAsync(
-      url,
-      base::BindOnce(&CookieStoreIOS::RunGetCookieListCallbackOnSystemCookies,
-                     weak_factory_.GetWeakPtr(), base::Passed(&callback)));
+  NSArray* cookies =
+      system_store_->GetCookiesForURL(url, creation_time_manager_.get());
+  net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(cookies);
+  if (!callback.is_null())
+    std::move(callback).Run(cookie_list);
 }
 
 void CookieStoreIOS::GetAllCookiesAsync(GetCookieListCallback callback) {
@@ -455,33 +470,30 @@ void CookieStoreIOS::GetAllCookiesAsync(GetCookieListCallback callback) {
     cookie_monster_->GetAllCookiesAsync(std::move(callback));
     return;
   }
-  // TODO(crbug.com/459154): If/when iOS supports Same-Site cookies, we'll need
-  // to pass options in here as well.
-  system_store_->GetAllCookiesAsync(
-      base::BindOnce(&CookieStoreIOS::RunGetCookieListCallbackOnSystemCookies,
-                     weak_factory_.GetWeakPtr(), base::Passed(&callback)));
+
+  NSArray* cookies = system_store_->GetAllCookies(creation_time_manager_.get());
+  net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(cookies);
+  if (!callback.is_null()) {
+    std::move(callback).Run(cookie_list);
+  }
 }
 
 void CookieStoreIOS::DeleteCookieAsync(const GURL& url,
                                        const std::string& cookie_name,
                                        base::OnceClosure callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  __block base::OnceClosure shared_callback = std::move(callback);
-  base::WeakPtr<SystemCookieStore> weak_system_store =
-      system_store_->GetWeakPtr();
-  system_store_->GetCookiesForURLAsync(
-      url, base::BindBlockArc(^(NSArray<NSHTTPCookie*>* cookies) {
-        for (NSHTTPCookie* cookie in cookies) {
-          if ([cookie.name
-                  isEqualToString:base::SysUTF8ToNSString(cookie_name)] &&
-              weak_system_store) {
-            weak_system_store->DeleteCookieAsync(
-                cookie, SystemCookieStore::SystemCookieCallback());
-          }
-        }
-        if (!shared_callback.is_null())
-          std::move(shared_callback).Run();
-      }));
+
+  NSArray* cookies =
+      system_store_->GetCookiesForURL(url, creation_time_manager_.get());
+  for (NSHTTPCookie* cookie in cookies) {
+    if ([[cookie name] isEqualToString:base::SysUTF8ToNSString(cookie_name)]) {
+      system_store_->DeleteCookie(cookie);
+      creation_time_manager_->DeleteCreationTime(cookie);
+    }
+  }
+
+  if (!callback.is_null())
+    std::move(callback).Run();
 }
 
 void CookieStoreIOS::DeleteCanonicalCookieAsync(const CanonicalCookie& cookie,
@@ -491,7 +503,7 @@ void CookieStoreIOS::DeleteCanonicalCookieAsync(const CanonicalCookie& cookie,
   // This relies on the fact cookies are given unique creation dates.
   CookieFilterFunction filter = base::Bind(
       IsCookieCreatedBetween, cookie.CreationDate(), cookie.CreationDate());
-  DeleteCookiesWithFilterAsync(std::move(filter), std::move(callback));
+  DeleteCookiesWithFilter(filter, std::move(callback));
 }
 
 void CookieStoreIOS::DeleteAllCreatedBetweenAsync(
@@ -505,7 +517,7 @@ void CookieStoreIOS::DeleteAllCreatedBetweenAsync(
 
   CookieFilterFunction filter = base::Bind(
       &IsCookieCreatedBetween, delete_begin, delete_end);
-  DeleteCookiesWithFilterAsync(std::move(filter), std::move(callback));
+  DeleteCookiesWithFilter(filter, std::move(callback));
 }
 
 void CookieStoreIOS::DeleteAllCreatedBetweenWithPredicateAsync(
@@ -520,7 +532,7 @@ void CookieStoreIOS::DeleteAllCreatedBetweenWithPredicateAsync(
 
   CookieFilterFunction filter = base::Bind(
       IsCookieCreatedBetweenWithPredicate, delete_begin, delete_end, predicate);
-  DeleteCookiesWithFilterAsync(std::move(filter), std::move(callback));
+  DeleteCookiesWithFilter(filter, std::move(callback));
 }
 
 void CookieStoreIOS::DeleteSessionCookiesAsync(DeleteCallback callback) {
@@ -530,7 +542,7 @@ void CookieStoreIOS::DeleteSessionCookiesAsync(DeleteCallback callback) {
     ResetCookieCountMetrics();
 
   CookieFilterFunction filter = base::Bind(&IsCookieSessionCookie);
-  DeleteCookiesWithFilterAsync(std::move(filter), std::move(callback));
+  DeleteCookiesWithFilter(filter, std::move(callback));
 }
 
 void CookieStoreIOS::FlushStore(base::OnceClosure closure) {
@@ -539,19 +551,8 @@ void CookieStoreIOS::FlushStore(base::OnceClosure closure) {
   if (SystemCookiesAllowed()) {
     // If cookies are disabled, the system store is empty, and the cookies are
     // stashed on disk. Do not delete the cookies on the disk in this case.
-    system_store_->GetAllCookiesAsync(
-        base ::BindOnce(&CookieStoreIOS::FlushStoreFromCookies,
-                        weak_factory_.GetWeakPtr(), std::move(closure)));
-    return;
+    WriteToCookieMonster(system_store_->GetAllCookies());
   }
-
-  cookie_monster_->FlushStore(std::move(closure));
-  flush_closure_.Cancel();
-}
-
-void CookieStoreIOS::FlushStoreFromCookies(base::OnceClosure closure,
-                                           NSArray<NSHTTPCookie*>* cookies) {
-  WriteToCookieMonster(cookies);
   cookie_monster_->FlushStore(std::move(closure));
   flush_closure_.Cancel();
 }
@@ -564,6 +565,7 @@ CookieStoreIOS::CookieStoreIOS(
     std::unique_ptr<SystemCookieStore> system_store)
     : cookie_monster_(new net::CookieMonster(persistent_store)),
       system_store_(std::move(system_store)),
+      creation_time_manager_(new CookieCreationTimeManager),
       metrics_enabled_(false),
       cookie_cache_(new CookieCache()),
       weak_factory_(this) {
@@ -598,6 +600,12 @@ base::OnceClosure CookieStoreIOS::WrapClosure(base::OnceClosure callback) {
 #pragma mark -
 #pragma mark Private methods
 
+void CookieStoreIOS::ClearSystemStore() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  system_store_->ClearStore();
+  creation_time_manager_->Clear();
+}
+
 bool CookieStoreIOS::SystemCookiesAllowed() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return system_store_->GetCookieAcceptPolicy() !=
@@ -613,7 +621,7 @@ void CookieStoreIOS::WriteToCookieMonster(NSArray* system_cookies) {
   cookie_list.reserve(cookie_count);
   for (NSHTTPCookie* cookie in system_cookies) {
     cookie_list.push_back(CanonicalCookieFromSystemCookie(
-        cookie, system_store_->GetCookieCreationTime(cookie)));
+        cookie, creation_time_manager_->GetCreationTime(cookie)));
   }
   cookie_monster_->SetAllCookiesAsync(cookie_list, SetCookiesCallback());
 
@@ -622,30 +630,28 @@ void CookieStoreIOS::WriteToCookieMonster(NSArray* system_cookies) {
     UMA_HISTOGRAM_COUNTS_10000("CookieIOS.CookieWrittenCount", cookie_count);
 }
 
-void CookieStoreIOS::DeleteCookiesWithFilterAsync(CookieFilterFunction filter,
-                                                  DeleteCallback callback) {
+void CookieStoreIOS::DeleteCookiesWithFilter(const CookieFilterFunction& filter,
+                                             DeleteCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!filter.is_null());
-  __block DeleteCallback shared_callback = std::move(callback);
-  __block CookieFilterFunction shared_filter = std::move(filter);
-  base::WeakPtr<SystemCookieStore> weak_system_store =
-      system_store_->GetWeakPtr();
-  system_store_->GetAllCookiesAsync(
-      base::BindBlockArc(^(NSArray<NSHTTPCookie*>* cookies) {
-        int to_delete_count = 0;
-        for (NSHTTPCookie* cookie in cookies) {
-          if (weak_system_store &&
-              shared_filter.Run(
-                  cookie, weak_system_store->GetCookieCreationTime(cookie))) {
-            weak_system_store->DeleteCookieAsync(
-                cookie, SystemCookieStore::SystemCookieCallback());
-            to_delete_count++;
-          }
-        }
-
-        if (!shared_callback.is_null())
-          std::move(shared_callback).Run(to_delete_count);
-      }));
+  NSArray* cookies = system_store_->GetAllCookies();
+
+  // Collect the cookies to delete.
+  base::scoped_nsobject<NSMutableArray> to_delete(
+      [[NSMutableArray alloc] init]);
+  for (NSHTTPCookie* cookie in cookies) {
+    base::Time creation_time = creation_time_manager_->GetCreationTime(cookie);
+    if (filter.Run(cookie, creation_time))
+      [to_delete addObject:cookie];
+  }
+
+  // Delete them.
+  for (NSHTTPCookie* cookie in to_delete.get()) {
+    system_store_->DeleteCookie(cookie);
+    creation_time_manager_->DeleteCreationTime(cookie);
+  }
+
+  if (!callback.is_null())
+    std::move(callback).Run([to_delete count]);
 }
 
 void CookieStoreIOS::OnSystemCookiesChanged() {
@@ -653,8 +659,15 @@ void CookieStoreIOS::OnSystemCookiesChanged() {
 
   for (const auto& hook_map_entry : hook_map_) {
     std::pair<GURL, std::string> key = hook_map_entry.first;
-    UpdateCacheForCookieFromSystem(key.first, key.second,
-                                   /*run_callbacks=*/true);
+    std::vector<net::CanonicalCookie> removed_cookies;
+    std::vector<net::CanonicalCookie> added_cookies;
+    if (UpdateCacheForCookieFromSystem(key.first, key.second, &removed_cookies,
+                                       &added_cookies)) {
+      RunCallbacksForCookies(key.first, key.second, removed_cookies,
+                             net::CookieStore::ChangeCause::UNKNOWN_DELETION);
+      RunCallbacksForCookies(key.first, key.second, added_cookies,
+                             net::CookieStore::ChangeCause::INSERTED);
+    }
   }
 
   // Do not schedule a flush if one is already scheduled.
@@ -676,8 +689,9 @@ CookieStoreIOS::AddCallbackForCookie(const GURL& gurl,
   // Prefill cookie cache with all pertinent cookies for |url| if needed.
   std::pair<GURL, std::string> key(gurl, name);
   if (hook_map_.count(key) == 0) {
-    UpdateCacheForCookieFromSystem(gurl, name, /*run_callbacks=*/false);
-    hook_map_[key] = base::MakeUnique<CookieChangedCallbackList>();
+    UpdateCacheForCookieFromSystem(gurl, name, nullptr, nullptr);
+    if (hook_map_.count(key) == 0)
+      hook_map_[key] = base::MakeUnique<CookieChangedCallbackList>();
   }
 
   DCHECK(hook_map_.find(key) != hook_map_.end());
@@ -696,40 +710,16 @@ bool CookieStoreIOS::IsEphemeral() {
   return cookie_monster_->IsEphemeral();
 }
 
-void CookieStoreIOS::UpdateCacheForCookieFromSystem(
+bool CookieStoreIOS::UpdateCacheForCookieFromSystem(
     const GURL& gurl,
-    const std::string& cookie_name,
-    bool run_callbacks) {
+    const std::string& name,
+    std::vector<net::CanonicalCookie>* out_removed_cookies,
+    std::vector<net::CanonicalCookie>* out_added_cookies) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  system_store_->GetCookiesForURLAsync(
-      gurl, base::BindOnce(&CookieStoreIOS::UpdateCacheForCookies,
-                           weak_factory_.GetWeakPtr(), gurl, cookie_name,
-                           run_callbacks));
-}
-
-void CookieStoreIOS::UpdateCacheForCookies(const GURL& gurl,
-                                           const std::string& cookie_name,
-                                           bool run_callbacks,
-                                           NSArray<NSHTTPCookie*>* nscookies) {
-  std::vector<net::CanonicalCookie> cookies;
-  std::vector<net::CanonicalCookie> out_removed_cookies;
-  std::vector<net::CanonicalCookie> out_added_cookies;
-  for (NSHTTPCookie* nscookie in nscookies) {
-    if (base::SysNSStringToUTF8(nscookie.name) == cookie_name) {
-      net::CanonicalCookie canonical_cookie = CanonicalCookieFromSystemCookie(
-          nscookie, system_store_->GetCookieCreationTime(nscookie));
-      cookies.push_back(canonical_cookie);
-    }
-  }
-
-  bool changes = cookie_cache_->Update(
-      gurl, cookie_name, cookies, &out_removed_cookies, &out_added_cookies);
-  if (run_callbacks && changes) {
-    RunCallbacksForCookies(gurl, cookie_name, out_removed_cookies,
-                           net::CookieStore::ChangeCause::UNKNOWN_DELETION);
-    RunCallbacksForCookies(gurl, cookie_name, out_added_cookies,
-                           net::CookieStore::ChangeCause::INSERTED);
-  }
+  std::vector<net::CanonicalCookie> system_cookies;
+  GetSystemCookies(gurl, name, &system_cookies);
+  return cookie_cache_->Update(gurl, name, system_cookies, out_removed_cookies,
+                               out_added_cookies);
 }
 
 void CookieStoreIOS::RunCallbacksForCookies(
@@ -749,6 +739,23 @@ void CookieStoreIOS::RunCallbacksForCookies(
   }
 }
 
+bool CookieStoreIOS::GetSystemCookies(
+    const GURL& url,
+    const std::string& name,
+    std::vector<net::CanonicalCookie>* cookies) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  NSArray* nscookies = system_store_->GetCookiesForURL(url);
+  bool found_cookies = false;
+  for (NSHTTPCookie* nscookie in nscookies) {
+    if (nscookie.name.UTF8String == name) {
+      net::CanonicalCookie canonical_cookie = CanonicalCookieFromSystemCookie(
+          nscookie, creation_time_manager_->GetCreationTime(nscookie));
+      cookies->push_back(canonical_cookie);
+      found_cookies = true;
+    }
+  }
+  return found_cookies;
+}
 
 void CookieStoreIOS::GotCookieListFor(const std::pair<GURL, std::string> key,
                                       const net::CookieList& cookies) {
@@ -767,6 +774,35 @@ void CookieStoreIOS::GotCookieListFor(const std::pair<GURL, std::string> key,
   }
 }
 
+void CookieStoreIOS::DidClearNSHTTPCookieStorageCookies(
+    DeleteCallback delete_callback,
+    int num_deleted) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  CookieStoreIOSClient* client = net::GetCookieStoreIOSClient();
+  DCHECK(client);
+  auto sequenced_task_runner = client->GetTaskRunner();
+  DCHECK(sequenced_task_runner);
+  auto callback = base::BindOnce(
+      &CookieStoreIOS::DidClearBinaryCookiesFileCookies,
+      weak_factory_.GetWeakPtr(), std::move(delete_callback), num_deleted);
+  sequenced_task_runner.get()->PostTaskAndReply(
+      FROM_HERE, base::Bind(&ClearAllCookiesFromBinaryCookiesFile),
+      std::move(callback));
+}
+
+void CookieStoreIOS::DidClearBinaryCookiesFileCookies(
+    DeleteCallback callback,
+    int num_deleted_from_nshttp_cookie_storage) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  CookieStoreIOSClient* client = net::GetCookieStoreIOSClient();
+  DCHECK(client);
+  client->DidChangeCookieStorage();
+  if (!callback.is_null())
+    std::move(callback).Run(num_deleted_from_nshttp_cookie_storage);
+}
+
 void CookieStoreIOS::UpdateCachesFromCookieMonster() {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (const auto& hook_map_entry : hook_map_) {
@@ -806,18 +842,10 @@ CookieStoreIOS::CanonicalCookieListFromSystemCookies(NSArray* cookies) {
   net::CookieList cookie_list;
   cookie_list.reserve([cookies count]);
   for (NSHTTPCookie* cookie in cookies) {
-    base::Time created = system_store_->GetCookieCreationTime(cookie);
+    base::Time created = creation_time_manager_->GetCreationTime(cookie);
     cookie_list.push_back(CanonicalCookieFromSystemCookie(cookie, created));
   }
   return cookie_list;
 }
 
-void CookieStoreIOS::RunGetCookieListCallbackOnSystemCookies(
-    CookieStoreIOS::GetCookieListCallback callback,
-    NSArray<NSHTTPCookie*>* cookies) {
-  if (!callback.is_null()) {
-    std::move(callback).Run(CanonicalCookieListFromSystemCookies(cookies));
-  }
-}
-
 }  // namespace net

ios/net/cookies/cookie_store_ios_client.h

@@ -24,6 +24,13 @@ class CookieStoreIOSClient {
   CookieStoreIOSClient();
   virtual ~CookieStoreIOSClient();
 
+  // Gives the embedder a chance to perform tasks before the cookie storage is
+  // changed.
+  virtual void WillChangeCookieStorage() const;
+
+  // Informs the embedder after the cookie storage has been changed.
+  virtual void DidChangeCookieStorage() const;
+
   // Returns instance of SequencedTaskRunner used for blocking file I/O.
   virtual scoped_refptr<base::SequencedTaskRunner> GetTaskRunner() const;
 

ios/net/cookies/cookie_store_ios_client.mm

@@ -27,6 +27,10 @@ CookieStoreIOSClient::CookieStoreIOSClient() {}
 
 CookieStoreIOSClient::~CookieStoreIOSClient() {}
 
+void CookieStoreIOSClient::WillChangeCookieStorage() const {}
+
+void CookieStoreIOSClient::DidChangeCookieStorage() const {}
+
 scoped_refptr<base::SequencedTaskRunner>
 CookieStoreIOSClient::GetTaskRunner() const {
   return scoped_refptr<base::SequencedTaskRunner>();

ios/net/cookies/cookie_store_ios_persistent_unittest.mm

@@ -56,8 +56,6 @@ class CookieStoreIOSPersistentTest : public testing::Test {
  public:
   CookieStoreIOSPersistentTest()
       : kTestCookieURL("http://foo.google.com/bar"),
-        scoped_cookie_store_ios_client_(
-            base::MakeUnique<TestCookieStoreIOSClient>()),
         backend_(new net::TestPersistentCookieStore),
         store_(
             base::MakeUnique<net::CookieStoreIOSPersistent>(backend_.get())) {
@@ -87,7 +85,6 @@ class CookieStoreIOSPersistentTest : public testing::Test {
 
  protected:
   base::MessageLoop loop_;
-  ScopedTestingCookieStoreIOSClient scoped_cookie_store_ios_client_;
   scoped_refptr<net::TestPersistentCookieStore> backend_;
   std::unique_ptr<net::CookieStoreIOS> store_;
   std::unique_ptr<net::CookieStore::CookieChangedSubscription>

ios/net/cookies/cookie_store_ios_test_util.h

@@ -9,8 +9,6 @@
 #include <vector>
 
 #include "base/callback_forward.h"
-#include "base/task_scheduler/post_task.h"
-#include "ios/net/cookies/cookie_store_ios_client.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store.h"
 #include "url/gurl.h"
@@ -68,26 +66,6 @@ class GetCookieCallback {
   std::string cookie_line_;
 };
 
-class TestCookieStoreIOSClient : public CookieStoreIOSClient {
- public:
-  TestCookieStoreIOSClient();
-  // CookieStoreIOSClient implementation.
-  scoped_refptr<base::SequencedTaskRunner> GetTaskRunner() const override;
-};
-
-class ScopedTestingCookieStoreIOSClient {
- public:
-  explicit ScopedTestingCookieStoreIOSClient(
-      std::unique_ptr<CookieStoreIOSClient> cookie_store_client);
-  ~ScopedTestingCookieStoreIOSClient();
-
-  CookieStoreIOSClient* Get();
-
- private:
-  std::unique_ptr<CookieStoreIOSClient> cookie_store_client_;
-  CookieStoreIOSClient* original_client_;
-};
-
 void RecordCookieChanges(std::vector<net::CanonicalCookie>* out_cookies,
                          std::vector<bool>* out_removes,
                          const net::CanonicalCookie& cookie,

ios/net/cookies/cookie_store_ios_test_util.mm

@@ -8,8 +8,6 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #import "ios/net/cookies/cookie_store_ios.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_options.h"
@@ -115,33 +113,6 @@ void GetCookieCallback::Run(const std::string& cookie_line) {
   cookie_line_ = cookie_line;
 }
 
-#pragma mark -
-#pragma mark TestCookieStoreIOSClient
-
-TestCookieStoreIOSClient::TestCookieStoreIOSClient() {}
-
-#pragma mark -
-#pragma mark TestCookieStoreIOSClient methods
-
-scoped_refptr<base::SequencedTaskRunner>
-TestCookieStoreIOSClient::GetTaskRunner() const {
-  return base::ThreadTaskRunnerHandle::Get();
-}
-
-#pragma mark -
-#pragma mark ScopedTestingCookieStoreIOSClient
-
-ScopedTestingCookieStoreIOSClient::ScopedTestingCookieStoreIOSClient(
-    std::unique_ptr<CookieStoreIOSClient> cookie_store_client)
-    : cookie_store_client_(std::move(cookie_store_client)),
-      original_client_(GetCookieStoreIOSClient()) {
-  SetCookieStoreIOSClient(cookie_store_client_.get());
-}
-
-ScopedTestingCookieStoreIOSClient::~ScopedTestingCookieStoreIOSClient() {
-  SetCookieStoreIOSClient(original_client_);
-}
-
 //------------------------------------------------------------------------------
 
 void RecordCookieChanges(std::vector<net::CanonicalCookie>* out_cookies,

ios/net/cookies/cookie_store_ios_unittest.mm

@@ -9,13 +9,11 @@
 #include <memory>
 
 #include "base/bind_helpers.h"
-#import "base/mac/bind_objc_block.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
-#include "ios/net/cookies/cookie_store_ios_client.h"
 #import "ios/net/cookies/cookie_store_ios_test_util.h"
 #import "ios/net/cookies/ns_http_system_cookie_store.h"
 #import "net/base/mac/url_conversions.h"
@@ -28,21 +26,10 @@
 
 namespace net {
 
-class TestingCookieStoreIOS : public CookieStoreIOS {
- public:
-  TestingCookieStoreIOS(std::unique_ptr<SystemCookieStore> system_store)
-      : CookieStoreIOS(std::move(system_store)),
-        scoped_cookie_store_ios_client_(
-            base::MakeUnique<TestCookieStoreIOSClient>()) {}
-
- private:
-  ScopedTestingCookieStoreIOSClient scoped_cookie_store_ios_client_;
-};
-
 struct CookieStoreIOSTestTraits {
   static std::unique_ptr<net::CookieStore> Create() {
     ClearCookies();
-    return base::MakeUnique<TestingCookieStoreIOS>(
+    return base::MakeUnique<CookieStoreIOS>(
         base::MakeUnique<NSHTTPSystemCookieStore>());
   }
 
@@ -104,8 +91,6 @@ class CookieStoreIOSTest : public testing::Test {
         kTestCookieURL2("http://foo.google.com/baz"),
         kTestCookieURL3("http://foo.google.com"),
         kTestCookieURL4("http://bar.google.com/bar"),
-        scoped_cookie_store_ios_client_(
-            base::MakeUnique<TestCookieStoreIOSClient>()),
         backend_(new TestPersistentCookieStore) {
     std::unique_ptr<NSHTTPSystemCookieStore> system_store(
         base::MakeUnique<NSHTTPSystemCookieStore>());
@@ -137,33 +122,25 @@ class CookieStoreIOSTest : public testing::Test {
   void SetSystemCookie(const GURL& url,
                        const std::string& name,
                        const std::string& value) {
-    system_store_->SetCookieAsync(
-        [NSHTTPCookie cookieWithProperties:@{
-          NSHTTPCookiePath : base::SysUTF8ToNSString(url.path()),
-          NSHTTPCookieName : base::SysUTF8ToNSString(name),
-          NSHTTPCookieValue : base::SysUTF8ToNSString(value),
-          NSHTTPCookieDomain : base::SysUTF8ToNSString(url.host()),
-        }],
-        base::BindOnce(&net::CookieStoreIOS::NotifySystemCookiesChanged));
+    system_store_->SetCookie([NSHTTPCookie cookieWithProperties:@{
+      NSHTTPCookiePath : base::SysUTF8ToNSString(url.path()),
+      NSHTTPCookieName : base::SysUTF8ToNSString(name),
+      NSHTTPCookieValue : base::SysUTF8ToNSString(value),
+      NSHTTPCookieDomain : base::SysUTF8ToNSString(url.host()),
+    }]);
+    net::CookieStoreIOS::NotifySystemCookiesChanged();
     base::RunLoop().RunUntilIdle();
   }
 
   void DeleteSystemCookie(const GURL& gurl, const std::string& name) {
-    base::WeakPtr<SystemCookieStore> weak_system_store =
-        system_store_->GetWeakPtr();
-    system_store_->GetCookiesForURLAsync(
-        gurl, base::BindBlockArc(^(NSArray<NSHTTPCookie*>* cookies) {
-          for (NSHTTPCookie* cookie in cookies) {
-            if ([[cookie name] isEqualToString:base::SysUTF8ToNSString(name)] &&
-                weak_system_store) {
-              weak_system_store->DeleteCookieAsync(
-                  cookie,
-                  base::BindOnce(
-                      &net::CookieStoreIOS::NotifySystemCookiesChanged));
-              break;
-            }
-          }
-        }));
+    NSArray* cookies = system_store_->GetCookiesForURL(gurl);
+    for (NSHTTPCookie* cookie in cookies) {
+      if (cookie.name.UTF8String == name) {
+        system_store_->DeleteCookie(cookie);
+        break;
+      }
+    }
+    net::CookieStoreIOS::NotifySystemCookiesChanged();
     base::RunLoop().RunUntilIdle();
   }
 
@@ -174,7 +151,6 @@ class CookieStoreIOSTest : public testing::Test {
   const GURL kTestCookieURL4;
 
   base::MessageLoop loop_;
-  ScopedTestingCookieStoreIOSClient scoped_cookie_store_ios_client_;
   scoped_refptr<TestPersistentCookieStore> backend_;
   // |system_store_| will point to the NSHTTPSystemCookieStore object owned by
   // |store_|. Once the store_ object is deleted the NSHTTPSystemCookieStore
@@ -233,9 +209,6 @@ TEST_F(CookieStoreIOSTest, SameValueDoesNotCallHook) {
 
 TEST(CookieStoreIOS, GetAllCookiesForURLAsync) {
   base::MessageLoop loop;
-  ScopedTestingCookieStoreIOSClient scoped_cookie_store_ios_client(
-      base::MakeUnique<TestCookieStoreIOSClient>());
-
   const GURL kTestCookieURL("http://foo.google.com/bar");
   ClearCookies();
   std::unique_ptr<CookieStoreIOS> cookie_store(base::MakeUnique<CookieStoreIOS>(
@@ -251,7 +224,6 @@ TEST(CookieStoreIOS, GetAllCookiesForURLAsync) {
   cookie_store->GetAllCookiesForURLAsync(
       kTestCookieURL,
       base::Bind(&GetAllCookiesCallback::Run, base::Unretained(&callback)));
-  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1u, callback.cookie_list().size());
   net::CanonicalCookie cookie = callback.cookie_list()[0];

ios/net/cookies/ns_http_system_cookie_store.h

@@ -18,54 +18,17 @@ class NSHTTPSystemCookieStore : public net::SystemCookieStore {
   // By default the underlying cookiestore is
   // |NSHTTPCookieStorage sharedHTTPCookieStorage|
   NSHTTPSystemCookieStore();
-
   explicit NSHTTPSystemCookieStore(NSHTTPCookieStorage* cookie_store);
-
   ~NSHTTPSystemCookieStore() override;
-
-  // Gets cookies for URL and calls |callback| async on these cookies.
-  void GetCookiesForURLAsync(const GURL& url,
-                             SystemCookieCallbackForCookies callback) override;
-
-  // Gets all cookies and calls |callback| async on these cookies.
-  void GetAllCookiesAsync(SystemCookieCallbackForCookies callback) override;
-
-  // Deletes specific cookie and calls |callback| async after that.
-  void DeleteCookieAsync(NSHTTPCookie* cookie,
-                         SystemCookieCallback callback) override;
-
-  // Sets cookie, and calls |callback| async after that.
-  void SetCookieAsync(NSHTTPCookie* cookie,
-                      const base::Time* optional_creation_time,
-                      SystemCookieCallback callback) override;
-
-  // Clears all cookies from the store and call |callback| after all cookies are
-  // deleted.
-  void ClearStoreAsync(SystemCookieCallback callback) override;
-
+  NSArray* GetCookiesForURL(const GURL& url,
+                            CookieCreationTimeManager* manager) override;
+  NSArray* GetAllCookies(CookieCreationTimeManager* manager) override;
+  void DeleteCookie(NSHTTPCookie* cookie) override;
+  void SetCookie(NSHTTPCookie* cookie) override;
+  void ClearStore() override;
   NSHTTPCookieAcceptPolicy GetCookieAcceptPolicy() override;
 
  private:
-  // Returns all cookies for a specific |url| from the internal cookie store.
-  // Cookies are sorted, as per RFC6265.
-  NSArray* GetCookiesForURL(const GURL& url);
-
-  // Returns all cookies from the internal http cookie store.
-  // Cookies are sorted, as per RFC6265.
-  NSArray* GetAllCookies();
-
-  // Deletes a specific cookie from the internal http cookie store.
-  void DeleteCookie(NSHTTPCookie* cookie);
-
-  // Sets a specific cookie to the internal http cookie store.
-  // if the |optional_creation_time| is nullptr, uses Time::Now() as the
-  // creation time.
-  void SetCookie(NSHTTPCookie* cookie,
-                 const base::Time* optional_creation_time);
-
-  // Clears all cookies from the internal cookie store.
-  void ClearStore();
-
   NSHTTPCookieStorage* cookie_store_;
 
   DISALLOW_COPY_AND_ASSIGN(NSHTTPSystemCookieStore);

ios/net/cookies/ns_http_system_cookie_store.mm

@@ -4,10 +4,7 @@
 
 #import "ios/net/cookies/ns_http_system_cookie_store.h"
 
-#include "base/bind.h"
-#include "base/time/time.h"
 #import "ios/net/cookies/cookie_creation_time_manager.h"
-#import "ios/net/cookies/cookie_store_ios_client.h"
 #import "net/base/mac/url_conversions.h"
 #include "url/gurl.h"
 
@@ -17,15 +14,6 @@
 
 namespace net {
 
-// private
-void RunCookieCallback(base::OnceClosure callback) {
-  if (callback.is_null())
-    return;
-  CookieStoreIOSClient* client = net::GetCookieStoreIOSClient();
-  auto sequenced_task_runner = client->GetTaskRunner();
-  sequenced_task_runner->PostTask(FROM_HERE, std::move(callback));
-}
-
 NSHTTPSystemCookieStore::NSHTTPSystemCookieStore()
     : cookie_store_([NSHTTPCookieStorage sharedHTTPCookieStorage]) {}
 
@@ -38,71 +26,33 @@ NSHTTPSystemCookieStore::~NSHTTPSystemCookieStore() = default;
 #pragma mark -
 #pragma mark SystemCookieStore methods
 
-void NSHTTPSystemCookieStore::GetCookiesForURLAsync(
+NSArray* NSHTTPSystemCookieStore::GetCookiesForURL(
     const GURL& url,
-    SystemCookieCallbackForCookies callback) {
-  NSArray* cookies = GetCookiesForURL(url);
-  RunCookieCallback(base::BindOnce(std::move(callback), cookies));
-}
-void NSHTTPSystemCookieStore::GetAllCookiesAsync(
-    SystemCookieCallbackForCookies callback) {
-  NSArray* cookies = GetAllCookies();
-  RunCookieCallback(base::BindOnce(std::move(callback), cookies));
-}
-void NSHTTPSystemCookieStore::DeleteCookieAsync(NSHTTPCookie* cookie,
-                                                SystemCookieCallback callback) {
-  DeleteCookie(cookie);
-  RunCookieCallback(std::move(callback));
-}
-
-void NSHTTPSystemCookieStore::SetCookieAsync(
-    NSHTTPCookie* cookie,
-    const base::Time* optional_creation_time,
-    SystemCookieCallback callback) {
-  SetCookie(cookie, optional_creation_time);
-  RunCookieCallback(std::move(callback));
-}
-
-void NSHTTPSystemCookieStore::ClearStoreAsync(SystemCookieCallback callback) {
-  ClearStore();
-  RunCookieCallback(std::move(callback));
-}
-
-NSHTTPCookieAcceptPolicy NSHTTPSystemCookieStore::GetCookieAcceptPolicy() {
-  return [cookie_store_ cookieAcceptPolicy];
-}
-
-#pragma mark private methods
-
-NSArray* NSHTTPSystemCookieStore::GetCookiesForURL(const GURL& url) {
+    CookieCreationTimeManager* manager) {
   NSArray* cookies = [cookie_store_ cookiesForURL:NSURLWithGURL(url)];
+  if (!manager)
+    return cookies;
   // Sort cookies by decreasing path length, then creation time, as per
   // RFC6265.
-  return [cookies sortedArrayUsingFunction:CompareCookies
-                                   context:creation_time_manager_.get()];
+  return [cookies sortedArrayUsingFunction:CompareCookies context:manager];
 }
 
-NSArray* NSHTTPSystemCookieStore::GetAllCookies() {
+NSArray* NSHTTPSystemCookieStore::GetAllCookies(
+    CookieCreationTimeManager* manager) {
   NSArray* cookies = cookie_store_.cookies;
-  return [cookies sortedArrayUsingFunction:CompareCookies
-                                   context:creation_time_manager_.get()];
+  if (!manager)
+    return cookies;
+  // Sort cookies by decreasing path length, then creation time, as per
+  // RFC6265.
+  return [cookies sortedArrayUsingFunction:CompareCookies context:manager];
 }
 
 void NSHTTPSystemCookieStore::DeleteCookie(NSHTTPCookie* cookie) {
   [cookie_store_ deleteCookie:cookie];
-  creation_time_manager_->DeleteCreationTime(cookie);
 }
 
-void NSHTTPSystemCookieStore::SetCookie(
-    NSHTTPCookie* cookie,
-    const base::Time* optional_creation_time) {
+void NSHTTPSystemCookieStore::SetCookie(NSHTTPCookie* cookie) {
   [cookie_store_ setCookie:cookie];
-  base::Time cookie_time = base::Time::Now();
-  if (optional_creation_time && !optional_creation_time->is_null())
-    cookie_time = *optional_creation_time;
-
-  creation_time_manager_->SetCreationTime(
-      cookie, creation_time_manager_->MakeUniqueCreationTime(cookie_time));
 }
 
 void NSHTTPSystemCookieStore::ClearStore() {
@@ -110,6 +60,10 @@ void NSHTTPSystemCookieStore::ClearStore() {
   for (NSHTTPCookie* cookie in copy)
     [cookie_store_ deleteCookie:cookie];
   DCHECK_EQ(0u, cookie_store_.cookies.count);
-  creation_time_manager_->Clear();
 }
+
+NSHTTPCookieAcceptPolicy NSHTTPSystemCookieStore::GetCookieAcceptPolicy() {
+  return [cookie_store_ cookieAcceptPolicy];
+}
+
 }  // namespace net

ios/net/cookies/ns_http_system_cookie_store_unittest.mm

@@ -8,13 +8,7 @@
 
 #include <memory>
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#import "ios/net/cookies/cookie_store_ios_test_util.h"
 #import "net/base/mac/url_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
@@ -26,45 +20,12 @@
 
 namespace net {
 
-namespace {
-// Helper callbacks to be passed to SetCookieAsync/GetCookiesAsync.
-class SystemCookiesCallback {
- public:
-  SystemCookiesCallback()
-      : did_run_with_cookies_(false), did_run_with_no_cookies_(false) {}
-  // Returns if the callback has been run.
-  bool did_run_with_cookies() { return did_run_with_cookies_; }
-  bool did_run_with_no_cookies() { return did_run_with_no_cookies_; }
-
-  // Returns the paremeter of the callback.
-  NSArray<NSHTTPCookie*>* cookies() { return cookies_; }
-
-  void RunWithCookies(NSArray<NSHTTPCookie*>* cookies) {
-    ASSERT_FALSE(did_run_with_cookies_);
-    did_run_with_cookies_ = true;
-    cookies_ = cookies;
-  }
-
-  void RunWithNoCookies() {
-    ASSERT_FALSE(did_run_with_no_cookies_);
-    did_run_with_no_cookies_ = true;
-  }
-
- private:
-  bool did_run_with_cookies_;
-  bool did_run_with_no_cookies_;
-  NSArray<NSHTTPCookie*>* cookies_;
-};
-}  // namespace
-
 // Test fixture to exercise net::NSHTTPSystemCookieStore created with
 // |[NSHTTPCookieStorage sharedHTTPCookieStorage]|.
 class NSHTTPSystemCookieStoreTest : public PlatformTest {
  public:
   NSHTTPSystemCookieStoreTest()
-      : scoped_cookie_store_ios_client_(
-            base::MakeUnique<TestCookieStoreIOSClient>()),
-        shared_store_([NSHTTPCookieStorage sharedHTTPCookieStorage]),
+      : shared_store_([NSHTTPCookieStorage sharedHTTPCookieStorage]),
         store_(base::MakeUnique<net::NSHTTPSystemCookieStore>(shared_store_)),
         test_cookie_url1_([NSURL URLWithString:@"http://foo.google.com/bar"]),
         test_cookie_url2_([NSURL URLWithString:@"http://bar.xyz.abc"]),
@@ -85,22 +46,7 @@ class NSHTTPSystemCookieStoreTest : public PlatformTest {
                                  forURL:url] objectAtIndex:0];
   }
 
-  bool IsCookieSet(NSHTTPCookie* system_cookie, NSURL* url) {
-    // Verify that cookie is set in system storage.
-    NSHTTPCookie* result_cookie = nil;
-
-    for (NSHTTPCookie* cookie in [shared_store_ cookiesForURL:url]) {
-      if ([cookie.name isEqualToString:system_cookie.name]) {
-        result_cookie = cookie;
-        break;
-      }
-    }
-    return [result_cookie.value isEqualToString:system_cookie.value];
-  }
-
  protected:
-  base::MessageLoop loop;
-  ScopedTestingCookieStoreIOSClient scoped_cookie_store_ios_client_;
   NSHTTPCookieStorage* shared_store_;
   std::unique_ptr<net::NSHTTPSystemCookieStore> store_;
   NSURL* test_cookie_url1_;
@@ -108,126 +54,105 @@ class NSHTTPSystemCookieStoreTest : public PlatformTest {
   NSURL* test_cookie_url3_;
 };
 
-TEST_F(NSHTTPSystemCookieStoreTest, GetCookieAcceptPolicy) {
-  EXPECT_EQ(shared_store_.cookieAcceptPolicy, store_->GetCookieAcceptPolicy());
-  shared_store_.cookieAcceptPolicy = NSHTTPCookieAcceptPolicyNever;
-  EXPECT_EQ(shared_store_.cookieAcceptPolicy, store_->GetCookieAcceptPolicy());
-  shared_store_.cookieAcceptPolicy = NSHTTPCookieAcceptPolicyAlways;
-  EXPECT_EQ(shared_store_.cookieAcceptPolicy, store_->GetCookieAcceptPolicy());
+TEST_F(NSHTTPSystemCookieStoreTest, SetCookie) {
+  NSHTTPCookie* system_cookie = CreateCookie(@"a=b", test_cookie_url1_);
+  // Verify that cookie is not set in system storage.
+  for (NSHTTPCookie* cookie in
+       [shared_store_ cookiesForURL:test_cookie_url1_]) {
+    EXPECT_FALSE([cookie.name isEqualToString:system_cookie.name]);
+  }
+  store_->SetCookie(system_cookie);
+
+  // Verify that cookie is set in system storage.
+  NSHTTPCookie* result_cookie = nil;
+
+  for (NSHTTPCookie* cookie in
+       [shared_store_ cookiesForURL:test_cookie_url1_]) {
+    if ([cookie.name isEqualToString:system_cookie.name]) {
+      result_cookie = cookie;
+      break;
+    }
+  }
+  EXPECT_TRUE([result_cookie.value isEqualToString:system_cookie.value]);
 }
 
-TEST_F(NSHTTPSystemCookieStoreTest, GetCookiesAsync) {
+TEST_F(NSHTTPSystemCookieStoreTest, ClearCookies) {
+  [shared_store_ setCookie:CreateCookie(@"a=b", test_cookie_url1_)];
+  [shared_store_ setCookie:CreateCookie(@"x=d", test_cookie_url2_)];
+
+  EXPECT_EQ(2u, shared_store_.cookies.count);
+  store_->ClearStore();
+  EXPECT_EQ(0u, shared_store_.cookies.count);
+}
+
+TEST_F(NSHTTPSystemCookieStoreTest, GetCookies) {
   NSMutableDictionary* input_cookies = [[NSMutableDictionary alloc] init];
   NSHTTPCookie* system_cookie = CreateCookie(@"a=b", test_cookie_url1_);
   [input_cookies setValue:system_cookie forKey:@"a"];
-  store_->SetCookieAsync(system_cookie, /*optional_creation_time=*/nullptr,
-                         SystemCookieStore::SystemCookieCallback());
+  [shared_store_ setCookie:system_cookie];
+
   system_cookie = CreateCookie(@"x=d", test_cookie_url2_);
   [input_cookies setValue:system_cookie forKey:@"x"];
-  store_->SetCookieAsync(system_cookie, /*optional_creation_time=*/nullptr,
-                         SystemCookieStore::SystemCookieCallback());
+  [shared_store_ setCookie:system_cookie];
+
   system_cookie = CreateCookie(@"l=m", test_cookie_url3_);
   [input_cookies setValue:system_cookie forKey:@"l"];
-  store_->SetCookieAsync(system_cookie, /*optional_creation_time=*/nullptr,
-                         SystemCookieStore::SystemCookieCallback());
-  base::RunLoop().RunUntilIdle();
+  [shared_store_ setCookie:system_cookie];
 
-  // Test GetCookieForURLAsync.
-  NSHTTPCookie* input_cookie = [input_cookies valueForKey:@"a"];
-  SystemCookiesCallback callback_for_url;
-  store_->GetCookiesForURLAsync(
-      GURLWithNSURL(test_cookie_url1_),
-      base::BindOnce(&SystemCookiesCallback::RunWithCookies,
-                     base::Unretained(&callback_for_url)));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(callback_for_url.did_run_with_cookies());
-  EXPECT_EQ(1u, callback_for_url.cookies().count);
-  NSHTTPCookie* result_cookie = callback_for_url.cookies()[0];
-  EXPECT_TRUE([input_cookie.name isEqualToString:result_cookie.name]);
-  EXPECT_TRUE([input_cookie.value isEqualToString:result_cookie.value]);
+  EXPECT_EQ(3u, shared_store_.cookies.count);
 
   // Test GetAllCookies
-  SystemCookiesCallback callback_all_cookies;
-  store_->GetAllCookiesAsync(
-      base::BindOnce(&SystemCookiesCallback::RunWithCookies,
-                     base::Unretained(&callback_all_cookies)));
-  base::RunLoop().RunUntilIdle();
-
-  EXPECT_TRUE(callback_all_cookies.did_run_with_cookies());
-  NSArray<NSHTTPCookie*>* result_cookies = callback_all_cookies.cookies();
-  EXPECT_EQ(3u, result_cookies.count);
-  for (NSHTTPCookie* cookie in result_cookies) {
+  NSArray* cookies = store_->GetAllCookies(/*manager=*/nullptr);
+  EXPECT_EQ(3u, cookies.count);
+  for (NSHTTPCookie* cookie in cookies) {
     NSHTTPCookie* existing_cookie = [input_cookies valueForKey:cookie.name];
     EXPECT_TRUE(existing_cookie);
     EXPECT_TRUE([existing_cookie.name isEqualToString:cookie.name]);
     EXPECT_TRUE([existing_cookie.value isEqualToString:cookie.value]);
     EXPECT_TRUE([existing_cookie.domain isEqualToString:cookie.domain]);
   }
-}
 
-TEST_F(NSHTTPSystemCookieStoreTest, SetCookieAsync) {
-  NSHTTPCookie* system_cookie = CreateCookie(@"a=b", test_cookie_url1_);
-  SystemCookiesCallback callback;
-  store_->SetCookieAsync(
-      system_cookie, /*optional_creation_time=*/nullptr,
-      base::BindOnce(&SystemCookiesCallback::RunWithNoCookies,
-                     base::Unretained(&callback)));
-  base::RunLoop().RunUntilIdle();
-  // verify callback.
-  EXPECT_TRUE(callback.did_run_with_no_cookies());
-  EXPECT_TRUE(IsCookieSet(system_cookie, test_cookie_url1_));
+  // Test GetCookiesForURL
+  NSHTTPCookie* input_cookie = [input_cookies valueForKey:@"a"];
+  NSArray* cookies_for_url = store_->GetCookiesForURL(
+      GURLWithNSURL(test_cookie_url1_), /*manager=*/nullptr);
+  EXPECT_EQ(1u, cookies_for_url.count);
+  NSHTTPCookie* output_cookie = [cookies_for_url objectAtIndex:0];
+  EXPECT_TRUE([input_cookie.name isEqualToString:output_cookie.name]);
+  EXPECT_TRUE([input_cookie.value isEqualToString:output_cookie.value]);
+  EXPECT_TRUE([input_cookie.domain isEqualToString:output_cookie.domain]);
 }
 
-TEST_F(NSHTTPSystemCookieStoreTest, DeleteCookiesAsync) {
+TEST_F(NSHTTPSystemCookieStoreTest, DeleteCookies) {
   NSHTTPCookie* system_cookie1 = CreateCookie(@"a=b", test_cookie_url1_);
-  store_->SetCookieAsync(system_cookie1, /*optional_creation_time=*/nullptr,
-                         SystemCookieStore::SystemCookieCallback());
+  [shared_store_ setCookie:system_cookie1];
+
   NSHTTPCookie* system_cookie2 = CreateCookie(@"x=d", test_cookie_url2_);
-  store_->SetCookieAsync(system_cookie2, /*optional_creation_time=*/nullptr,
-                         SystemCookieStore::SystemCookieCallback());
+  store_->SetCookie(system_cookie2);
+
   NSHTTPCookie* system_cookie3 = CreateCookie(@"l=m", test_cookie_url3_);
-  store_->SetCookieAsync(system_cookie3, /*optional_creation_time=*/nullptr,
-                         SystemCookieStore::SystemCookieCallback());
-  base::RunLoop().RunUntilIdle();
+  [shared_store_ setCookie:system_cookie3];
+
   EXPECT_EQ(3u, shared_store_.cookies.count);
 
-  SystemCookiesCallback callback;
-  EXPECT_EQ(1u, [shared_store_ cookiesForURL:test_cookie_url2_].count);
-  store_->DeleteCookieAsync(
-      system_cookie2, base::BindOnce(&SystemCookiesCallback::RunWithNoCookies,
-                                     base::Unretained(&callback)));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(callback.did_run_with_no_cookies());
+  store_->DeleteCookie(system_cookie2);
   EXPECT_EQ(0u, [shared_store_ cookiesForURL:test_cookie_url2_].count);
   EXPECT_EQ(2u, shared_store_.cookies.count);
 
-  store_->DeleteCookieAsync(system_cookie1,
-                            SystemCookieStore::SystemCookieCallback());
-  base::RunLoop().RunUntilIdle();
+  store_->DeleteCookie(system_cookie1);
   EXPECT_EQ(0u, [shared_store_ cookiesForURL:test_cookie_url1_].count);
   EXPECT_EQ(1u, shared_store_.cookies.count);
 
-  store_->DeleteCookieAsync(system_cookie3,
-                            SystemCookieStore::SystemCookieCallback());
-  base::RunLoop().RunUntilIdle();
+  store_->DeleteCookie(system_cookie3);
   EXPECT_EQ(0u, shared_store_.cookies.count);
 }
 
-TEST_F(NSHTTPSystemCookieStoreTest, ClearCookiesAsync) {
-  store_->SetCookieAsync(CreateCookie(@"a=b", test_cookie_url1_),
-                         /*optional_creation_time=*/nullptr,
-                         SystemCookieStore::SystemCookieCallback());
-  store_->SetCookieAsync(CreateCookie(@"x=d", test_cookie_url2_),
-                         /*optional_creation_time=*/nullptr,
-                         SystemCookieStore::SystemCookieCallback());
-
-  SystemCookiesCallback callback;
-  EXPECT_EQ(2u, shared_store_.cookies.count);
-  store_->ClearStoreAsync(base::BindOnce(
-      &SystemCookiesCallback::RunWithNoCookies, base::Unretained(&callback)));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(callback.did_run_with_no_cookies());
-  EXPECT_EQ(0u, shared_store_.cookies.count);
+TEST_F(NSHTTPSystemCookieStoreTest, GetCookieAcceptPolicy) {
+  EXPECT_EQ(shared_store_.cookieAcceptPolicy, store_->GetCookieAcceptPolicy());
+  shared_store_.cookieAcceptPolicy = NSHTTPCookieAcceptPolicyNever;
+  EXPECT_EQ(shared_store_.cookieAcceptPolicy, store_->GetCookieAcceptPolicy());
+  shared_store_.cookieAcceptPolicy = NSHTTPCookieAcceptPolicyAlways;
+  EXPECT_EQ(shared_store_.cookieAcceptPolicy, store_->GetCookieAcceptPolicy());
 }
 
 }  // namespace net

ios/net/cookies/system_cookie_store.h

@@ -7,10 +7,7 @@
 
 #import <Foundation/Foundation.h>
 
-#include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/time/time.h"
 
 class GURL;
 
@@ -24,67 +21,39 @@ class CookieCreationTimeManager;
 // it directly without caring about the type of the underlying cookie store.
 class SystemCookieStore {
  public:
-  // Callback definitions.
-  typedef base::OnceClosure SystemCookieCallback;
-  typedef base::OnceCallback<void(NSArray<NSHTTPCookie*>*)>
-      SystemCookieCallbackForCookies;
-
-  SystemCookieStore();
   virtual ~SystemCookieStore();
 
-  // Calls |callback| on all cookies for a specific |url| in the internal
-  // cookie store.
-  // If CookieCreationTimeManager was provided in the constructor, sort cookies
-  // as per RFC6265 before calling the |callback|.
-  virtual void GetCookiesForURLAsync(
-      const GURL& url,
-      SystemCookieCallbackForCookies callback) = 0;
-
-  // Calls |callback| on all cookies in the internal cookie store.
-  // If CookieCreationTimeManager was provided in the constructor, sort cookies
-  // as per RFC6265 before calling the |callback|.
-  virtual void GetAllCookiesAsync(SystemCookieCallbackForCookies callback) = 0;
-
-  // Deletes a specific cookie from the internal cookie store, and call
-  // |callback| after it's deleted.
-  virtual void DeleteCookieAsync(NSHTTPCookie* cookie,
-                                 SystemCookieCallback callback) = 0;
-
-  // Sets a specific cookie to the internal cookie store, sets the cookie
-  // creation time |optional_creation_time| or to the current time if
-  // |optional_creation_time| is nil, then calls |callback| after it's set.
-  virtual void SetCookieAsync(NSHTTPCookie* cookie,
-                              const base::Time* optional_creation_time,
-                              SystemCookieCallback callback) = 0;
-
-  // Same as SetCookieAsync but uses actual time of setting the cookie.
-  void SetCookieAsync(NSHTTPCookie* cookie, SystemCookieCallback callback);
-
-  // Deletes all cookies from the internal http cookie store, and calls
-  // |callback| all cookies are deleted.
-  virtual void ClearStoreAsync(SystemCookieCallback callback) = 0;
+  // Returns cookies for specific URL without sorting.
+  NSArray* GetCookiesForURL(const GURL& url);
 
-  // Returns the Cookie Accept policy for the internal cookie store.
-  virtual NSHTTPCookieAcceptPolicy GetCookieAcceptPolicy() = 0;
+  // Returns all cookies for a specific |url| from the internal cookie store.
+  // If |manager| is provided, use it to sort cookies, as per RFC6265.
+  virtual NSArray* GetCookiesForURL(const GURL& url,
+                                    CookieCreationTimeManager* manager) = 0;
+
+  // Returns all cookies from the internal http cookie store without sorting.
+  NSArray* GetAllCookies();
+
+  // Returns all cookies from the internal http cookie store.
+  // If |manager| is provided, use it to sort cookies, as per RFC6265.
+  virtual NSArray* GetAllCookies(CookieCreationTimeManager* manager) = 0;
+
+  // Delete a specific cookie from the internal http cookie store.
+  virtual void DeleteCookie(NSHTTPCookie* cookie) = 0;
 
-  // Returns the creation time of a specific cookie
-  base::Time GetCookieCreationTime(NSHTTPCookie* cookie);
+  // Set a specific cookie to the internal http cookie store.
+  virtual void SetCookie(NSHTTPCookie* cookie) = 0;
 
-  // Return WeakPtr of this object.
-  base::WeakPtr<SystemCookieStore> GetWeakPtr();
+  // Delete all cookies from the internal http cookie store.
+  virtual void ClearStore() = 0;
+
+  // Returns the Cookie Accept policy for the internal cookie store.
+  virtual NSHTTPCookieAcceptPolicy GetCookieAcceptPolicy() = 0;
 
  protected:
   // Compares cookies based on the path lengths and the creation times, as per
   // RFC6265.
   static NSInteger CompareCookies(id a, id b, void* context);
-
-  // Internal cookie stores doesn't store creation time. This object is used
-  // to keep track of the creation time of cookies, this is required for
-  // conversion between SystemCookie and Chromium CookieMonster.
-  std::unique_ptr<CookieCreationTimeManager> creation_time_manager_;
-
-  // Weak Ptr factory.
-  base::WeakPtrFactory<SystemCookieStore> weak_factory_;
 };
 
 }  // namespace net

ios/net/cookies/system_cookie_store.mm

@@ -4,7 +4,7 @@
 
 #import "ios/net/cookies/system_cookie_store.h"
 
-#include "base/memory/ptr_util.h"
+#include "base/time/time.h"
 #import "ios/net/cookies/cookie_creation_time_manager.h"
 #include "ios/net/ios_net_features.h"
 
@@ -16,22 +16,12 @@ namespace net {
 
 SystemCookieStore::~SystemCookieStore() = default;
 
-SystemCookieStore::SystemCookieStore()
-    : creation_time_manager_(base::MakeUnique<CookieCreationTimeManager>()),
-      weak_factory_(this) {}
-
-void SystemCookieStore::SetCookieAsync(NSHTTPCookie* cookie,
-                                       SystemCookieCallback callback) {
-  SetCookieAsync(cookie, /*optional_creation_time=*/nullptr,
-                 std::move(callback));
-}
-
-base::Time SystemCookieStore::GetCookieCreationTime(NSHTTPCookie* cookie) {
-  return creation_time_manager_->GetCreationTime(cookie);
+NSArray* SystemCookieStore::GetCookiesForURL(const GURL& url) {
+  return GetCookiesForURL(url, /* manager = */ nullptr);
 }
 
-base::WeakPtr<SystemCookieStore> SystemCookieStore::GetWeakPtr() {
-  return weak_factory_.GetWeakPtr();
+NSArray* SystemCookieStore::GetAllCookies() {
+  return GetAllCookies(/* manager = */ nullptr);
 }
 
 // protected static