service worker: Avoid starting up for activation during shutdown

content/browser/service_worker/service_worker_registration.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_REGISTRATION_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_REGISTRATION_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
+#include "base/timer/timer.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/content_export.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 namespace content {
 
 class ServiceWorkerVersion;
 struct ServiceWorkerRegistrationInfo;
 
 // Represents the core of a service worker registration object. Other
 // registration derivatives (WebServiceWorkerRegistration etc) ultimately refer
 // to this class. This is refcounted via ServiceWorkerRegistrationHandle to
 // facilitate multiple controllees being associated with the same registration.
 class CONTENT_EXPORT ServiceWorkerRegistration
-    : NON_EXPORTED_BASE(public base::RefCounted<ServiceWorkerRegistration>),
-      public ServiceWorkerVersion::Listener {
+    : public NON_EXPORTED_BASE(
+          base::RefCountedThreadSafe<ServiceWorkerRegistration,
+                                     BrowserThread::DeleteOnIOThread>),
+      public NON_EXPORTED_BASE(ServiceWorkerVersion::Listener) {
  public:
   typedef base::Callback<void(ServiceWorkerStatusCode status)> StatusCallback;
 
   class Listener {
    public:
     virtual void OnVersionAttributesChanged(
         ServiceWorkerRegistration* registration,
         ChangedVersionAttributesMask changed_mask,
         const ServiceWorkerRegistrationInfo& info) {}
     virtual void OnRegistrationFailed(
@@ skipping 21 matching lines @@
   bool is_uninstalled() const { return is_uninstalled_; }
 
   int64_t resources_total_size_bytes() const {
     return resources_total_size_bytes_;
   }
 
   void set_resources_total_size_bytes(int64_t resources_total_size_bytes) {
     resources_total_size_bytes_ = resources_total_size_bytes;
   }
 
+  // Returns the active version. This version may be in ACTIVATING or ACTIVATED
+  // state. If you require an ACTIVATED version, use
+  // ServiceWorkerContextWrapper::FindReadyRegistration* to get a registration
+  // with such a version. Alternatively, use
+  // ServiceWorkerVersion::Listener::OnVersionStateChanged to wait for the
+  // ACTIVATING version to become ACTIVATED.
   ServiceWorkerVersion* active_version() const {
     return active_version_.get();
   }
 
   ServiceWorkerVersion* waiting_version() const {
     return waiting_version_.get();
   }
 
   ServiceWorkerVersion* installing_version() const {
     return installing_version_.get();
@@ skipping 48 matching lines @@
   base::Time last_update_check() const { return last_update_check_; }
   void set_last_update_check(base::Time last) { last_update_check_ = last; }
 
   // Unsets the version and deletes its resources. Also deletes this
   // registration from storage if there is no longer a stored version.
   void DeleteVersion(const scoped_refptr<ServiceWorkerVersion>& version);
 
   void RegisterRegistrationFinishedCallback(const base::Closure& callback);
   void NotifyRegistrationFinished();
 
+  void SetTimerTaskRunnerForTest(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
  private:
-  friend class base::RefCounted<ServiceWorkerRegistration>;
+  friend class base::RefCountedThreadSafe<
+      ServiceWorkerRegistration,
+      content::BrowserThread::DeleteOnIOThread>;
+  friend class base::DeleteHelper<ServiceWorkerRegistration>;
+  friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
 
   ~ServiceWorkerRegistration() override;
 
   void UnsetVersionInternal(
       ServiceWorkerVersion* version,
       ChangedVersionAttributesMask* mask);
 
   // ServiceWorkerVersion::Listener override.
   void OnNoControllees(ServiceWorkerVersion* version) override;
 
-  // This method corresponds to the [[Activate]] algorithm.
-  void ActivateWaitingVersion();
+  // Promotes the waiting version to active version. If |delay| is true, waits
+  // a short time before attempting to start and dispatch the activate event
+  // to the version.
+  void ActivateWaitingVersion(bool delay);
+  void ContinueActivation(
+      const scoped_refptr<ServiceWorkerVersion>& activating_version);

[nhiroki, 2016/06/01 05:51:48]

[Optional] As you might already know, passing "const scoped_refptr<>&" is not
encouraged any more:
http://www.chromium.org/developers/smart-pointer-guidelines#TOC-What-about-pa...

I know other places in this file have been still using this idiom, but it'd be
nice if we could adopt the new idiom one by one.

[falken, 2016/06/01 09:20:05]

I changed to use scoped_refptr and std::move when it looked safe. For
base::Bind, do you use std::move?

[nhiroki, 2016/06/03 00:54:29]

I use std::move if an object is not used anymore after base::Bind.

   void DispatchActivateEvent(
       const scoped_refptr<ServiceWorkerVersion>& activating_version);
   void OnActivateEventFinished(
       const scoped_refptr<ServiceWorkerVersion>& activating_version,
       ServiceWorkerStatusCode status);
+  // Actually sets |activating_version| to ACTIVATED and writes to
+  // storage that it's active.
+  void CompleteActivation(
+      const scoped_refptr<ServiceWorkerVersion>& activating_version,
+      ServiceWorkerStatusCode status,
+      bool is_shutdown);
+
   void OnDeleteFinished(ServiceWorkerStatusCode status);
 
   // This method corresponds to the [[ClearRegistration]] algorithm.
   void Clear();
 
   void OnRestoreFinished(const StatusCallback& callback,
                          scoped_refptr<ServiceWorkerVersion> version,
                          ServiceWorkerStatusCode status);
 
   const GURL pattern_;
   const int64_t registration_id_;
   bool is_deleted_;
   bool is_uninstalling_;
   bool is_uninstalled_;
   bool should_activate_when_ready_;
   base::Time last_update_check_;
   int64_t resources_total_size_bytes_;
+  base::OneShotTimer timer_;
 
   // This registration is the primary owner of these versions.
   scoped_refptr<ServiceWorkerVersion> active_version_;
   scoped_refptr<ServiceWorkerVersion> waiting_version_;
   scoped_refptr<ServiceWorkerVersion> installing_version_;
 
   base::ObserverList<Listener> listeners_;
   std::vector<base::Closure> registration_finished_callbacks_;
   base::WeakPtr<ServiceWorkerContextCore> context_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRegistration);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_REGISTRATION_H_