[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..07e760ed780301ee7cf640314a7d4853771f744c
--- /dev/null
+++ b/content/browser/background_sync/background_sync_manager.h
@@ -0,0 +1,167 @@
+// 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.
+class CONTENT_EXPORT BackgroundSyncManager {
+ public:
+  enum ErrorType {
+    ERROR_TYPE_OK = 0,
+    ERROR_TYPE_EXISTS,
+    ERROR_TYPE_STORAGE,
+    ERROR_TYPE_NOT_FOUND
+  };
+
+  // TODO(jkarlin): Remove this and use the struct from IPC messages once it
+  // lands.
+  struct BackgroundSyncRegistration {
+    BackgroundSyncRegistration() {}
+    explicit BackgroundSyncRegistration(const std::string& id) : id(id) {}
+    std::string 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. Will request permission from the user if necessary. Calls |callback|
+  // with ErrorTypeExists if the registration is already registered. Calls
+  // |callback| with ErrorTypeOK and the registration on success.

[davidben, 2015/03/17 18:47:15]

There's no way to change an existing registration, right? I vaguely worry that
people will just defensibly unregister first when using the API.

[jkarlin, 2015/03/20 13:50:49]

The plan was to change this to overwrite existing registrations in a future CL.
But I did it now instead. Done.

+  void Register(const GURL& origin,
+                int64 sw_registration_id,
+                const BackgroundSyncRegistration& sync_registratin,
+                const StatusAndRegistrationCallback& callback);
+
+  // Removes the given background sync registration from storage and the
+  // scheduling queue. Calls |callback| with ErrorTypeNotFound if not
+  // registered. Calls |callback| with ErrorTypeOK on success.
+  void Unregister(const GURL& origin,
+                  int64 sw_registration_id,
+                  const BackgroundSyncRegistration& sync_registration,

[davidben, 2015/03/17 18:47:15]

Should this pass in a sync_registration_id rather than the full registration?
It's weird that you *almost* ignore the (currently non-existent) remaining
parameters.

[jkarlin, 2015/03/20 13:50:49]

Done.

+                  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_id,
+                       const StatusAndRegistrationCallback& callback);
+
+ private:
+  using PermissionStatusCallback = base::Callback<void(bool)>;
+  using IdToRegistrationMap =
+      std::map<int64, std::list<BackgroundSyncRegistration>>;
+
+  explicit BackgroundSyncManager(
+      const scoped_refptr<ServiceWorkerContextWrapper>& context);
+
+  bool HasRegistration(int64 sw_registration_id,
+                       const BackgroundSyncRegistration& sync_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. Otherwise returns false.
+  bool RemoveRegistrationFromMap(
+      int64 sw_registration_id,
+      const BackgroundSyncRegistration& sync_registration);
+
+  // If the registration is not in the map, adds it. Otherwise returns false.
+  bool AddRegistrationToMap(
+      int64 sw_registration_id,
+      const BackgroundSyncRegistration& sync_registration);
+
+  // Init must be called before any public member function. Only call it once.
+  void Init();
+  void InitImpl();
+  void InitDidGetUserData(
+      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 StatusAndRegistrationCallback& callback,
+                        ServiceWorkerStatusCode status);
+
+  // Unregister callbacks
+  void UnregisterImpl(const GURL& origin,
+                      int64 sw_registration_id,
+                      const BackgroundSyncRegistration& sync_registration,
+                      const StatusCallback& callback);
+  void UnregisterDidStore(int64 sw_registration_id,
+                          const BackgroundSyncRegistration& sync_registration,
+                          const StatusCallback& callback,
+                          ServiceWorkerStatusCode status);
+
+  // GetRegistration callbacks
+  void GetRegistrationImpl(const GURL& origin,
+                           int64 sw_registration_id,
+                           const std::string sync_registration_id,
+                           const StatusAndRegistrationCallback& callback);
+
+  // Operation Scheduling callbacks
+  void PendingStatusAndRegistrationCallback(
+      const StatusAndRegistrationCallback& callback,
+      ErrorType error,
+      const BackgroundSyncRegistration& sync_registration);
+  void PendingStatusCallback(const StatusCallback& callback, ErrorType error);
+
+  IdToRegistrationMap registration_map_;
+  ServiceWorkerCacheScheduler op_scheduler_;

[davidben, 2015/03/17 18:47:15]

It's a little odd that operations from one sw_registration_id lock out those
from another. But probably fine?

[jkarlin, 2015/03/20 13:50:49]

I intend to add such parallelism in the future. See the TODO in
ServiceWorkerCacheScheduler. I think it's fine for now but should be addressed
eventually.

+  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_