[BackgroundSync] Fire one-shot sync events

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 <list>
 #include <map>
 
@@ skipping 45 matching lines @@
     static const RegistrationId kInitialId;
     BackgroundSyncRegistration() {}
 
     bool Equals(const BackgroundSyncRegistration& other) const {
       return this->tag == other.tag && this->periodicity == other.periodicity &&
              this->min_period == other.min_period &&
              network_state == other.network_state &&
              power_state == other.power_state;
     }
 
-    RegistrationId id = kInvalidRegistrationId;
+    // Registrations options from the specification
     std::string tag;
-    SyncPeriodicity periodicity = SYNC_ONE_SHOT;
     int64 min_period = 0;
     SyncNetworkState network_state = NETWORK_STATE_ONLINE;
     SyncPowerState power_state = POWER_STATE_AVOID_DRAINING;
+
+    // Implementation specific members
+    RegistrationId id = kInvalidRegistrationId;
+    SyncPeriodicity periodicity = SYNC_ONE_SHOT;
+    SyncState sync_state = SYNC_STATE_PENDING;
   };
 
   using StatusCallback = base::Callback<void(ErrorType)>;
   using StatusAndRegistrationCallback =
       base::Callback<void(ErrorType, const BackgroundSyncRegistration&)>;
 
   static scoped_ptr<BackgroundSyncManager> Create(
       const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context);
   ~BackgroundSyncManager() override;
 
@@ skipping 46 matching lines @@
   virtual void StoreDataInBackend(
       int64 sw_registration_id,
       const GURL& origin,
       const std::string& backend_key,
       const std::string& data,
       const ServiceWorkerStorage::StatusCallback& callback);
   virtual void GetDataFromBackend(
       const std::string& backend_key,
       const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
           callback);
+  virtual void FireOneShotSync(
+      const scoped_refptr<ServiceWorkerVersion>& active_version,
+      const ServiceWorkerVersion::StatusCallback& callback);
 
  private:
   class RegistrationKey {
    public:
     explicit RegistrationKey(const BackgroundSyncRegistration& registration);
     RegistrationKey(const std::string& tag, SyncPeriodicity periodicity);
     RegistrationKey(const RegistrationKey& other) = default;
     RegistrationKey& operator=(const RegistrationKey& other) = default;
 
     bool operator<(const RegistrationKey& rhs) const {
@@ skipping 95 matching lines @@
   void OnNetworkChanged();
 
   // Operation Scheduling callbacks
   void PendingStatusAndRegistrationCallback(
       const StatusAndRegistrationCallback& callback,
       ErrorType error,
       const BackgroundSyncRegistration& sync_registration);
   void PendingStatusCallback(const StatusCallback& callback, ErrorType error);
   void PendingClosure(const base::Closure& closure);
 
+  bool IsRegistrationReadyToFire(
+      const BackgroundSyncRegistration& registration);
+
+  // FireReadyEvents and callbacks
+  void FireReadyEvents();
+  void FireReadyEventsImpl(const base::Closure& callback);
+  void FireReadyEventsDidFindRegistration(
+      const RegistrationKey& registration_key,
+      BackgroundSyncRegistration::RegistrationId registration_id,
+      const base::Closure& callback,
+      ServiceWorkerStatusCode service_worker_status,
+      const scoped_refptr<ServiceWorkerRegistration>&
+          service_worker_registration);
+
+  // Called when a sync event has completed.
+  void EventComplete(
+      int64 service_worker_id,
+      const RegistrationKey& key,
+      BackgroundSyncRegistration::RegistrationId sync_registration_id,
+      ServiceWorkerStatusCode status_code);
+  void EventCompleteImpl(
+      int64 service_worker_id,
+      const RegistrationKey& key,
+      BackgroundSyncRegistration::RegistrationId sync_registration_id,
+      ServiceWorkerStatusCode status_code,
+      const base::Closure& callback);
+  void EventCompleteDidStore(int64 service_worker_id,
+                             const base::Closure& callback,
+                             ServiceWorkerStatusCode status_code);
+
   StatusAndRegistrationCallback MakeStatusAndRegistrationCompletion(
       const StatusAndRegistrationCallback& callback);
   BackgroundSyncManager::StatusCallback MakeStatusCompletion(
       const StatusCallback& callback);
   base::Closure MakeEmptyCompletion();
 
   SWIdToRegistrationsMap sw_to_registrations_map_;
   CacheStorageScheduler op_scheduler_;
   scoped_refptr<ServiceWorkerContextWrapper> service_worker_context_;
   bool disabled_;
 
   scoped_ptr<BackgroundSyncNetworkObserver> network_observer_;
 
   base::WeakPtrFactory<BackgroundSyncManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_