Shift cookie system callbacks to OnceCallback to impedance match mojo.

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 285 matching lines @@
   metrics_enabled_ = true;
 }
 
 #pragma mark -
 #pragma mark CookieStore methods
 
 void CookieStoreIOS::SetCookieWithOptionsAsync(
     const GURL& url,
     const std::string& cookie_line,
     const net::CookieOptions& options,
-    const SetCookiesCallback& callback) {
+    SetCookiesCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // The exclude_httponly() option would only be used by a javascript
   // engine.
   DCHECK(!options.exclude_httponly());
 
   // If cookies are not allowed, they are stashed in the CookieMonster, and
   // should be written there instead.
   DCHECK(SystemCookiesAllowed());
 
@@ skipping 24 matching lines @@
                  (!has_explicit_domain || has_valid_domain);
 
   if (success) {
     [system_store_ setCookie:cookie];
     creation_time_manager_->SetCreationTime(
         cookie,
         creation_time_manager_->MakeUniqueCreationTime(base::Time::Now()));
   }
 
   if (!callback.is_null())
-    callback.Run(success);
+    std::move(callback).Run(success);
 }
 
-void CookieStoreIOS::SetCookieWithDetailsAsync(
-    const GURL& url,
-    const std::string& name,
-    const std::string& value,
-    const std::string& domain,
-    const std::string& path,
-    base::Time creation_time,
-    base::Time expiration_time,
-    base::Time last_access_time,
-    bool secure,
-    bool http_only,
-    CookieSameSite same_site,
-    CookiePriority priority,
-    const SetCookiesCallback& callback) {
+void CookieStoreIOS::SetCookieWithDetailsAsync(const GURL& url,
+                                               const std::string& name,
+                                               const std::string& value,
+                                               const std::string& domain,
+                                               const std::string& path,
+                                               base::Time creation_time,
+                                               base::Time expiration_time,
+                                               base::Time last_access_time,
+                                               bool secure,
+                                               bool http_only,
+                                               CookieSameSite same_site,
+                                               CookiePriority priority,
+                                               SetCookiesCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // If cookies are not allowed, they are stashed in the CookieMonster, and
   // should be written there instead.
   DCHECK(SystemCookiesAllowed());
 
   bool success = false;
 
   if (creation_time.is_null())
     creation_time = base::Time::Now();
 
   // Validate consistency of passed arguments.
   if (ParsedCookie::ParseTokenString(name) != name ||
       ParsedCookie::ParseValueString(value) != value ||
       ParsedCookie::ParseValueString(domain) != domain ||
       ParsedCookie::ParseValueString(path) != path) {
     if (!callback.is_null())
-      callback.Run(false);
+      std::move(callback).Run(false);
     return;
   }
 
   // Validate passed arguments against URL.
   std::string cookie_domain;
   std::string cookie_path = CanonicalCookie::CanonPathWithString(url, path);
   if ((secure && !url.SchemeIsCryptographic()) ||
       !cookie_util::GetCookieDomainWithString(url, domain, &cookie_domain) ||
       (!path.empty() && cookie_path != path)) {
     if (!callback.is_null())
-      callback.Run(false);
+      std::move(callback).Run(false);
     return;
   }
 
   // Canonicalize path again to make sure it escapes characters as needed.
   url::Component path_component(0, cookie_path.length());
   url::RawCanonOutputT<char> canon_path;
   url::Component canon_path_component;
   url::CanonicalizePath(cookie_path.data(), path_component, &canon_path,
                         &canon_path_component);
   cookie_path = std::string(canon_path.data() + canon_path_component.begin,
@@ skipping 11 matching lines @@
     if (cookie != nil) {
       [system_store_ setCookie:cookie];
       creation_time_manager_->SetCreationTime(
           cookie, creation_time_manager_->MakeUniqueCreationTime(
               canonical_cookie->CreationDate()));
       success = true;
     }
   }
 
   if (!callback.is_null())
-    callback.Run(success);
+    std::move(callback).Run(success);
 }
 
 void CookieStoreIOS::SetCanonicalCookieAsync(
     std::unique_ptr<net::CanonicalCookie> cookie,
     bool secure_source,
     bool modify_http_only,
-    const SetCookiesCallback& callback) {
+    SetCookiesCallback callback) {
   DCHECK(cookie->IsCanonical());
   // The exclude_httponly() option would only be used by a javascript
   // engine.
   DCHECK(modify_http_only);
 
   if (cookie->IsSecure() && !secure_source) {
     if (!callback.is_null())
-      callback.Run(false);
+      std::move(callback).Run(false);
     return;
   }
 
   NSHTTPCookie* ns_cookie = SystemCookieFromCanonicalCookie(*cookie.get());
 
   if (ns_cookie != nil) {
     [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())
-      callback.Run(true);
+      std::move(callback).Run(true);
     return;
   }
 
   if (!callback.is_null())
-    callback.Run(false);
+    std::move(callback).Run(false);
 }
 
 void CookieStoreIOS::GetCookiesWithOptionsAsync(
     const GURL& url,
     const net::CookieOptions& options,
-    const GetCookiesCallback& callback) {
+    GetCookiesCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If cookies are not allowed, they are stashed in the CookieMonster, and
   // should be read from there instead.
   DCHECK(SystemCookiesAllowed());
   // The exclude_httponly() option would only be used by a javascript
   // engine.
   DCHECK(!options.exclude_httponly());
 
   // 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 =
       GetCookiesForURL(system_store_, url, creation_time_manager_.get());
   if (!callback.is_null())
-    callback.Run(BuildCookieLineWithOptions(cookies, options));
+    std::move(callback).Run(BuildCookieLineWithOptions(cookies, options));
 }
 
 void CookieStoreIOS::GetCookieListWithOptionsAsync(
     const GURL& url,
     const net::CookieOptions& options,
-    const GetCookieListCallback& callback) {
+    GetCookieListCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!SystemCookiesAllowed()) {
     // If cookies are not allowed, the cookies are stashed in the
     // CookieMonster, so get them from there.
-    cookie_monster_->GetCookieListWithOptionsAsync(url, options, callback);
+    cookie_monster_->GetCookieListWithOptionsAsync(url, options,
+                                                   std::move(callback));
     return;
   }
 
   // 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 =
       GetCookiesForURL(system_store_, url, creation_time_manager_.get());
   net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(cookies);
   if (!callback.is_null())
-    callback.Run(cookie_list);
+    std::move(callback).Run(cookie_list);
 }
 
-void CookieStoreIOS::GetAllCookiesAsync(const GetCookieListCallback& callback) {
+void CookieStoreIOS::GetAllCookiesAsync(GetCookieListCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!SystemCookiesAllowed()) {
     // If cookies are not allowed, the cookies are stashed in the
     // CookieMonster, so get them from there.
-    cookie_monster_->GetAllCookiesAsync(callback);
+    cookie_monster_->GetAllCookiesAsync(std::move(callback));
     return;
   }
 
   NSArray* cookies = GetAllCookies(system_store_, creation_time_manager_.get());
   net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(cookies);
   if (!callback.is_null()) {
-    callback.Run(cookie_list);
+    std::move(callback).Run(cookie_list);
   }
 }
 
 void CookieStoreIOS::DeleteCookieAsync(const GURL& url,
                                        const std::string& cookie_name,
-                                       const base::Closure& callback) {
+                                       base::OnceClosure callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   NSArray* cookies =
       GetCookiesForURL(system_store_, 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())
-    callback.Run();
+    std::move(callback).Run();
 }
 
-void CookieStoreIOS::DeleteCanonicalCookieAsync(
-    const CanonicalCookie& cookie,
-    const DeleteCallback& callback) {
+void CookieStoreIOS::DeleteCanonicalCookieAsync(const CanonicalCookie& cookie,
+                                                DeleteCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // This relies on the fact cookies are given unique creation dates.
   CookieFilterFunction filter = base::Bind(
       IsCookieCreatedBetween, cookie.CreationDate(), cookie.CreationDate());
-  DeleteCookiesWithFilter(filter, callback);
+  DeleteCookiesWithFilter(filter, std::move(callback));
 }
 
 void CookieStoreIOS::DeleteAllCreatedBetweenAsync(
     const base::Time& delete_begin,
     const base::Time& delete_end,
-    const DeleteCallback& callback) {
+    DeleteCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
   CookieFilterFunction filter = base::Bind(
       &IsCookieCreatedBetween, delete_begin, delete_end);
-  DeleteCookiesWithFilter(filter, callback);
+  DeleteCookiesWithFilter(filter, std::move(callback));
 }
 
 void CookieStoreIOS::DeleteAllCreatedBetweenWithPredicateAsync(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     const CookiePredicate& predicate,
-    const DeleteCallback& callback) {
+    DeleteCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
   CookieFilterFunction filter = base::Bind(
       IsCookieCreatedBetweenWithPredicate, delete_begin, delete_end, predicate);
-  DeleteCookiesWithFilter(filter, callback);
+  DeleteCookiesWithFilter(filter, std::move(callback));
 }
 
-void CookieStoreIOS::DeleteSessionCookiesAsync(const DeleteCallback& callback) {
+void CookieStoreIOS::DeleteSessionCookiesAsync(DeleteCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
   CookieFilterFunction filter = base::Bind(&IsCookieSessionCookie);
-  DeleteCookiesWithFilter(filter, callback);
+  DeleteCookiesWithFilter(filter, std::move(callback));
 }
 
-void CookieStoreIOS::FlushStore(const base::Closure& closure) {
+void CookieStoreIOS::FlushStore(base::OnceClosure closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   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.
     WriteToCookieMonster([system_store_ cookies]);
   }
-  cookie_monster_->FlushStore(closure);
+  cookie_monster_->FlushStore(std::move(closure));
   flush_closure_.Cancel();
 }
 
 #pragma mark -
 #pragma mark Protected methods
 
 CookieStoreIOS::CookieStoreIOS(
     net::CookieMonster::PersistentCookieStore* persistent_store,
     NSHTTPCookieStorage* system_store)
     : cookie_monster_(new net::CookieMonster(persistent_store, nullptr)),
       system_store_(system_store),
       creation_time_manager_(new CookieCreationTimeManager),
       metrics_enabled_(false),
       cookie_cache_(new CookieCache()),
       weak_factory_(this) {
   DCHECK(system_store);
 
   NotificationTrampoline::GetInstance()->AddObserver(this);
 
   cookie_monster_->SetPersistSessionCookies(true);
   cookie_monster_->SetForceKeepSessionState();
 }
 
 CookieStoreIOS::SetCookiesCallback CookieStoreIOS::WrapSetCallback(
-    const SetCookiesCallback& callback) {
+    SetCookiesCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return base::Bind(&CookieStoreIOS::UpdateCachesAfterSet,
-                    weak_factory_.GetWeakPtr(), callback);
+  return base::BindOnce(&CookieStoreIOS::UpdateCachesAfterSet,
+                        weak_factory_.GetWeakPtr(), std::move(callback));
 }
 
 CookieStoreIOS::DeleteCallback CookieStoreIOS::WrapDeleteCallback(
-    const DeleteCallback& callback) {
+    DeleteCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return base::Bind(&CookieStoreIOS::UpdateCachesAfterDelete,
-                    weak_factory_.GetWeakPtr(), callback);
+  return base::BindOnce(&CookieStoreIOS::UpdateCachesAfterDelete,
+                        weak_factory_.GetWeakPtr(), std::move(callback));
 }
 
-base::Closure CookieStoreIOS::WrapClosure(const base::Closure& callback) {
+base::OnceClosure CookieStoreIOS::WrapClosure(base::OnceClosure callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return base::Bind(&CookieStoreIOS::UpdateCachesAfterClosure,
-                    weak_factory_.GetWeakPtr(), callback);
+  return base::BindOnce(&CookieStoreIOS::UpdateCachesAfterClosure,
+                        weak_factory_.GetWeakPtr(), std::move(callback));
 }
 
 #pragma mark -
 #pragma mark Private methods
 
 void CookieStoreIOS::ClearSystemStore() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::scoped_nsobject<NSArray> copy(
       [[NSArray alloc] initWithArray:[system_store_ cookies]]);
   for (NSHTTPCookie* cookie in copy.get())
@@ skipping 19 matching lines @@
         cookie, creation_time_manager_->GetCreationTime(cookie)));
   }
   cookie_monster_->SetAllCookiesAsync(cookie_list, SetCookiesCallback());
 
   // Update metrics.
   if (metrics_enabled_)
     UMA_HISTOGRAM_COUNTS_10000("CookieIOS.CookieWrittenCount", cookie_count);
 }
 
 void CookieStoreIOS::DeleteCookiesWithFilter(const CookieFilterFunction& filter,
-                                             const DeleteCallback& callback) {
+                                             DeleteCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   NSArray* cookies = [system_store_ cookies];
 
   // 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())
-    callback.Run([to_delete count]);
+    std::move(callback).Run([to_delete count]);
 }
 
 void CookieStoreIOS::OnSystemCookiesChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   for (const auto& hook_map_entry : hook_map_) {
     std::pair<GURL, std::string> key = hook_map_entry.first;
     std::vector<net::CanonicalCookie> removed_cookies;
     std::vector<net::CanonicalCookie> added_cookies;
     if (UpdateCacheForCookieFromSystem(key.first, key.second, &removed_cookies,
@@ skipping 96 matching lines @@
   if (cookie_cache_->Update(key.first, key.second, filtered, &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);
   }
 }
 
 void CookieStoreIOS::DidClearNSHTTPCookieStorageCookies(
-    const DeleteCallback& delete_callback,
+    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::Bind(&CookieStoreIOS::DidClearBinaryCookiesFileCookies,
-                 weak_factory_.GetWeakPtr(), delete_callback, num_deleted);
+  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), callback);
+      FROM_HERE, base::Bind(&ClearAllCookiesFromBinaryCookiesFile),
+      std::move(callback));
 }
 
 void CookieStoreIOS::DidClearBinaryCookiesFileCookies(
-    const DeleteCallback& callback,
+    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())
-    callback.Run(num_deleted_from_nshttp_cookie_storage);
+    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_) {
     std::pair<GURL, std::string> key = hook_map_entry.first;
-    GetCookieListCallback callback = base::Bind(
+    GetCookieListCallback callback = base::BindOnce(
         &CookieStoreIOS::GotCookieListFor, weak_factory_.GetWeakPtr(), key);
-    cookie_monster_->GetAllCookiesForURLAsync(key.first, callback);
+    cookie_monster_->GetAllCookiesForURLAsync(key.first, std::move(callback));
   }
 }
 
-void CookieStoreIOS::UpdateCachesAfterSet(const SetCookiesCallback& callback,
+void CookieStoreIOS::UpdateCachesAfterSet(SetCookiesCallback callback,
                                           bool success) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (success)
     UpdateCachesFromCookieMonster();
   if (!callback.is_null())
-    callback.Run(success);
+    std::move(callback).Run(success);
 }
 
-void CookieStoreIOS::UpdateCachesAfterDelete(const DeleteCallback& callback,
+void CookieStoreIOS::UpdateCachesAfterDelete(DeleteCallback callback,
                                              int num_deleted) {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateCachesFromCookieMonster();
   if (!callback.is_null())
-    callback.Run(num_deleted);
+    std::move(callback).Run(num_deleted);
 }
 
-void CookieStoreIOS::UpdateCachesAfterClosure(const base::Closure& callback) {
+void CookieStoreIOS::UpdateCachesAfterClosure(base::OnceClosure callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateCachesFromCookieMonster();
   if (!callback.is_null())
-    callback.Run();
+    std::move(callback).Run();
 }
 
 net::CookieList
 CookieStoreIOS::CanonicalCookieListFromSystemCookies(NSArray* cookies) {
   net::CookieList cookie_list;
   cookie_list.reserve([cookies count]);
   for (NSHTTPCookie* cookie in cookies) {
     base::Time created = creation_time_manager_->GetCreationTime(cookie);
     cookie_list.push_back(CanonicalCookieFromSystemCookie(cookie, created));
   }
   return cookie_list;
 }
 
 }  // namespace net