Implement registration job ordering

content/browser/service_worker/service_worker_register_job.h

 // Copyright 2013 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_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 {
 
+class ServiceWorkerJobCoordinator;
+
 // A ServiceWorkerRegisterJob lives only for the lifetime of a single
 // registration or unregistration.
 class ServiceWorkerRegisterJob {
  public:
+  enum RegistrationType {
+    REGISTER,
+    UNREGISTER,
+  };
+
   typedef base::Callback<void(ServiceWorkerRegistrationStatus status,
                               const scoped_refptr<ServiceWorkerRegistration>&
                                   registration)> RegistrationCallback;
   typedef base::Callback<void(ServiceWorkerRegistrationStatus status)>
       UnregistrationCallback;
 
   typedef base::Callback<void(
       ServiceWorkerRegisterJob* job,
       ServiceWorkerRegistrationStatus status,
       ServiceWorkerRegistration* registration)> 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);
+                           ServiceWorkerJobCoordinator* coordinator,
+                           const GURL& pattern,
+                           const GURL& script_url,
+                           RegistrationType type);
   ~ServiceWorkerRegisterJob();
 
+  void AddCallback(const RegistrationCompleteCallback& callback);
+
+  // hack for now. Could be virtual
+  void Start() {
+    if (type_ == REGISTER)
+      StartRegister();
+    else
+      StartUnregister();
+    running_ = true;
+  }

[kinuko, 2014/01/08 08:38:36]

Can you move this to .cc ?

[alecflett, 2014/01/08 23:59:16]

oops! meant to do that before uploading. Done.

+
+  const GURL& pattern() const { return pattern_; }
+  const GURL& script_url() const {
+    DCHECK(type_ == REGISTER);

[kinuko, 2014/01/08 08:38:36]

We seem to call this for UNREGISTER case too?

[alecflett, 2014/01/08 23:59:16]

the && short-circuits this call)

But we never should need to call this - unregister doesn't have the notion of a
script_url so to ever call it means the caller is trying to do something wrong.

+    return script_url_;
+  }
+  RegistrationType type() const { return type_; }
+  bool is_running() const { return running_; }

[kinuko, 2014/01/08 08:38:36]

This doesn't seem to be used, or relying on this flag feels a bit sketch-- can
we remove this (until we find it necessary)?

[alecflett, 2014/01/08 23:59:16]

this is mainly for tests - I thought I had an EXPECT_TRUE/FALSE, I must have
left it out

I'd also like to expose this in the internals page (still under construction)

I'll make sure the test is there and will comment that this is (currently) only
for tests.

+
+ private:
   // 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.
-  void StartRegister(const GURL& pattern, const GURL& script_url);
+  void StartRegister();
 
   // 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);
+  void StartUnregister();
 
- private:
   // These are all steps in the registration and unregistration pipeline.
   void RegisterPatternAndContinue(
-      const GURL& pattern,
-      const GURL& script_url,
       const RegistrationCallback& callback,
       ServiceWorkerRegistrationStatus previous_status);
 
   void UnregisterPatternAndContinue(
-      const GURL& pattern,
-      const GURL& script_url,
       const UnregistrationCallback& callback,
       bool found,
       ServiceWorkerRegistrationStatus previous_status,
       const scoped_refptr<ServiceWorkerRegistration>& previous_registration);
 
   // These methods are the last internal callback in the callback
   // chain, and ultimately call callback_.
   void UnregisterComplete(ServiceWorkerRegistrationStatus status);
   void RegisterComplete(
       ServiceWorkerRegistrationStatus status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
+  void RunCallbacks(
+      ServiceWorkerRegistrationStatus status,
+      const scoped_refptr<ServiceWorkerRegistration>& registration);
+
   const base::WeakPtr<ServiceWorkerStorage> storage_;
-  const RegistrationCompleteCallback callback_;
+  ServiceWorkerJobCoordinator* coordinator_;
+  const GURL pattern_;
+  GURL script_url_;  // should be unset for register case
+  std::vector<RegistrationCompleteCallback> callbacks_;
   base::WeakPtrFactory<ServiceWorkerRegisterJob> weak_factory_;
+  const RegistrationType type_;
+  bool running_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRegisterJob);
 };
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_REGISTER_JOB_H_