Implement memory-persistent registration

content/browser/service_worker/service_worker_register_job.h

Index: content/browser/service_worker/service_worker_register_job.h
diff --git a/content/browser/service_worker/service_worker_register_job.h b/content/browser/service_worker/service_worker_register_job.h
new file mode 100644
index 0000000000000000000000000000000000000000..06e0c6bd8ede79eb390508a1f0e19e15a5c57201
--- /dev/null
+++ b/content/browser/service_worker/service_worker_register_job.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.

[kinuko, 2013/12/04 13:04:29]

Some files have (c) while others do not.  Afaik our current agreement in the
community is we do not need this (c), so maybe we should just drop all (c) from
new files.

[alecflett, 2013/12/06 05:43:33]

Whatever I check in, there's some bot that always fixes them. I can never
remember which we need, but I'll make 'em consistent with the existing files.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_REGISTER_JOB_H_
+#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_REGISTER_JOB_H_
+
+#include "base/memory/weak_ptr.h"
+#include "content/browser/service_worker/service_worker_registration_status.h"
+#include "content/browser/service_worker/service_worker_storage.h"
+
+namespace content {
+
+// A ServiceWorkerRegisterJob lives only for the lifetime of a single
+// registration or unregistration.
+class ServiceWorkerRegisterJob {
+ public:
+  typedef base::Callback<
+      void(ServiceWorkerRegisterJob*,
+           ServiceWorkerRegistrationStatus status,
+           ServiceWorkerRegistration*)> RegistrationCompleteCallback;
+
+  // All type of jobs (Register and Unregister) complete through a
+  // single call to this callback on the IO thread.
+  ServiceWorkerRegisterJob(const base::WeakPtr<ServiceWorkerStorage>& storage,
+                           const RegistrationCompleteCallback& callback);
+  ~ServiceWorkerRegisterJob();
+
+  // The Registration flow includes most or all of the following,
+  // depending on what is already registered:
+  //  - creating a ServiceWorkerRegistration instance if there isn't
+  //    already something registered
+  //  - creating a ServiceWorkerVersion for the new registration instance.
+  //  - starting a worker for the ServiceWorkerVersion
+  //  - telling the Version to evaluate the script
+  //  - firing the 'install' event at the ServiceWorkerVersion
+  //  - firing the 'activate' event at the ServiceWorkerVersion
+  //  - Waiting for older ServiceWorkerVersions to deactivate
+  //  - designating the new version to be the 'active' version
+  // This method should be called once and only once per job.

[kinuko, 2013/12/04 13:04:29]

To perform all these operations would Storage be the right place to own this job
class?  It looks it needs to do a bit of storage-related operation but also
needs to interact with a lot of other classes.

[alecflett, 2013/12/06 05:43:33]

I think as far as owning the Job class instance, its a reasonable place for the
near term - my hope is to shield ServiceWorkerStorage from the implementation
details of the job, so it kind of doesn't matter who owns it. 

I guess the ServiceWorkerContext could also own it, but it has a 1:1
relationship with ServiceWorkerStorage and  I'm trying not to clutter up the
main context class.

+  void StartRegister(const GURL& pattern, const GURL& script_url);
+
+  // The Unregistration process is primarily cleanup, removing
+  // everything that was created during the Registration process,
+  // including the ServiceWorkerRegistration itself.
+  // This method should be called once and only once per job.
+  void StartUnregister(const GURL& pattern);
+
+ private:
+  // These are all steps in the registration and unregistration pipeline.
+  void RegisterPatternAndContinue(
+      const GURL& pattern,
+      const GURL& script_url,
+      const ServiceWorkerStorage::RegistrationCallback& callback,
+      ServiceWorkerRegistrationStatus previous_status);
+
+  void UnregisterPatternAndContinue(
+      const GURL& pattern,
+      const GURL& script_url,
+      const ServiceWorkerStorage::UnregistrationCallback& callback,
+      ServiceWorkerRegistrationStatus previous_status,
+      const scoped_refptr<ServiceWorkerRegistration>& previous_registration);
+
+  // These methods convert

[kinuko, 2013/12/04 13:04:29]

incomplete sentence?

[alecflett, 2013/12/06 05:43:33]

Done.

+  void UnregisterComplete(ServiceWorkerRegistrationStatus status);
+  void RegisterComplete(
+      ServiceWorkerRegistrationStatus status,
+      const scoped_refptr<ServiceWorkerRegistration>& registration);
+
+  const base::WeakPtr<ServiceWorkerStorage> storage_;
+  const RegistrationCompleteCallback callback_;
+  base::WeakPtrFactory<ServiceWorkerRegisterJob> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRegisterJob);
+};
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_REGISTER_JOB_H_