ServiceWorker: Migrate the script cache backend from BlockFile to Simple

content/browser/service_worker/service_worker_storage.cc

 // 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.
 
 #include "content/browser/service_worker/service_worker_storage.h"
 
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
+#include "content/browser/service_worker/service_worker_disk_cache_migrator.h"
 #include "content/browser/service_worker/service_worker_info.h"
-#include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/special_storage_policy.h"
@@ skipping 24 matching lines @@
     const scoped_refptr<ServiceWorkerRegistration>& registration,
     ServiceWorkerStatusCode status,
     const ServiceWorkerStorage::FindRegistrationCallback& callback) {
   RunSoon(from_here,
           base::Bind(&CompleteFindNow, registration, status, callback));
 }
 
 const base::FilePath::CharType kDatabaseName[] =
     FILE_PATH_LITERAL("Database");
 const base::FilePath::CharType kDiskCacheName[] =
-    FILE_PATH_LITERAL("Cache");
+    FILE_PATH_LITERAL("ScriptCache");
+const base::FilePath::CharType kOldDiskCacheName[] = FILE_PATH_LITERAL("Cache");
 
 const int kMaxMemDiskCacheSize = 10 * 1024 * 1024;
 const int kMaxDiskCacheSize = 250 * 1024 * 1024;
 
 ServiceWorkerStatusCode DatabaseStatusToStatusCode(
     ServiceWorkerDatabase::Status status) {
   switch (status) {
     case ServiceWorkerDatabase::STATUS_OK:
       return SERVICE_WORKER_OK;
     case ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND:
@@ skipping 126 matching lines @@
   }
 
   ReadSomeData();
 }
 
 }  // namespace
 
 ServiceWorkerStorage::InitialData::InitialData()
     : next_registration_id(kInvalidServiceWorkerRegistrationId),
       next_version_id(kInvalidServiceWorkerVersionId),
-      next_resource_id(kInvalidServiceWorkerResourceId) {
+      next_resource_id(kInvalidServiceWorkerResourceId),
+      migration_state(ServiceWorkerDatabase::DISKCACHE_UNKNOWN_STATE) {
 }
 
 ServiceWorkerStorage::InitialData::~InitialData() {
 }
 
 ServiceWorkerStorage::
 DidDeleteRegistrationParams::DidDeleteRegistrationParams()
     : registration_id(kInvalidServiceWorkerRegistrationId) {
 }
 
@@ skipping 700 matching lines @@
     : next_registration_id_(kInvalidServiceWorkerRegistrationId),
       next_version_id_(kInvalidServiceWorkerVersionId),
       next_resource_id_(kInvalidServiceWorkerResourceId),
       state_(UNINITIALIZED),
       path_(path),
       context_(context),
       database_task_manager_(database_task_manager.Pass()),
       disk_cache_thread_(disk_cache_thread),
       quota_manager_proxy_(quota_manager_proxy),
       special_storage_policy_(special_storage_policy),
+      disk_cache_migration_state_(
+          ServiceWorkerDatabase::DISKCACHE_UNKNOWN_STATE),
       is_purge_pending_(false),
       has_checked_for_stale_resources_(false),
       weak_factory_(this) {
   database_.reset(new ServiceWorkerDatabase(GetDatabasePath()));
 }
 
 base::FilePath ServiceWorkerStorage::GetDatabasePath() {
   if (path_.empty())
     return base::FilePath();
   return path_.Append(ServiceWorkerContextCore::kServiceWorkerDirectory)
       .Append(kDatabaseName);
 }
 
 base::FilePath ServiceWorkerStorage::GetDiskCachePath() {
   if (path_.empty())
     return base::FilePath();
   return path_.Append(ServiceWorkerContextCore::kServiceWorkerDirectory)
       .Append(kDiskCacheName);
 }
 
+base::FilePath ServiceWorkerStorage::GetOldDiskCachePath() {
+  if (path_.empty())
+    return base::FilePath();
+  return path_.Append(ServiceWorkerContextCore::kServiceWorkerDirectory)
+      .Append(kOldDiskCacheName);
+}
+
 bool ServiceWorkerStorage::LazyInitialize(const base::Closure& callback) {
   if (!context_)
     return false;
 
   switch (state_) {
     case INITIALIZED:
       return true;
     case DISABLED:
       return false;
     case INITIALIZING:
@@ skipping 19 matching lines @@
     InitialData* data,
     ServiceWorkerDatabase::Status status) {
   DCHECK(data);
   DCHECK_EQ(INITIALIZING, state_);
 
   if (status == ServiceWorkerDatabase::STATUS_OK) {
     next_registration_id_ = data->next_registration_id;
     next_version_id_ = data->next_version_id;
     next_resource_id_ = data->next_resource_id;
     registered_origins_.swap(data->origins);
+    disk_cache_migration_state_ = data->migration_state;
     state_ = INITIALIZED;
   } else {
     DVLOG(2) << "Failed to initialize: "
              << ServiceWorkerDatabase::StatusToString(status);
     ScheduleDeleteAndStartOver();
   }
 
   for (std::vector<base::Closure>::const_iterator it = pending_tasks_.begin();
        it != pending_tasks_.end(); ++it) {
     RunSoon(FROM_HERE, *it);
@@ skipping 97 matching lines @@
 void ServiceWorkerStorage::ReturnFoundRegistration(
     const FindRegistrationCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources) {
   DCHECK(!resources.empty());
   scoped_refptr<ServiceWorkerRegistration> registration =
       GetOrCreateRegistration(data, resources);
   CompleteFindNow(registration, SERVICE_WORKER_OK, callback);
 }
 
+void ServiceWorkerStorage::DidWriteDatabase(
+    const base::Closure& continuation,
+    ServiceWorkerDatabase::Status status) {
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    ScheduleDeleteAndStartOver();
+    return;
+  }
+  continuation.Run();
+}
+
 void ServiceWorkerStorage::DidGetRegistrations(
     const GetRegistrationsCallback& callback,
     RegistrationList* registration_data_list,
     std::vector<ResourceList>* resources_list,
     const GURL& origin_filter,
     ServiceWorkerDatabase::Status status) {
   DCHECK(registration_data_list);
   DCHECK(resources_list);
 
   if (status != ServiceWorkerDatabase::STATUS_OK &&
@@ skipping 283 matching lines @@
 ServiceWorkerStorage::FindInstallingRegistrationForId(
     int64 registration_id) {
   RegistrationRefsById::const_iterator found =
       installing_registrations_.find(registration_id);
   if (found == installing_registrations_.end())
     return NULL;
   return found->second.get();
 }
 
 ServiceWorkerDiskCache* ServiceWorkerStorage::disk_cache() {
+  DCHECK_EQ(INITIALIZED, state_);
   if (disk_cache_)
     return disk_cache_.get();
 
-  disk_cache_ = ServiceWorkerDiskCache::CreateWithBlockFileBackend();
+  disk_cache_ = ServiceWorkerDiskCache::CreateWithSimpleBackend();
 
   base::FilePath path = GetDiskCachePath();
   if (path.empty()) {
     int rv = disk_cache_->InitWithMemBackend(kMaxMemDiskCacheSize,
                                              net::CompletionCallback());
     DCHECK_EQ(net::OK, rv);
     return disk_cache_.get();
   }
 
+  switch (disk_cache_migration_state_) {

[michaeln, 2015/06/12 20:47:58]

if (migration_needed_)
  start it;  // when its done, postafterstartuptask to delete old
else if (deletion_needed_)
  postafterstartuptask to do it

[nhiroki, 2015/06/15 16:43:27]

Done.

+    case ServiceWorkerDatabase::DISKCACHE_NOT_USED: {
+      // Defer the start of initialization until a migration state is updated.
+      disk_cache_->set_is_waiting_to_initialize(true);
+      base::Closure continuation =
+          base::Bind(&ServiceWorkerStorage::InitializeDiskCache,
+                     weak_factory_.GetWeakPtr());
+      PostTaskAndReplyWithResult(
+          database_task_manager_->GetTaskRunner(), FROM_HERE,
+          base::Bind(&ServiceWorkerDatabase::WriteDiskCacheMigrationState,
+                     base::Unretained(database_.get()),
+                     ServiceWorkerDatabase::DISKCACHE_MIGRATED),
+          base::Bind(&ServiceWorkerStorage::DidWriteDatabase,
+                     weak_factory_.GetWeakPtr(), continuation));
+      ServiceWorkerMetrics::RecordDiskCacheMigrationResult(
+          ServiceWorkerMetrics::MIGRATION_NOT_NECESSARY);
+      break;
+    }
+    case ServiceWorkerDatabase::DISKCACHE_NEEDS_TO_MIGRATE: {
+      // Defer the start of initialization until a migration is complete.
+      disk_cache_->set_is_waiting_to_initialize(true);
+      DCHECK(!disk_cache_migrator_);
+      disk_cache_migrator_.reset(new ServiceWorkerDiskCacheMigrator(
+          GetOldDiskCachePath(), GetDiskCachePath(), kMaxDiskCacheSize,
+          disk_cache_thread_));
+      disk_cache_migrator_->Start(
+          base::Bind(&ServiceWorkerStorage::DidMigrateDiskCache,
+                     weak_factory_.GetWeakPtr()));
+      break;
+    }
+    case ServiceWorkerDatabase::DISKCACHE_NEEDS_TO_DELETE_OLD: {
+      // A migration was complete, but an old diskcache still exists.
+      base::Closure continuation = base::Bind(&base::DoNothing);
+      BrowserThread::PostAfterStartupTask(
+          FROM_HERE, database_task_manager_->GetTaskRunner(),
+          base::Bind(&DeleteOldDiskCacheInDB, database_.get(),
+                     base::ThreadTaskRunnerHandle::Get(), GetOldDiskCachePath(),
+                     base::Bind(&ServiceWorkerStorage::DidWriteDatabase,
+                                weak_factory_.GetWeakPtr(), continuation)));
+
+      // Don't have to wait for the completion of deleting the old diskcache.
+      // Immediately continue to initialize.
+      ServiceWorkerMetrics::RecordDiskCacheMigrationResult(
+          ServiceWorkerMetrics::MIGRATION_NOT_NECESSARY);
+      InitializeDiskCache();
+      break;
+    }
+    case ServiceWorkerDatabase::DISKCACHE_MIGRATED: {
+      ServiceWorkerMetrics::RecordDiskCacheMigrationResult(
+          ServiceWorkerMetrics::MIGRATION_NOT_NECESSARY);
+      InitializeDiskCache();
+      break;
+    }
+    case ServiceWorkerDatabase::DISKCACHE_UNKNOWN_STATE: {
+      NOTREACHED();
+      break;
+    }
+  }
+
+  return disk_cache_.get();
+}
+
+void ServiceWorkerStorage::DidMigrateDiskCache(ServiceWorkerStatusCode status) {
+  disk_cache_migrator_.reset();
+
+  if (status != SERVICE_WORKER_OK) {
+    LOG(ERROR) << "Failed to migrate the diskcache: "
+               << ServiceWorkerStatusToString(status);
+    ServiceWorkerMetrics::RecordDiskCacheMigrationResult(
+        ServiceWorkerMetrics::MIGRATION_ERROR_FAILED);
+
+    // Give up a migration and recreate the whole storage.
+    ScheduleDeleteAndStartOver();
+
+    // Delete the old diskcache.
+    disk_cache_thread_->PostTask(
+        FROM_HERE, base::Bind(base::IgnoreResult(&base::DeleteFile),
+                              GetOldDiskCachePath(), true));
+    return;
+  }
+
+  // The migration was complete, but an old diskcache still exists.
+  base::Closure continuation = base::Bind(&base::DoNothing);
+  BrowserThread::PostAfterStartupTask(
+      FROM_HERE, database_task_manager_->GetTaskRunner(),
+      base::Bind(&DeleteOldDiskCacheInDB, database_.get(),
+                 base::ThreadTaskRunnerHandle::Get(), GetOldDiskCachePath(),
+                 base::Bind(&ServiceWorkerStorage::DidWriteDatabase,
+                            weak_factory_.GetWeakPtr(), continuation)));
+
+  // Don't have to wait for the completion of deleting the old diskcache.
+  // Immediately continue to initialize.
+  ServiceWorkerMetrics::RecordDiskCacheMigrationResult(
+      ServiceWorkerMetrics::MIGRATION_OK);
+  InitializeDiskCache();
+}
+
+void ServiceWorkerStorage::InitializeDiskCache() {
+  disk_cache_->set_is_waiting_to_initialize(false);
   int rv = disk_cache_->InitWithDiskBackend(
-      path,
-      kMaxDiskCacheSize,
-      false,
-      disk_cache_thread_,
+      GetDiskCachePath(), kMaxDiskCacheSize, false, disk_cache_thread_,
       base::Bind(&ServiceWorkerStorage::OnDiskCacheInitialized,
                  weak_factory_.GetWeakPtr()));
   if (rv != net::ERR_IO_PENDING)
     OnDiskCacheInitialized(rv);
-
-  return disk_cache_.get();
 }
 
 void ServiceWorkerStorage::OnDiskCacheInitialized(int rv) {
   if (rv != net::OK) {
     LOG(ERROR) << "Failed to open the serviceworker diskcache: "
                << net::ErrorToString(rv);
     ScheduleDeleteAndStartOver();
   }
   ServiceWorkerMetrics::CountInitDiskCacheResult(rv == net::OK);
 }
@@ skipping 137 matching lines @@
   ServiceWorkerDatabase::Status status =
       database->GetNextAvailableIds(&data->next_registration_id,
                                     &data->next_version_id,
                                     &data->next_resource_id);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE, base::Bind(callback, base::Owned(data.release()), status));
     return;
   }
 
+  status = database->ReadDiskCacheMigrationState(&data->migration_state);
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    original_task_runner->PostTask(
+        FROM_HERE, base::Bind(callback, base::Owned(data.release()), status));
+    return;
+  }
+
   status = database->GetOriginsWithRegistrations(&data->origins);
   original_task_runner->PostTask(
       FROM_HERE, base::Bind(callback, base::Owned(data.release()), status));
 }
 
+void ServiceWorkerStorage::DeleteOldDiskCacheInDB(
+    ServiceWorkerDatabase* database,
+    scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+    const base::FilePath& disk_cache_path,
+    const DatabaseStatusCallback& callback) {
+  DCHECK(database);
+  ServiceWorkerDatabase::Status status = database->WriteDiskCacheMigrationState(
+      ServiceWorkerDatabase::DISKCACHE_NEEDS_TO_DELETE_OLD);
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    original_task_runner->PostTask(FROM_HERE, base::Bind(callback, status));
+    return;
+  }
+
+  if (!base::DeleteFile(disk_cache_path, true)) {

[michaeln, 2015/06/12 20:47:58]

it would be good to defer this part till 'afterstartup'

[nhiroki, 2015/06/15 16:43:27]

Done.

+    // Ignore a failure. A migration state has already been recorded in the
+    // database and a retry happens on the next diskcache initialization.
+    original_task_runner->PostTask(
+        FROM_HERE, base::Bind(callback, ServiceWorkerDatabase::STATUS_OK));
+    return;
+  }
+
+  status = database->WriteDiskCacheMigrationState(
+      ServiceWorkerDatabase::DISKCACHE_MIGRATED);
+  original_task_runner->PostTask(FROM_HERE, base::Bind(callback, status));
+}
+
 void ServiceWorkerStorage::DeleteRegistrationFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     int64 registration_id,
     const GURL& origin,
     const DeleteRegistrationCallback& callback) {
   DCHECK(database);
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
@@ skipping 244 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   ServiceWorkerMetrics::RecordDeleteAndStartOverResult(
       ServiceWorkerMetrics::DELETE_OK);
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content