Service Worker: Delay stale resource cleanup

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 100 matching lines @@
                           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
   // cache but not yet stored with a registration.
-  void StoreUncommittedReponseId(int64 id);
+  void StoreUncommittedResponseId(int64 id);
 
   // Removes |id| from uncommitted list, adds it to the
   // purgeable list and purges it.
   void DoomUncommittedResponse(int64 id);
 
   // Deletes the storage and starts over.
   void DeleteAndStartOver(const StatusCallback& callback);
 
   // Returns new IDs which are guaranteed to be unique in the storage.
   int64 NewRegistrationId();
@@ skipping 20 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageTest,
                            UpdateRegistration);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerResourceStorageDiskTest,
                            CleanupOnRestart);
 
   struct InitialData {
     int64 next_registration_id;
     int64 next_version_id;
     int64 next_resource_id;
     std::set<GURL> origins;
-    std::set<int64> purgeable_resource_ids;
 
     InitialData();
     ~InitialData();
   };
 
   typedef std::vector<ServiceWorkerDatabase::RegistrationData> RegistrationList;
   typedef std::map<int64, scoped_refptr<ServiceWorkerRegistration> >
       RegistrationRefsById;
   typedef base::Callback<void(
       InitialData* data,
       ServiceWorkerDatabase::Status status)> InitializeCallback;
   typedef base::Callback<
       void(const GURL& origin,
            int64 deleted_version_id,
            const std::vector<int64>& newly_purgeable_resources,
            ServiceWorkerDatabase::Status status)> WriteRegistrationCallback;
   typedef base::Callback<
       void(bool origin_is_deletable,
            int64 version_id,
            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;
+  typedef base::Callback<void(const std::vector<int64>& resource_ids,
+                              ServiceWorkerDatabase::Status status)>
+      GetResourcesCallback;
 
   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();
 
+  bool IsReady();
+
   bool LazyInitialize(
       const base::Closure& callback);
   void DidReadInitialData(
       InitialData* data,
       ServiceWorkerDatabase::Status status);
   void DidFindRegistrationForDocument(
       const GURL& document_url,
       const FindRegistrationCallback& callback,
       const ServiceWorkerDatabase::RegistrationData& data,
       const ResourceList& resources,
@@ skipping 47 matching lines @@
   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();
+  void DidCollectStaleResources(const std::vector<int64>& stale_resource_ids,
+                                ServiceWorkerDatabase::Status status);
+
   // Static cross-thread helpers.
+  static void CollectStaleResourcesFromDB(
+      ServiceWorkerDatabase* database,
+      scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+      const GetResourcesCallback& callback);
   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);
@@ skipping 37 matching lines @@
   // Pending database tasks waiting for initialization.
   std::vector<base::Closure> pending_tasks_;
 
   int64 next_registration_id_;
   int64 next_version_id_;
   int64 next_resource_id_;
 
   enum State {
     UNINITIALIZED,
     INITIALIZING,
+    HAS_STALE_RESOURCES,

[michaeln, 2014/07/09 02:36:11]

bikesheddy...

This one is a little different then the other states. Would this be better as a
flag, has_checked_for_stale_resources_? If we keep it a state, having
INITIALIZED in both of the names might make sense

INITIALIZED_FOR_READING
INITIALIZED_FOR_WRITING

[falken, 2014/07/09 04:31:14]

I was a bit torn when writing this. I liked State because it constrains the
possible states instead of a combinatoric explosion of flags and states. But it
does seem to make the code more convoluted with the introduction of IsReady. I
switched back to flag, it feels nicer.

     INITIALIZED,
     DISABLED,
   };
   State state_;
 
   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_resource_ids_;
   bool is_purge_pending_;
   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_