Shift cookie system callbacks to OnceCallback to impedance match mojo.

ios/net/cookies/cookie_store_ios.h

 // 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.
 
 #ifndef IOS_NET_COOKIES_COOKIE_STORE_IOS_H_
 #define IOS_NET_COOKIES_COOKIE_STORE_IOS_H_
 
 #include <map>
 #include <memory>
 #include <string>
@@ skipping 57 matching lines @@
   // |NSHTTPCookieStorage sharedHTTPCookieStorage|.
   static void NotifySystemCookiesChanged();
 
   // Only one cookie store may enable metrics.
   void SetMetricsEnabled();
 
   // Inherited CookieStore methods.
   void SetCookieWithOptionsAsync(const GURL& url,
                                  const std::string& cookie_line,
                                  const net::CookieOptions& options,
-                                 const SetCookiesCallback& callback) override;
+                                 SetCookiesCallback callback) override;
   void 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) override;
+                                 SetCookiesCallback callback) override;
   void SetCanonicalCookieAsync(std::unique_ptr<CanonicalCookie> cookie,
                                bool secure_source,
                                bool modify_http_only,
-                               const SetCookiesCallback& callback) override;
+                               SetCookiesCallback callback) override;
   void GetCookiesWithOptionsAsync(const GURL& url,
                                   const net::CookieOptions& options,
-                                  const GetCookiesCallback& callback) override;
-  void GetCookieListWithOptionsAsync(
-      const GURL& url,
-      const net::CookieOptions& options,
-      const GetCookieListCallback& callback) override;
-  void GetAllCookiesAsync(const GetCookieListCallback& callback) override;
+                                  GetCookiesCallback callback) override;
+  void GetCookieListWithOptionsAsync(const GURL& url,
+                                     const net::CookieOptions& options,
+                                     GetCookieListCallback callback) override;
+  void GetAllCookiesAsync(GetCookieListCallback callback) override;
   void DeleteCookieAsync(const GURL& url,
                          const std::string& cookie_name,
-                         const base::Closure& callback) override;
-  void DeleteCanonicalCookieAsync(
-      const CanonicalCookie& cookie,
-      const DeleteCallback& callback) override;
+                         base::OnceClosure callback) override;
+  void DeleteCanonicalCookieAsync(const CanonicalCookie& cookie,
+                                  DeleteCallback callback) override;
   void DeleteAllCreatedBetweenAsync(const base::Time& delete_begin,
                                     const base::Time& delete_end,
-                                    const DeleteCallback& callback) override;
+                                    DeleteCallback callback) override;
   void DeleteAllCreatedBetweenWithPredicateAsync(
       const base::Time& delete_begin,
       const base::Time& delete_end,
       const CookiePredicate& predicate,
-      const DeleteCallback& callback) override;
-  void DeleteSessionCookiesAsync(const DeleteCallback& callback) override;
-  void FlushStore(const base::Closure& callback) override;
+      DeleteCallback callback) override;
+  void DeleteSessionCookiesAsync(DeleteCallback callback) override;
+  void FlushStore(base::OnceClosure callback) override;
 
   std::unique_ptr<CookieChangedSubscription> AddCallbackForCookie(
       const GURL& url,
       const std::string& name,
       const CookieChangedCallback& callback) override;
 
   bool IsEphemeral() override;
 
  protected:
   CookieStoreIOS(net::CookieMonster::PersistentCookieStore* persistent_store,
                  NSHTTPCookieStorage* system_store);
 
   // These three functions are used for wrapping user-supplied callbacks given
   // to CookieStoreIOS mutator methods. Given a callback, they return a new
   // callback that invokes UpdateCachesFromCookieMonster() to schedule an
   // asynchronous synchronization of the cookie cache and then calls the
   // original callback.
-  SetCookiesCallback WrapSetCallback(const SetCookiesCallback& callback);
-  DeleteCallback WrapDeleteCallback(const DeleteCallback& callback);
-  base::Closure WrapClosure(const base::Closure& callback);
+  SetCookiesCallback WrapSetCallback(SetCookiesCallback callback);
+  DeleteCallback WrapDeleteCallback(DeleteCallback callback);
+  base::OnceClosure WrapClosure(base::OnceClosure callback);
 
   bool metrics_enabled() { return metrics_enabled_; }
 
   net::CookieMonster* cookie_monster() { return cookie_monster_.get(); }
 
   const base::ThreadChecker& thread_checker() { return thread_checker_; }
 
  private:
   // Cookie filter for DeleteCookiesWithFilter().
   // Takes a cookie and a creation time and returns true the cookie must be
   // 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();
   // Copies the cookies to the backing CookieMonster.
   virtual void WriteToCookieMonster(NSArray* system_cookies);
 
   // Inherited CookieNotificationObserver methods.
   void OnSystemCookiesChanged() override;
 
   void DeleteCookiesWithFilter(const CookieFilterFunction& filter,
-                               const DeleteCallback& callback);
+                               DeleteCallback callback);
 
   std::unique_ptr<net::CookieMonster> cookie_monster_;
   base::scoped_nsobject<NSHTTPCookieStorage> system_store_;
   std::unique_ptr<CookieCreationTimeManager> creation_time_manager_;
   bool metrics_enabled_;
   base::CancelableClosure flush_closure_;
 
   base::ThreadChecker thread_checker_;
 
   // Cookie notification methods.
@@ skipping 42 matching lines @@
 
   // Fetches new values for all (url, name) pairs that have hooks registered,
   // 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(const DeleteCallback& callback,
+  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(
-      const DeleteCallback& callback,
+      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
   // hence running callbacks).
   //
   // When this CookieStoreIOS object is not synchronized, the various mutator
   // methods (SetCookieWithOptionsAsync &c) instead store their state in a
   // CookieMonster object to be written back when the system store synchronizes.
   // To deliver notifications in a timely manner, the mutators have to ensure
   // that hooks get run, but only after the changes have been written back to
   // CookieMonster. To do this, the mutators wrap the user-supplied callback in
   // a callback which schedules an asynchronous task to synchronize the cache
   // and run callbacks, then calls through to the user-specified callback.
   //
   // These three UpdateCachesAfter functions are responsible for scheduling an
   // asynchronous cache update (using UpdateCachesFromCookieMonster()) and
   // calling the provided callback.
 
-  void UpdateCachesAfterSet(const SetCookiesCallback& callback, bool success);
-  void UpdateCachesAfterDelete(const DeleteCallback& callback, int num_deleted);
-  void UpdateCachesAfterClosure(const base::Closure& callback);
+  void UpdateCachesAfterSet(SetCookiesCallback callback, bool success);
+  void UpdateCachesAfterDelete(DeleteCallback callback, int num_deleted);
+  void UpdateCachesAfterClosure(base::OnceClosure callback);
 
   // Takes an NSArray of NSHTTPCookies as returns a net::CookieList.
   // The returned cookies are ordered by longest path, then earliest
   // creation date.
   net::CookieList CanonicalCookieListFromSystemCookies(NSArray* 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_;
 
   // Callbacks for cookie changes installed by AddCallbackForCookie.
   std::map<std::pair<GURL, std::string>,
            std::unique_ptr<CookieChangedCallbackList>>
       hook_map_;
 
   base::WeakPtrFactory<CookieStoreIOS> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieStoreIOS);
 };
 
 }  // namespace net
 
 #endif  // IOS_NET_COOKIES_COOKIE_STORE_IOS_H_