Store the service worker script and its imports on first load... really

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>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/service_worker/service_worker_database.h"
@@ skipping 28 matching lines @@
   typedef base::Callback<void(ServiceWorkerStatusCode status,
                               const scoped_refptr<ServiceWorkerRegistration>&
                                   registration)> FindRegistrationCallback;
   typedef base::Callback<
       void(const std::vector<ServiceWorkerRegistrationInfo>& registrations)>
           GetAllRegistrationInfosCallback;
   typedef base::Callback<
       void(ServiceWorkerStatusCode status, int result)>
           CompareCallback;
 
-  struct InitialData {
-    int64 next_registration_id;
-    int64 next_version_id;
-    int64 next_resource_id;
-    std::set<GURL> origins;
-
-    InitialData();
-    ~InitialData();
-  };
-
   ServiceWorkerStorage(const base::FilePath& path,
                        base::WeakPtr<ServiceWorkerContextCore> context,
                        base::SequencedTaskRunner* database_task_runner,
                        base::MessageLoopProxy* disk_cache_thread,
                        quota::QuotaManagerProxy* quota_manager_proxy);
   ~ServiceWorkerStorage();
 
   // Finds registration for |document_url| or |pattern| or |registration_id|.
   // The Find methods will find stored and initially installing registrations.
   // Returns SERVICE_WORKER_OK with non-null registration if registration
@@ skipping 48 matching lines @@
 
   // Intended for use only by ServiceWorkerRegisterJob.
   void NotifyInstallingRegistration(
       ServiceWorkerRegistration* registration);
   void NotifyDoneInstallingRegistration(
       ServiceWorkerRegistration* registration);
 
  private:
   friend class ServiceWorkerStorageTest;
 
+  struct InitialData {
+    int64 next_registration_id;
+    int64 next_version_id;
+    int64 next_resource_id;
+    std::set<GURL> origins;
+
+    InitialData();
+    ~InitialData();
+  };
+
   typedef std::vector<ServiceWorkerDatabase::RegistrationData> RegistrationList;
   typedef std::vector<ServiceWorkerDatabase::ResourceRecord> ResourceList;
+  typedef std::map<int64, scoped_refptr<ServiceWorkerRegistration> >
+      RegistrationRefsById;
+  typedef base::Callback<void(
+      ServiceWorkerStorage::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;
+
+  base::FilePath GetDatabasePath();
+  base::FilePath GetDiskCachePath();
 
   bool LazyInitialize(
       const base::Closure& callback);
   void DidReadInitialData(
       InitialData* data,
       ServiceWorkerDatabase::Status status);
-  void DidGetRegistrationsForPattern(
+  void DidFindRegistrationForDocument(
+      const GURL& document_url,
+      const FindRegistrationCallback& callback,
+      const ServiceWorkerDatabase::RegistrationData& data,
+      const ResourceList& resources,
+      ServiceWorkerDatabase::Status status);
+  void DidFindRegistrationForPattern(
       const GURL& scope,
       const FindRegistrationCallback& callback,
-      RegistrationList* registrations,
+      const ServiceWorkerDatabase::RegistrationData& data,
+      const ResourceList& resources,
       ServiceWorkerDatabase::Status status);
-  void DidGetRegistrationsForDocument(
-      const GURL& scope,
+  void DidFindRegistrationForId(
       const FindRegistrationCallback& callback,
-      RegistrationList* registrations,
-      ServiceWorkerDatabase::Status status);
-  void DidReadRegistrationForId(
-      const FindRegistrationCallback& callback,
-      ServiceWorkerDatabase::RegistrationData* registration,
-      ResourceList* resources,
+      const ServiceWorkerDatabase::RegistrationData& data,
+      const ResourceList& resources,
       ServiceWorkerDatabase::Status status);
   void DidGetAllRegistrations(
       const GetAllRegistrationInfosCallback& callback,
       RegistrationList* registrations,
       ServiceWorkerDatabase::Status status);
   void DidStoreRegistration(
+      const StatusCallback& callback,
       const GURL& origin,
-      const StatusCallback& callback,
+      const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status);
   void DidUpdateToActiveState(
       const StatusCallback& callback,
       ServiceWorkerDatabase::Status status);
   void DidDeleteRegistration(
       const GURL& origin,
       const StatusCallback& callback,
       bool origin_is_deletable,
+      const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status);
 
-  scoped_refptr<ServiceWorkerRegistration> CreateRegistration(
-      const ServiceWorkerDatabase::RegistrationData& data);
+  scoped_refptr<ServiceWorkerRegistration> GetOrCreateRegistration(
+      const ServiceWorkerDatabase::RegistrationData& data,
+      const ResourceList& resources);
   ServiceWorkerRegistration* FindInstallingRegistrationForDocument(
       const GURL& document_url);
   ServiceWorkerRegistration* FindInstallingRegistrationForPattern(
       const GURL& scope);
   ServiceWorkerRegistration* FindInstallingRegistrationForId(
       int64 registration_id);
 
-  // For finding registrations being installed.
-  typedef std::map<int64, scoped_refptr<ServiceWorkerRegistration> >
-      RegistrationRefsById;
-  RegistrationRefsById installing_registrations_;
-
   // Lazy disk_cache getter.
   ServiceWorkerDiskCache* disk_cache();
+  void OnDiskCacheInitialized(int rv);
+
+  void StartPurgingResources(const std::vector<int64>& ids);
+  void PurgeResource(int64 id);
+  void OnResourcePurged(int64 id, int rv);
+
+  // Static cross-thread helpers.
+  static void ReadInitialDataFromDB(
+      ServiceWorkerDatabase* database,
+      scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+      const InitializeCallback& callback);
+  static void ServiceWorkerStorage::DeleteRegistrationFromDB(
+      ServiceWorkerDatabase* database,
+      scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+      int64 registration_id,
+      const GURL& origin,
+      const DeleteRegistrationCallback& 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,
+      const FindInDBCallback& callback);
+  static void FindForPatternInDB(
+      ServiceWorkerDatabase* database,
+      scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+      const GURL& scope,
+      const FindInDBCallback& callback);
+  static void FindForIdInDB(
+      ServiceWorkerDatabase* database,
+      scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+      int64 registration_id,
+      const GURL& origin,
+      const FindInDBCallback& callback);
+
+  // For finding registrations being installed.
+  RegistrationRefsById installing_registrations_;
 
   // Origins having registations.
   std::set<GURL> registered_origins_;
 
   // 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,
     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_reource_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_