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 567 matching lines @@
   // The registration should no longer be findable.
   pending_deletions_.insert(registration_id);
   ServiceWorkerRegistration* registration =
       context_->GetLiveRegistration(registration_id);
   if (registration)
     registration->set_is_deleted(true);
 }
 
 scoped_ptr<ServiceWorkerResponseReader>
 ServiceWorkerStorage::CreateResponseReader(int64 response_id) {
+  DCHECK_EQ(INITIALIZED, state_);
   return make_scoped_ptr(
       new ServiceWorkerResponseReader(response_id, disk_cache()));
 }
 
 scoped_ptr<ServiceWorkerResponseWriter>
 ServiceWorkerStorage::CreateResponseWriter(int64 response_id) {
+  DCHECK_EQ(INITIALIZED, state_);
   return make_scoped_ptr(
       new ServiceWorkerResponseWriter(response_id, disk_cache()));
 }
 
 scoped_ptr<ServiceWorkerResponseMetadataWriter>
 ServiceWorkerStorage::CreateResponseMetadataWriter(int64 response_id) {
+  DCHECK_EQ(INITIALIZED, state_);
   return make_scoped_ptr(
       new ServiceWorkerResponseMetadataWriter(response_id, disk_cache()));
 }
 
 void ServiceWorkerStorage::StoreUncommittedResponseId(int64 id) {
   DCHECK_NE(kInvalidServiceWorkerResponseId, id);
   DCHECK_EQ(INITIALIZED, state_);
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
@@ skipping 269 matching lines @@
       .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:
       pending_tasks_.push_back(callback);
       return false;
     case UNINITIALIZED:
       pending_tasks_.push_back(callback);
       // Fall-through.
   }
 
   state_ = INITIALIZING;
+
+  if (GetOldDiskCachePath().empty()) {
+    // In-memory storage does not have to migrate.
+    ContinueLazyInitialize();
+    return false;
+  }
+
+  // Check if the old DiskCache directory exists.
+  PostTaskAndReplyWithResult(
+      disk_cache_thread_.get(), FROM_HERE,
+      base::Bind(&base::DirectoryExists, GetOldDiskCachePath()),
+      base::Bind(&ServiceWorkerStorage::DidCheckOldDiskCacheDirectory,
+                 weak_factory_.GetWeakPtr()));
+  return false;
+}
+
+void ServiceWorkerStorage::DidCheckOldDiskCacheDirectory(bool exists) {
+  if (!exists) {
+    // DiskCache has already been migrated.
+    ServiceWorkerMetrics::RecordDiskCacheMigrationResult(
+        ServiceWorkerMetrics::MIGRATION_NOT_NECESSARY);
+    ContinueLazyInitialize();
+    return;
+  }
+
+  // Initialize the old DiskCache.
+  scoped_ptr<ServiceWorkerDiskCache> old_disk_cache =
+      ServiceWorkerDiskCache::CreateWithBlockFileBackend();
+  ServiceWorkerDiskCache* old_disk_cache_ptr = old_disk_cache.get();
+  net::CompletionCallback callback = base::Bind(
+      &ServiceWorkerStorage::DidInitializeOldDiskCache,
+      weak_factory_.GetWeakPtr(), base::Passed(old_disk_cache.Pass()));
+
+  int result = old_disk_cache_ptr->InitWithDiskBackend(
+      GetOldDiskCachePath(), kMaxDiskCacheSize, false /* force */,
+      disk_cache_thread_, callback);
+  if (result == net::ERR_IO_PENDING)
+    return;
+  callback.Run(result);
+}
+
+void ServiceWorkerStorage::DidInitializeOldDiskCache(
+    scoped_ptr<ServiceWorkerDiskCache> old_disk_cache,
+    int result) {
+  if (result != net::OK) {
+    LOG(ERROR) << "Failed to initialize the diskcache: " << result;
+    AbortLazyInitialize(ServiceWorkerMetrics::MIGRATION_ERROR_INITIALIZE);
+    return;
+  }
+
+  // Start migrating resources stored in the old DiskCache.
+  scoped_ptr<ServiceWorkerDiskCacheMigrator> migrator(
+      new ServiceWorkerDiskCacheMigrator(old_disk_cache.get(), disk_cache()));
+  ServiceWorkerDiskCacheMigrator* migrator_ptr = migrator.get();
+  migrator_ptr->Start(base::Bind(
+      &ServiceWorkerStorage::DidDiskCacheMigrated, weak_factory_.GetWeakPtr(),
+      base::Passed(migrator.Pass()), base::Passed(old_disk_cache.Pass())));
+}
+
+void ServiceWorkerStorage::DidDiskCacheMigrated(
+    scoped_ptr<ServiceWorkerDiskCacheMigrator> migrator,
+    scoped_ptr<ServiceWorkerDiskCache> old_disk_cache,
+    ServiceWorkerStatusCode status) {
+  if (status != SERVICE_WORKER_OK) {
+    LOG(ERROR) << "Failed to migrate the diskcache: " << status;
+    AbortLazyInitialize(ServiceWorkerMetrics::MIGRATION_ERROR_FAILED);
+    return;
+  }
+
+  // Delete the old DiskCache directory.
+  migrator.reset();
+  old_disk_cache.reset();
+  PostTaskAndReplyWithResult(
+      disk_cache_thread_.get(), FROM_HERE,
+      base::Bind(&base::DeleteFile, GetOldDiskCachePath(), true),
+      base::Bind(&ServiceWorkerStorage::DidDeleteOldDiskCache,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void ServiceWorkerStorage::DidDeleteOldDiskCache(bool deleted) {
+  if (!deleted) {
+    LOG(ERROR) << "Failed to delete the old diskcache directory";
+    AbortLazyInitialize(
+        ServiceWorkerMetrics::MIGRATION_ERROR_DELETE_DISK_CACHE);
+    return;
+  }
+
+  ContinueLazyInitialize();
+}
+
+void ServiceWorkerStorage::AbortLazyInitialize(
+    ServiceWorkerMetrics::DiskCacheMigrationResult result) {

[falken, 2015/06/01 04:31:49]

DCHECK(result != OK)?

[nhiroki, 2015/06/02 09:18:33]

Done.

+  ServiceWorkerMetrics::RecordDiskCacheMigrationResult(result);
+
+  // Give up the migration and recreate the whole storage.
+  ScheduleDeleteAndStartOver();
+
+  // Pending tasks will be aborted due to the disabled storage.
+  for (const base::Closure& pending_task : pending_tasks_)
+    RunSoon(FROM_HERE, pending_task);

[falken, 2015/06/01 04:31:50]

Is this OK? Should the pending tasks be run after start over is complete?

I actually don't really understand the comment: is it saying "abort the pending
tasks" or "when the pending tasks run they will be aborted" or "if we don't run
them now, the pending tasks would be aborted"...?

[nhiroki, 2015/06/02 09:18:33]

ScheduleDeleteAndStartOver() disables the storage and schedules the recovery
task to be accompanied with multiple thread hops, so the pending tasks should
run before the recovery is done and fail due to the disabled storage.

Updated the comment. Please let me know if this is still ambiguous.

+  pending_tasks_.clear();
+}
+
+void ServiceWorkerStorage::ContinueLazyInitialize() {
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ReadInitialDataFromDB,
                  database_.get(),
                  base::ThreadTaskRunnerHandle::Get(),
                  base::Bind(&ServiceWorkerStorage::DidReadInitialData,
                             weak_factory_.GetWeakPtr())));
-  return false;
 }
 
 void ServiceWorkerStorage::DidReadInitialData(
     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);
     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);
-  }
+  for (const base::Closure& pending_task : pending_tasks_)
+    RunSoon(FROM_HERE, pending_task);
   pending_tasks_.clear();
 }
 
 void ServiceWorkerStorage::DidFindRegistrationForDocument(
     const GURL& document_url,
     const FindRegistrationCallback& callback,
     int64 callback_id,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources,
     ServiceWorkerDatabase::Status status) {
@@ skipping 352 matching lines @@
       installing_registrations_.find(registration_id);
   if (found == installing_registrations_.end())
     return NULL;
   return found->second.get();
 }
 
 ServiceWorkerDiskCache* ServiceWorkerStorage::disk_cache() {
   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();
   }
 
   int rv = disk_cache_->InitWithDiskBackend(
@@ skipping 426 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