Don't prematurely delete script resources when registration is deleted

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 92 matching lines @@
       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 either a browser restart or
   // DeleteVersionResources is called.
   void DeleteRegistration(int64 registration_id,
                           const GURL& origin,
                           const StatusCallback& callback);
+  void DeleteVersionResources(int64 version_id, 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
   // cache but not yet stored with a registration.
   void StoreUncommittedReponseId(int64 id);
 
@@ skipping 40 matching lines @@
       RegistrationRefsById;
   typedef base::Callback<void(
       InitialData* data,
       ServiceWorkerDatabase::Status status)> InitializeCallback;
   typedef base::Callback<void(
       const GURL& origin,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status)> WriteRegistrationCallback;
   typedef base::Callback<void(
       bool origin_is_deletable,
-      const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status)> DeleteRegistrationCallback;
   typedef base::Callback<void(
-      const ServiceWorkerDatabase::RegistrationData& data,
-      const ResourceList& resources,
-      ServiceWorkerDatabase::Status status)> FindInDBCallback;
+      const std::vector<int64>& newly_purgeable_resources,
+      ServiceWorkerDatabase::Status status)> DeleteVersionResourcesCallback;
+  typedef base::Callback<
+      void(const ServiceWorkerDatabase::RegistrationData& data,
+           const ResourceList& resources,
+           ServiceWorkerDatabase::Status status)> FindInDBCallback;
 
   ServiceWorkerStorage(const base::FilePath& path,
                        base::WeakPtr<ServiceWorkerContextCore> context,
                        base::SequencedTaskRunner* database_task_runner,
                        base::MessageLoopProxy* disk_cache_thread,
                        quota::QuotaManagerProxy* quota_manager_proxy);
 
   base::FilePath GetDatabasePath();
   base::FilePath GetDiskCachePath();
 
@@ skipping 24 matching lines @@
       RegistrationList* registrations,
       ServiceWorkerDatabase::Status status);
   void DidStoreRegistration(
       const StatusCallback& callback,
       const GURL& origin,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status);
   void DidUpdateToActiveState(
       const StatusCallback& callback,
       ServiceWorkerDatabase::Status status);
-  void DidDeleteRegistration(
-      const GURL& origin,
+  void DidDeleteRegistration(const GURL& origin,
+                             const StatusCallback& callback,
+                             bool origin_is_deletable,
+                             ServiceWorkerDatabase::Status status);
+  void DidDeleteVersionResources(
       const StatusCallback& callback,
-      bool origin_is_deletable,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status);
 
   scoped_refptr<ServiceWorkerRegistration> GetOrCreateRegistration(
       const ServiceWorkerDatabase::RegistrationData& data,
       const ResourceList& resources);
   ServiceWorkerRegistration* FindInstallingRegistrationForDocument(
       const GURL& document_url);
   ServiceWorkerRegistration* FindInstallingRegistrationForPattern(
       const GURL& scope);
@@ skipping 14 matching lines @@
   static void ReadInitialDataFromDB(
       ServiceWorkerDatabase* database,
       scoped_refptr<base::SequencedTaskRunner> original_task_runner,
       const InitializeCallback& callback);
   static void DeleteRegistrationFromDB(
       ServiceWorkerDatabase* database,
       scoped_refptr<base::SequencedTaskRunner> original_task_runner,
       int64 registration_id,
       const GURL& origin,
       const DeleteRegistrationCallback& callback);
+  static void DeleteVersionResourcesFromDB(
+      ServiceWorkerDatabase* database,
+      scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+      int64 version_id,
+      const DeleteVersionResourcesCallback& callback);
   static void WriteRegistrationInDB(
       ServiceWorkerDatabase* database,
       scoped_refptr<base::SequencedTaskRunner> original_task_runner,
       const ServiceWorkerDatabase::RegistrationData& registration,
       const ResourceList& resources,
       const WriteRegistrationCallback& callback);
   static void FindForDocumentInDB(
       ServiceWorkerDatabase* database,
       scoped_refptr<base::SequencedTaskRunner> original_task_runner,
       const GURL& document_url,
@@ skipping 42 matching lines @@
   base::FilePath path_;
   base::WeakPtr<ServiceWorkerContextCore> context_;
 
   // 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_reource_ids_;
+  std::deque<int64> purgeable_resource_ids_;
   bool is_purge_pending_;
 
   base::WeakPtrFactory<ServiceWorkerStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_