[BackgroundSync] Initial land of the BackgroundSyncManager

content/browser/background_sync/background_sync_manager.h

Index: content/browser/background_sync/background_sync_manager.h
diff --git a/content/browser/background_sync/background_sync_manager.h b/content/browser/background_sync/background_sync_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..674186c8712c25b831a195b32438a63ada1fe660
--- /dev/null
+++ b/content/browser/background_sync/background_sync_manager.h
@@ -0,0 +1,221 @@
+// 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>
+
+#include "base/callback_forward.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "content/browser/service_worker/service_worker_cache_scheduler.h"
+#include "content/browser/service_worker/service_worker_storage.h"
+#include "content/common/content_export.h"
+#include "content/common/service_worker/service_worker_status_code.h"
+#include "url/gurl.h"
+
+namespace content {
+
+class ServiceWorkerContextWrapper;
+
+// 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 expects to be run on the IO
+// thread. The asynchronous methods are executed sequentially.
+
+// TODO(jkarlin): Check permissions when registering, scheduling, and firing
+// background sync. In the meantime, --enable-service-worker-sync is required to
+// fire a sync event.
+// TODO(jkarlin): Unregister syncs when permission is revoked.
+// TODO(jkarlin): Create a background sync scheduler to actually run the
+// registered events.
+// TODO(jkarlin): Keep the browser alive if "Let Google Chrome Run in the
+// Background" is true and a sync is registered.
+// TODO(jkarlin): Unregister syncs when storage for an origin is cleared.
+// TODO(jkarlin): Detect and handle a corrupt or broken backend.
+class CONTENT_EXPORT BackgroundSyncManager {
+ public:
+  enum ErrorType {
+    ERROR_TYPE_OK = 0,
+    ERROR_TYPE_STORAGE,
+    ERROR_TYPE_NOT_FOUND
+  };
+
+  // TODO(jkarlin): Remove this and use the struct from IPC messages once it
+  // lands.
+  struct CONTENT_EXPORT BackgroundSyncRegistration {
+    using RegistrationId = int64;
+    static const RegistrationId kInvalidRegistrationId;
+
+    BackgroundSyncRegistration()
+        : BackgroundSyncRegistration(kInvalidRegistrationId, "") {}
+    explicit BackgroundSyncRegistration(const std::string& name)
+        : BackgroundSyncRegistration(kInvalidRegistrationId, name) {}
+    BackgroundSyncRegistration(int64 id, const std::string& name)
+        : id(id), min_period(0), name(name) {}
+
+    bool Equals(const BackgroundSyncRegistration& other) {
+      return this->name == other.name && this->min_period == other.min_period;
+    }
+
+    RegistrationId id;
+    int64 min_period;
+    std::string name;
+  };
+
+  struct CONTENT_EXPORT BackgroundSyncRegistrations {
+    using NameToRegistrationMap =
+        std::map<std::string, BackgroundSyncRegistration>;
+    static const BackgroundSyncRegistration::RegistrationId kInitialId;
+
+    BackgroundSyncRegistrations();
+    explicit BackgroundSyncRegistrations(
+        BackgroundSyncRegistration::RegistrationId next_id);
+    ~BackgroundSyncRegistrations();
+
+    NameToRegistrationMap name_to_registration_map;
+    BackgroundSyncRegistration::RegistrationId next_id;
+  };
+
+  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);
+  virtual ~BackgroundSyncManager();
+
+  // Stores the given background sync registration and adds it to the scheduling
+  // queue. Overwrites any existing registration with the same name but
+  // different parameters (other than the id). Calls |callback| with ErrorTypeOK
+  // 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(const GURL& origin,
+                int64 sw_registration_id,
+                const BackgroundSyncRegistration& sync_registration,
+                const StatusAndRegistrationCallback& callback);
+
+  // Removes the background sync registration with |sync_registration_name| if
+  // the |sync_registration_id| matches. |sync_registration_id| will not match
+  // if, for instance, a new registration with the same name has replaced it.
+  // Calls |callback| with ErrorTypeNotFound if no match is found. Calls
+  // |callback| with ErrorTypeOK on success.
+  void Unregister(
+      const GURL& origin,
+      int64 sw_registration_id,
+      const std::string& sync_registration_name,
+      BackgroundSyncRegistration::RegistrationId sync_registration_id,
+      const StatusCallback& callback);
+
+  // Finds the background sync registration associated with
+  // |sw_registration_id|. Calls |callback| with ErrorTypeNotFound if it doesn't
+  // exist. Calls |callback| with ErrorTypeOK on success.
+  void GetRegistration(const GURL& origin,
+                       int64 sw_registration_id,
+                       const std::string sync_registration_name,
+                       const StatusAndRegistrationCallback& callback);
+
+ protected:
+  explicit BackgroundSyncManager(
+      const scoped_refptr<ServiceWorkerContextWrapper>& context);
+
+  // Init must be called before any public member function. Only call it once.
+  void Init();
+
+  // The following methods are virtual for testing.
+  virtual void StoreDataInBackend(
+      int64 sw_registration_id,
+      const GURL& origin,
+      const std::string& key,
+      const std::string& data,
+      const ServiceWorkerStorage::StatusCallback& callback);
+  virtual void GetDataFromBackend(
+      const std::string& key,
+      const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
+          callback);
+
+ private:
+  using PermissionStatusCallback = base::Callback<void(bool)>;
+  using SWIdToRegistrationsMap = std::map<int64, BackgroundSyncRegistrations>;
+
+  // Returns the existing registration in |existing_registration| if it is not
+  // null.
+  bool LookupRegistration(int64 sw_registration_id,
+                          const std::string& sync_registration_name,
+                          BackgroundSyncRegistration* existing_registration);
+
+  // Store all registrations for a given |sw_registration_id|.
+  void StoreRegistrations(const GURL& origin,
+                          int64 sw_registration_id,
+                          const ServiceWorkerStorage::StatusCallback& callback);
+
+  // If the registration is in the map, removes it and returns the removed
+  // registration in |old_registration|. |old_registration| may be null.
+  void RemoveRegistrationFromMap(int64 sw_registration_id,
+                                 const std::string& sync_registration_name,
+                                 BackgroundSyncRegistration* old_registration);
+
+  void AddRegistrationToMap(
+      int64 sw_registration_id,
+      const BackgroundSyncRegistration& sync_registration);
+
+  void InitImpl();
+  void InitDidGetDataFromBackend(
+      const std::vector<std::pair<int64, std::string>>& user_data,
+      ServiceWorkerStatusCode status);
+
+  // Register callbacks
+  void RegisterImpl(const GURL& origin,
+                    int64 sw_registration_id,
+                    const BackgroundSyncRegistration& sync_registration,
+                    const StatusAndRegistrationCallback& callback);
+  void RegisterDidStore(int64 sw_registration_id,
+                        const BackgroundSyncRegistration& sync_registration,
+                        const BackgroundSyncRegistration& previous_registration,
+                        const StatusAndRegistrationCallback& callback,
+                        ServiceWorkerStatusCode status);
+
+  // Unregister callbacks
+  void UnregisterImpl(
+      const GURL& origin,
+      int64 sw_registration_id,
+      const std::string& sync_registration_name,
+      BackgroundSyncRegistration::RegistrationId sync_registration_id,
+      const StatusCallback& callback);
+  void UnregisterDidStore(
+      int64 sw_registration_id,
+      const BackgroundSyncRegistration& old_sync_registration,
+      const StatusCallback& callback,
+      ServiceWorkerStatusCode status);
+
+  // GetRegistration callbacks
+  void GetRegistrationImpl(const GURL& origin,
+                           int64 sw_registration_id,
+                           const std::string sync_registration_name,
+                           const StatusAndRegistrationCallback& callback);
+
+  // Operation Scheduling callbacks
+  void PendingStatusAndRegistrationCallback(
+      const StatusAndRegistrationCallback& callback,
+      ErrorType error,
+      const BackgroundSyncRegistration& sync_registration);
+  void PendingStatusCallback(const StatusCallback& callback, ErrorType error);
+
+  SWIdToRegistrationsMap sw_to_registrations_map_;
+  ServiceWorkerCacheScheduler op_scheduler_;
+  scoped_refptr<ServiceWorkerContextWrapper> service_worker_context_;
+
+  base::WeakPtrFactory<BackgroundSyncManager> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(BackgroundSyncManager);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_