ServiceWorker: Migrate the script cache backend from BlockFile to Simple

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 <string>
 #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"
 #include "content/browser/service_worker/service_worker_database_task_manager.h"
+#include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/content_export.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "url/gurl.h"
 
 namespace base {
 class SequencedTaskRunner;
 class SingleThreadTaskRunner;
 }
 
 namespace storage {
 class QuotaManagerProxy;
 class SpecialStoragePolicy;
 }
 
 namespace content {
 
 class ServiceWorkerContextCore;
 class ServiceWorkerDiskCache;
+class ServiceWorkerDiskCacheMigrator;
 class ServiceWorkerRegistration;
 class ServiceWorkerResponseMetadataWriter;
 class ServiceWorkerResponseReader;
 class ServiceWorkerResponseWriter;
 struct ServiceWorkerRegistrationInfo;
 
 // This class provides an interface to store and retrieve ServiceWorker
 // registration data.
 class CONTENT_EXPORT ServiceWorkerStorage
     : NON_EXPORTED_BASE(public ServiceWorkerVersion::Listener) {
@@ skipping 155 matching lines @@
 
   // |resources| must already be on the purgeable list.
   void PurgeResources(const ResourceList& resources);
 
  private:
   friend class ServiceWorkerHandleTest;
   friend class ServiceWorkerStorageTest;
   friend class ServiceWorkerResourceStorageTest;
   friend class ServiceWorkerControlleeRequestHandlerTest;
   friend class ServiceWorkerContextRequestHandlerTest;
+  friend class ServiceWorkerDiskCacheMigratorTest;
   friend class ServiceWorkerRequestHandlerTest;
   friend class ServiceWorkerURLRequestJobTest;
   friend class ServiceWorkerVersionBrowserTest;
   friend class ServiceWorkerVersionTest;
   friend class ServiceWorkerWriteToCacheJobTest;
+  FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDiskCacheMigratorTest,
+                           MigrateOnDiskCacheAccess);
+  FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDiskCacheMigratorTest,
+                           NotMigrateOnDatabaseAccess);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDispatcherHostTest,
                            CleanupOnRendererCrash);
   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);
@@ skipping 18 matching lines @@
     GURL origin;
     StatusCallback callback;
 
     DidDeleteRegistrationParams();
     ~DidDeleteRegistrationParams();
   };
 
   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(InitialData* data,
+                              bool needs_disk_cache_migration,
+                              ServiceWorkerDatabase::Status status)>
+      InitializeCallback;
   typedef base::Callback<void(
       const GURL& origin,
       const ServiceWorkerDatabase::RegistrationData& deleted_version_data,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status)> WriteRegistrationCallback;
   typedef base::Callback<void(
       bool origin_is_deletable,
       const ServiceWorkerDatabase::RegistrationData& deleted_version_data,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status)> DeleteRegistrationCallback;
@@ skipping 16 matching lines @@
       const base::FilePath& path,
       base::WeakPtr<ServiceWorkerContextCore> context,
       scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
       const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
       storage::QuotaManagerProxy* quota_manager_proxy,
       storage::SpecialStoragePolicy* special_storage_policy);
 
   base::FilePath GetDatabasePath();
   base::FilePath GetDiskCachePath();
 
-  // Loads the registration data from backend storage. This must be called
-  // before any method that requires registration data.
+  // Returns a path to an old diskcache backed with BlockFile. This is used for
+  // the diskcache migration (see service_worker_disk_cache_migrator.h).
+  // TODO(nhiroki): Remove this after several milestones pass
+  // (http://crbug.com/487482)
+  base::FilePath GetOldDiskCachePath();
+
   bool LazyInitialize(
       const base::Closure& callback);
-  void DidReadInitialData(
-      InitialData* data,
-      ServiceWorkerDatabase::Status status);
+  void DidReadInitialData(InitialData* data,
+                          bool needs_disk_cache_migration,
+                          ServiceWorkerDatabase::Status status);
   void DidFindRegistrationForDocument(
       const GURL& document_url,
       const FindRegistrationCallback& callback,
       int64 callback_id,
       const ServiceWorkerDatabase::RegistrationData& data,
       const ResourceList& resources,
       ServiceWorkerDatabase::Status status);
   void DidFindRegistrationForPattern(
       const GURL& scope,
       const FindRegistrationCallback& callback,
@@ skipping 50 matching lines @@
       const ResourceList& resources);
   ServiceWorkerRegistration* FindInstallingRegistrationForDocument(
       const GURL& document_url);
   ServiceWorkerRegistration* FindInstallingRegistrationForPattern(
       const GURL& scope);
   ServiceWorkerRegistration* FindInstallingRegistrationForId(
       int64 registration_id);
 
   // Lazy disk_cache getter.
   ServiceWorkerDiskCache* disk_cache();
+  void PrepareDiskCacheForMigration();
+  void DidInitializeDiskCacheForMigration(bool* is_failed,
+                                          const base::Closure& barrier_closure,
+                                          int result);
+  void DidPrepareDiskCacheForMigration(
+      scoped_ptr<ServiceWorkerDiskCache> src_disk_cache,
+      scoped_ptr<ServiceWorkerDiskCache> dest_disk_cache,
+      bool* is_failed);
+  void DidMigrateDiskCache(scoped_ptr<ServiceWorkerDiskCacheMigrator> migrator,
+                           scoped_ptr<ServiceWorkerDiskCache> src_disk_cache,
+                           scoped_ptr<ServiceWorkerDiskCache> dest_disk_cache,
+                           ServiceWorkerStatusCode status);
+  void DidDeleteOldDiskCache(bool deleted);
+  void AbortDiskCacheMigration(
+      ServiceWorkerMetrics::DiskCacheMigrationResult result);
+  void InitializeDiskCache();
   void OnDiskCacheInitialized(int rv);
 
   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);
 
   void ClearSessionOnlyOrigins();
 
   // 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 base::FilePath& old_disk_cache_path,
       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 WriteRegistrationInDB(
       ServiceWorkerDatabase* database,
       scoped_refptr<base::SequencedTaskRunner> original_task_runner,
@@ skipping 69 matching lines @@
   base::FilePath path_;
   base::WeakPtr<ServiceWorkerContextCore> context_;
 
   // Only accessed using |database_task_manager_|.
   scoped_ptr<ServiceWorkerDatabase> database_;
 
   scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager_;
   scoped_refptr<base::SingleThreadTaskRunner> disk_cache_thread_;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
   scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
+
   scoped_ptr<ServiceWorkerDiskCache> disk_cache_;
+  bool needs_disk_cache_migration_;
+
   std::deque<int64> purgeable_resource_ids_;
   bool is_purge_pending_;
   bool has_checked_for_stale_resources_;
   std::set<int64> pending_deletions_;
 
   base::WeakPtrFactory<ServiceWorkerStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_