BackgroundSync: Convert to base::BindOnce/OnceCallback/OnceClosure

content/browser/background_sync/background_sync_manager.h

 // Copyright 2015 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 CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_
 #define CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 35 matching lines @@
 
 // BackgroundSyncManager manages and stores the set of background sync
 // registrations across all registered service workers for a profile.
 // Registrations are stored along with their associated Service Worker
 // registration in ServiceWorkerStorage. If the ServiceWorker is unregistered,
 // the sync registrations are removed. This class must be run on the IO
 // thread. The asynchronous methods are executed sequentially.
 class CONTENT_EXPORT BackgroundSyncManager
     : NON_EXPORTED_BASE(public ServiceWorkerContextCoreObserver) {
  public:
-  using BoolCallback = base::Callback<void(bool)>;
-  using StatusCallback = base::Callback<void(BackgroundSyncStatus)>;
+  using BoolCallback = base::OnceCallback<void(bool)>;
   using StatusAndRegistrationCallback =
-      base::Callback<void(BackgroundSyncStatus,
-                          std::unique_ptr<BackgroundSyncRegistration>)>;
-  using StatusAndRegistrationsCallback = base::Callback<void(
+      base::OnceCallback<void(BackgroundSyncStatus,
+                              std::unique_ptr<BackgroundSyncRegistration>)>;
+  using StatusAndRegistrationsCallback = base::OnceCallback<void(
       BackgroundSyncStatus,
       std::vector<std::unique_ptr<BackgroundSyncRegistration>>)>;
 
   static std::unique_ptr<BackgroundSyncManager> Create(
       scoped_refptr<ServiceWorkerContextWrapper> service_worker_context);
   ~BackgroundSyncManager() override;
 
   // Stores the given background sync registration and adds it to the scheduling
   // queue. It will overwrite an existing registration with the same tag unless
   // they're identical (save for the id). Calls |callback| with
   // BACKGROUND_SYNC_STATUS_OK and the accepted registration on success.
   // The accepted registration will have a unique id. It may also have altered
   // parameters if the user or UA chose different parameters than those
   // supplied.
   void Register(int64_t sw_registration_id,
                 const BackgroundSyncRegistrationOptions& options,
-                const StatusAndRegistrationCallback& callback);
+                StatusAndRegistrationCallback callback);
 
   // Finds the background sync registrations associated with
   // |sw_registration_id|. Calls |callback| with BACKGROUND_SYNC_STATUS_OK on
   // success.
   void GetRegistrations(int64_t sw_registration_id,
-                        const StatusAndRegistrationsCallback& callback);
+                        StatusAndRegistrationsCallback callback);
 
   // ServiceWorkerContextCoreObserver overrides.
   void OnRegistrationDeleted(int64_t sw_registration_id,
                              const GURL& pattern) override;
   void OnStorageWiped() override;
 
   // Sets the max number of sync attempts after any pending operations have
   // completed.
   void SetMaxSyncAttemptsForTesting(int max_attempts);
 
@@ skipping 29 matching lines @@
       const ServiceWorkerStorage::StatusCallback& callback);
   virtual void GetDataFromBackend(
       const std::string& backend_key,
       const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
           callback);
   virtual void DispatchSyncEvent(
       const std::string& tag,
       scoped_refptr<ServiceWorkerVersion> active_version,
       blink::mojom::BackgroundSyncEventLastChance last_chance,
       const ServiceWorkerVersion::StatusCallback& callback);
-  virtual void ScheduleDelayedTask(const base::Closure& callback,
+  virtual void ScheduleDelayedTask(base::OnceClosure callback,
                                    base::TimeDelta delay);
   virtual void HasMainFrameProviderHost(const GURL& origin,
-                                        const BoolCallback& callback);
+                                        BoolCallback callback);
 
  private:
   friend class TestBackgroundSyncManager;
   friend class BackgroundSyncManagerTest;
 
   struct BackgroundSyncRegistrations {
     using RegistrationMap = std::map<std::string, BackgroundSyncRegistration>;
 
     BackgroundSyncRegistrations();
     BackgroundSyncRegistrations(const BackgroundSyncRegistrations& other);
     ~BackgroundSyncRegistrations();
 
     RegistrationMap registration_map;
     BackgroundSyncRegistration::RegistrationId next_id;
     GURL origin;
   };
 
-  using PermissionStatusCallback = base::Callback<void(bool)>;
   using SWIdToRegistrationsMap = std::map<int64_t, BackgroundSyncRegistrations>;
 
   static const size_t kMaxTagLength = 10240;
 
   // Disable the manager. Already queued operations will abort once they start
   // to run (in their impl methods). Future operations will not queue.
   // The list of active registrations is cleared and the backend is also cleared
   // (if it's still functioning). The manager will reenable itself once it
   // receives the OnStorageWiped message or on browser restart.
-  void DisableAndClearManager(const base::Closure& callback);
+  void DisableAndClearManager(base::OnceClosure callback);
   void DisableAndClearDidGetRegistrations(
-      const base::Closure& callback,
+      base::OnceClosure callback,
       const std::vector<std::pair<int64_t, std::string>>& user_data,
       ServiceWorkerStatusCode status);
-  void DisableAndClearManagerClearedOne(const base::Closure& barrier_closure,
+  void DisableAndClearManagerClearedOne(base::OnceClosure barrier_closure,
                                         ServiceWorkerStatusCode status);
 
   // Returns the existing registration or nullptr if it cannot be found.
   BackgroundSyncRegistration* LookupActiveRegistration(
       int64_t sw_registration_id,
       const std::string& tag);
 
   // Write all registrations for a given |sw_registration_id| to persistent
   // storage.
   void StoreRegistrations(int64_t sw_registration_id,
                           const ServiceWorkerStorage::StatusCallback& callback);
 
   // Removes the active registration if it is in the map.
   void RemoveActiveRegistration(int64_t sw_registration_id,
                                 const std::string& tag);
 
   void AddActiveRegistration(
       int64_t sw_registration_id,
       const GURL& origin,
       const BackgroundSyncRegistration& sync_registration);
 
-  void InitImpl(const base::Closure& callback);
+  void InitImpl(base::OnceClosure callback);
   void InitDidGetControllerParameters(
-      const base::Closure& callback,
+      base::OnceClosure callback,
       std::unique_ptr<BackgroundSyncParameters> parameters);
   void InitDidGetDataFromBackend(
-      const base::Closure& callback,
+      base::OnceClosure callback,
       const std::vector<std::pair<int64_t, std::string>>& user_data,
       ServiceWorkerStatusCode status);
 
   // Register callbacks
   void RegisterCheckIfHasMainFrame(
       int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& options,
-      const StatusAndRegistrationCallback& callback);
+      StatusAndRegistrationCallback callback);
   void RegisterDidCheckIfMainFrame(
       int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& options,
-      const StatusAndRegistrationCallback& callback,
+      StatusAndRegistrationCallback callback,
       bool has_main_frame_client);
   void RegisterImpl(int64_t sw_registration_id,
                     const BackgroundSyncRegistrationOptions& options,
-                    const StatusAndRegistrationCallback& callback);
+                    StatusAndRegistrationCallback callback);
   void RegisterDidAskForPermission(
       int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& options,
-      const StatusAndRegistrationCallback& callback,
+      StatusAndRegistrationCallback callback,
       blink::mojom::PermissionStatus permission_status);
   void RegisterDidStore(int64_t sw_registration_id,
                         const BackgroundSyncRegistration& new_registration,
-                        const StatusAndRegistrationCallback& callback,
+                        StatusAndRegistrationCallback callback,
                         ServiceWorkerStatusCode status);
 
   // GetRegistrations callbacks
   void GetRegistrationsImpl(int64_t sw_registration_id,
-                            const StatusAndRegistrationsCallback& callback);
+                            StatusAndRegistrationsCallback callback);
 
   bool AreOptionConditionsMet(const BackgroundSyncRegistrationOptions& options);
   bool IsRegistrationReadyToFire(
       const BackgroundSyncRegistration& registration);
 
   // Determines if the browser needs to be able to run in the background (e.g.,
   // to run a pending registration or verify that a firing registration
   // completed). If background processing is required it calls out to the
   // BackgroundSyncController to enable it.
   // Assumes that all registrations in the pending state are not currently ready
   // to fire. Therefore this should not be called directly and should only be
   // called by FireReadyEvents.
   void RunInBackgroundIfNecessary();
 
   // FireReadyEvents scans the list of available events and fires those that are
   // ready to fire. For those that can't yet be fired, wakeup alarms are set.
   void FireReadyEvents();
-  void FireReadyEventsImpl(const base::Closure& callback);
+  void FireReadyEventsImpl(base::OnceClosure callback);
   void FireReadyEventsDidFindRegistration(
       const std::string& tag,
       BackgroundSyncRegistration::RegistrationId registration_id,
-      const base::Closure& event_fired_callback,
-      const base::Closure& event_completed_callback,
+      base::OnceClosure event_fired_callback,
+      base::OnceClosure event_completed_callback,
       ServiceWorkerStatusCode service_worker_status,
       scoped_refptr<ServiceWorkerRegistration> service_worker_registration);
-  void FireReadyEventsAllEventsFiring(const base::Closure& callback);
+  void FireReadyEventsAllEventsFiring(base::OnceClosure callback);
 
   // Called when a sync event has completed.
   void EventComplete(
       scoped_refptr<ServiceWorkerRegistration> service_worker_registration,
       int64_t service_worker_id,
       const std::string& tag,
-      const base::Closure& callback,
+      base::OnceClosure callback,
       ServiceWorkerStatusCode status_code);
   void EventCompleteImpl(int64_t service_worker_id,
                          const std::string& tag,
                          ServiceWorkerStatusCode status_code,
-                         const base::Closure& callback);
+                         base::OnceClosure callback);
   void EventCompleteDidStore(int64_t service_worker_id,
-                             const base::Closure& callback,
+                             base::OnceClosure callback,
                              ServiceWorkerStatusCode status_code);
 
   // Called when all sync events have completed.
   static void OnAllSyncEventsCompleted(const base::TimeTicks& start_time,
                                        int number_of_batched_sync_events);
 
   // OnRegistrationDeleted callbacks
   void OnRegistrationDeletedImpl(int64_t sw_registration_id,
-                                 const base::Closure& callback);
+                                 base::OnceClosure callback);
 
   // OnStorageWiped callbacks
-  void OnStorageWipedImpl(const base::Closure& callback);
+  void OnStorageWipedImpl(base::OnceClosure callback);
 
   void OnNetworkChanged();
 
   // SetMaxSyncAttempts callback
   void SetMaxSyncAttemptsImpl(int max_sync_attempts,
-                              const base::Closure& callback);
+                              base::OnceClosure callback);
 
-  base::Closure MakeEmptyCompletion();
+  base::OnceClosure MakeEmptyCompletion();
 
   SWIdToRegistrationsMap active_registrations_;
   CacheStorageScheduler op_scheduler_;
   scoped_refptr<ServiceWorkerContextWrapper> service_worker_context_;
 
   std::unique_ptr<BackgroundSyncParameters> parameters_;
 
   // True if the manager is disabled and registrations should fail.
   bool disabled_;
 
   // The number of registrations currently in the firing state.
   int num_firing_registrations_;
 
   base::CancelableCallback<void()> delayed_sync_task_;
 
   std::unique_ptr<BackgroundSyncNetworkObserver> network_observer_;
 
   std::unique_ptr<base::Clock> clock_;
 
   base::WeakPtrFactory<BackgroundSyncManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_