Service Worker: set active worker to REDUNDANT when unregistered

content/browser/service_worker/service_worker_storage.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_STORAGE_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 74 matching lines @@
                                   const FindRegistrationCallback& callback);
   void FindRegistrationForId(int64 registration_id,
                              const GURL& origin,
                              const FindRegistrationCallback& callback);
 
   // Returns info about all stored and initially installing registrations.
   void GetAllRegistrations(const GetAllRegistrationInfosCallback& callback);
 
   // Commits |registration| with the installed but not activated |version|
   // to storage, overwritting any pre-existing registration data for the scope.
-  // A pre-existing version's script resources will remain available until
-  // it no longer controls a page, or a browser restart occurs.
+  // A pre-existing version's script resources remain available if that version
+  // is live. PurgeResources should be called when it's OK to delete them.
   void StoreRegistration(
       ServiceWorkerRegistration* registration,
       ServiceWorkerVersion* version,
       const StatusCallback& callback);
 
   // Updates the state of the registration's stored version to active.
   void UpdateToActiveState(
       ServiceWorkerRegistration* registration,
       const StatusCallback& callback);
 
-  // Deletes the registration data for |registration_id|. The script resources
-  // for the registration's stored version will remain available until that
-  // version no longer controls a page, or a browser restart occurs.
+  // Deletes the registration data for |registration_id|. If the registration's
+  // version is live, its script resources will remain available.
+  // PurgeResources should be called when it's OK to delete them.
   void DeleteRegistration(int64 registration_id,
                           const GURL& origin,
                           const StatusCallback& callback);
 
   scoped_ptr<ServiceWorkerResponseReader> CreateResponseReader(
       int64 response_id);
   scoped_ptr<ServiceWorkerResponseWriter> CreateResponseWriter(
       int64 response_id);
 
   // Adds |id| to the set of resources ids that are in the disk
@@ skipping 16 matching lines @@
   void NotifyInstallingRegistration(
       ServiceWorkerRegistration* registration);
   void NotifyDoneInstallingRegistration(
       ServiceWorkerRegistration* registration,
       ServiceWorkerVersion* version,
       ServiceWorkerStatusCode status);
 
   void Disable();
   bool IsDisabled() const;
 
+  // |resources| must already be on the purgeable list.
+  void PurgeResources(const ResourceList& resources);
+
  private:
   friend class ServiceWorkerResourceStorageTest;
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageTest,
+                           DeleteRegistration_NoLiveVersion);
+  FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageTest,
                            DeleteRegistration_WaitingVersion);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageTest,
                            DeleteRegistration_ActiveVersion);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageTest,
                            UpdateRegistration);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageDiskTest,
                            CleanupOnRestart);
 
   struct InitialData {
     int64 next_registration_id;
@@ skipping 87 matching lines @@
       const GURL& document_url);
   ServiceWorkerRegistration* FindInstallingRegistrationForPattern(
       const GURL& scope);
   ServiceWorkerRegistration* FindInstallingRegistrationForId(
       int64 registration_id);
 
   // Lazy disk_cache getter.
   ServiceWorkerDiskCache* disk_cache();
   void OnDiskCacheInitialized(int rv);
 
-  // ServiceWorkerVersion::Listener override
-  virtual void OnNoControllees(ServiceWorkerVersion* version) OVERRIDE;
-
-  void SchedulePurgeResources(int64 version_id,
-                              const std::vector<int64>& resources);
   void StartPurgingResources(const std::vector<int64>& ids);
   void StartPurgingResources(const ResourceList& resources);
   void ContinuePurgingResources();
   void PurgeResource(int64 id);
   void OnResourcePurged(int64 id, int rv);
 
   // Deletes purgeable and uncommitted resources left over from the previous
   // browser session. This must be called once per session before any database
   // operation that may mutate the purgeable or uncommitted resource lists.
   void DeleteStaleResources();
@@ skipping 73 matching lines @@
   // Only accessed on |database_task_runner_|.
   scoped_ptr<ServiceWorkerDatabase> database_;
 
   scoped_refptr<base::SequencedTaskRunner> database_task_runner_;
   scoped_refptr<base::MessageLoopProxy> disk_cache_thread_;
   scoped_refptr<quota::QuotaManagerProxy> quota_manager_proxy_;
   scoped_ptr<ServiceWorkerDiskCache> disk_cache_;
   std::deque<int64> purgeable_resource_ids_;
   bool is_purge_pending_;
   bool has_checked_for_stale_resources_;
-  std::map<int64, std::vector<int64> > deleted_version_resource_ids_;
 
   base::WeakPtrFactory<ServiceWorkerStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_