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/barrier_closure.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 848 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),
+      needs_disk_cache_migration_(false),
       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:
       pending_tasks_.push_back(callback);
       return false;
     case UNINITIALIZED:
       pending_tasks_.push_back(callback);
       // Fall-through.
   }
 
   state_ = INITIALIZING;
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&ReadInitialDataFromDB,
-                 database_.get(),
-                 base::ThreadTaskRunnerHandle::Get(),
+      base::Bind(&ReadInitialDataFromDB, database_.get(),
+                 base::ThreadTaskRunnerHandle::Get(), GetOldDiskCachePath(),
                  base::Bind(&ServiceWorkerStorage::DidReadInitialData,
                             weak_factory_.GetWeakPtr())));
   return false;
 }
 
 void ServiceWorkerStorage::DidReadInitialData(
     InitialData* data,
+    bool needs_disk_cache_migration,
     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;
+    needs_disk_cache_migration_ = needs_disk_cache_migration;

[michaeln, 2015/06/08 21:36:33]

Curiosity: I wish we didn't have to migrate at all because too many thing can go
wrong. What is it that is forced us to migrate instead of going with the
comparatively simple starting with a clean slate?

[nhiroki, 2015/06/09 15:41:56]

Yeah... it's definitely simpler and easier to achieve..., but it'd be preferable
to avoid losing (push) registrations:
https://code.google.com/p/chromium/issues/detail?id=487482#c13

   } 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 359 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()) {
+  if (GetDiskCachePath().empty()) {
     int rv = disk_cache_->InitWithMemBackend(kMaxMemDiskCacheSize,
                                              net::CompletionCallback());
     DCHECK_EQ(net::OK, rv);
     return disk_cache_.get();
   }
 
+  if (needs_disk_cache_migration_) {
+    // Defer the start of initialization until the migration is complete.
+    disk_cache_->set_is_waiting_to_initialize(true);
+    PrepareDiskCacheForMigration();
+    return disk_cache_.get();
+  }
+
+  // DiskCache has already been migrated.
+  ServiceWorkerMetrics::RecordDiskCacheMigrationResult(
+      ServiceWorkerMetrics::MIGRATION_NOT_NECESSARY);
+  InitializeDiskCache();
+
+  return disk_cache_.get();
+}
+
+void ServiceWorkerStorage::PrepareDiskCacheForMigration() {
+  scoped_ptr<ServiceWorkerDiskCache> src_disk_cache =
+      ServiceWorkerDiskCache::CreateWithBlockFileBackend();
+  ServiceWorkerDiskCache* src_disk_cache_ptr = src_disk_cache.get();
+  scoped_ptr<ServiceWorkerDiskCache> dest_disk_cache =
+      ServiceWorkerDiskCache::CreateWithSimpleBackend();
+  ServiceWorkerDiskCache* dest_disk_cache_ptr = dest_disk_cache.get();
+  bool* is_failed = new bool(false);
+
+  // This closure is called when both diskcaches are initialized.
+  base::Closure barrier_closure = base::BarrierClosure(
+      2, base::Bind(
+             &ServiceWorkerStorage::DidPrepareDiskCacheForMigration,
+             weak_factory_.GetWeakPtr(), base::Passed(src_disk_cache.Pass()),
+             base::Passed(dest_disk_cache.Pass()), base::Owned(is_failed)));
+
+  // Initialize the src DiskCache.
+  net::CompletionCallback src_callback =
+      base::Bind(&ServiceWorkerStorage::DidInitializeDiskCacheForMigration,
+                 weak_factory_.GetWeakPtr(), is_failed, barrier_closure);
+  int result = src_disk_cache_ptr->InitWithDiskBackend(
+      GetOldDiskCachePath(), kMaxDiskCacheSize, false /* force */,
+      disk_cache_thread_, src_callback);
+  if (result != net::ERR_IO_PENDING)
+    src_callback.Run(result);
+
+  // Initialize the dest DiskCache.

[michaeln, 2015/06/08 21:36:33]

Since a migration attempt can be started multiple times, should the first step
be to delete any partial results from an earlier attempt?

[nhiroki, 2015/06/09 15:41:56]

Done.

+  net::CompletionCallback dest_callback =
+      base::Bind(&ServiceWorkerStorage::DidInitializeDiskCacheForMigration,
+                 weak_factory_.GetWeakPtr(), is_failed, barrier_closure);
+  result = dest_disk_cache_ptr->InitWithDiskBackend(
+      GetDiskCachePath(), kMaxDiskCacheSize, false /* force */,
+      disk_cache_thread_, dest_callback);
+  if (result != net::ERR_IO_PENDING)
+    dest_callback.Run(result);
+}
+
+void ServiceWorkerStorage::DidInitializeDiskCacheForMigration(
+    bool* is_failed,
+    const base::Closure& barrier_closure,
+    int result) {
+  if (result != net::OK)
+    *is_failed = true;
+  barrier_closure.Run();
+}
+
+void ServiceWorkerStorage::DidPrepareDiskCacheForMigration(
+    scoped_ptr<ServiceWorkerDiskCache> src_disk_cache,
+    scoped_ptr<ServiceWorkerDiskCache> dest_disk_cache,
+    bool* is_failed) {
+  if (*is_failed) {
+    LOG(ERROR) << "Failed to initialize the diskcache.";
+    src_disk_cache.reset();
+    dest_disk_cache.reset();
+    AbortDiskCacheMigration(ServiceWorkerMetrics::MIGRATION_ERROR_INITIALIZE);
+    return;
+  }
+
+  // Start migrating resources stored in the src DiskCache.
+  scoped_ptr<ServiceWorkerDiskCacheMigrator> migrator(
+      new ServiceWorkerDiskCacheMigrator(src_disk_cache.get(),
+                                         dest_disk_cache.get()));
+  ServiceWorkerDiskCacheMigrator* migrator_ptr = migrator.get();
+  migrator_ptr->Start(base::Bind(

[michaeln, 2015/06/08 21:36:33]

The migrator will continue to run even after ServiceWorkerStorage has been
deleted, yet the results of a migrator left running detached from its storage
will never be used. Seems like we should abort the migrator in this case to
avoid it doing a bunch of unwanted io during shutdown.

[nhiroki, 2015/06/09 15:41:56]

I changed the storage to own the migrator. When the storage is destroyed, the
migrator is also destroyed and running/pending migration tasks bound with
weakptr<migrator> are aborted.

+      &ServiceWorkerStorage::DidMigrateDiskCache, weak_factory_.GetWeakPtr(),
+      base::Passed(migrator.Pass()), base::Passed(src_disk_cache.Pass()),
+      base::Passed(dest_disk_cache.Pass())));

[michaeln, 2015/06/08 21:36:33]

having ownership of src and dst bound into the closure works, but having the
migrator own them outright seems easier to grok

[nhiroki, 2015/06/09 15:41:57]

Moved the initialization code from storage to migrator.

+}
+
+void ServiceWorkerStorage::DidMigrateDiskCache(
+    scoped_ptr<ServiceWorkerDiskCacheMigrator> migrator,
+    scoped_ptr<ServiceWorkerDiskCache> src_disk_cache,
+    scoped_ptr<ServiceWorkerDiskCache> dest_disk_cache,
+    ServiceWorkerStatusCode status) {
+  migrator.reset();
+  src_disk_cache.reset();
+  dest_disk_cache.reset();
+
+  if (status != SERVICE_WORKER_OK) {
+    LOG(ERROR) << "Failed to migrate the diskcache: "
+               << ServiceWorkerStatusToString(status);
+    AbortDiskCacheMigration(ServiceWorkerMetrics::MIGRATION_ERROR_FAILED);
+    return;
+  }
+
+  // Delete the old DiskCache directory.
+  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";
+    AbortDiskCacheMigration(

[michaeln, 2015/06/08 21:36:33]

Seems unfortunate to let this error prevent migration completion since the dest
cache is successfully written and ready to go? Likely the call in line 1523 will
also fail to delete the old. Hmmm, if we're unable to delete the old dir we'll
be wedged forever trying to migrate?

[nhiroki, 2015/06/09 15:41:57]

Changed this sequence. The latest patchset records the old diskcache directory
in the database (INITDATA_PURGEABLE_FILE) and tries to delete it independently
from the migration attempt.

+        ServiceWorkerMetrics::MIGRATION_ERROR_DELETE_DISK_CACHE);
+    return;
+  }
+  ServiceWorkerMetrics::RecordDiskCacheMigrationResult(
+      ServiceWorkerMetrics::MIGRATION_OK);
+  InitializeDiskCache();
+}
+
+void ServiceWorkerStorage::AbortDiskCacheMigration(

[michaeln, 2015/06/08 21:36:33]

This method doesn't actually abort anything, it handles a migration failure.
Maybe rename the method?

[nhiroki, 2015/06/09 15:41:57]

(This function is gone)

+    ServiceWorkerMetrics::DiskCacheMigrationResult result) {
+  ServiceWorkerMetrics::RecordDiskCacheMigrationResult(result);
+
+  // Give up initialization and recreate the whole storage.
+  ScheduleDeleteAndStartOver();
+
+  // Delete the old disk directory because DeleteAndStartOver doesn't.
+  disk_cache_thread_->PostTask(FROM_HERE,
+                               base::Bind(base::IgnoreResult(&base::DeleteFile),
+                                          GetOldDiskCachePath(), true));
+}
+
+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 122 matching lines @@
   ids.clear();
   status = database->GetPurgeableResourceIds(&ids);
   original_task_runner->PostTask(
       FROM_HERE,
       base::Bind(callback, std::vector<int64>(ids.begin(), ids.end()), status));
 }
 
 void ServiceWorkerStorage::ReadInitialDataFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+    const base::FilePath& old_disk_cache_path,
     const InitializeCallback& callback) {
   DCHECK(database);
   scoped_ptr<ServiceWorkerStorage::InitialData> data(
       new ServiceWorkerStorage::InitialData());
 
   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));
+        FROM_HERE, base::Bind(callback, base::Owned(data.release()),
+                              false /* needs_disk_cache_migration */, status));
     return;
   }
 
+  bool needs_disk_cache_migration = false;
+  if (!old_disk_cache_path.empty())
+    needs_disk_cache_migration = base::DirectoryExists(old_disk_cache_path);

[michaeln, 2015/06/08 21:36:33]

I'm wondering about pathological cases where migration fails? How do we handle
different failure modes. As coded looks like we could repeatedly try to migrate
during a browsing session. I'm back to wondering if we should store whether
migration has happened or is needed in the db proper to handle unable to delete
the old case? Also wondering if the name of the scriptcache directory should be
part of the db schema to handle being unable to delete partial results from an
earlier migration attempt?

[nhiroki, 2015/06/09 15:41:57]

Added INITDATA_DISKCACHE_VERSION field in the database. We should be able to
distinguish the migration state by the version number.
In the latest CL, if the migrator is still running on the dtor of the storage,
the new diskcache directory which contains partial results is recorded as a
purgeable file in the database. Purgeable files are removed on the next system
startup.

(We might not have to do this if we delete partial results immediately before
the migration as you commented at line 1436?)

+
   status = database->GetOriginsWithRegistrations(&data->origins);
   original_task_runner->PostTask(
-      FROM_HERE, base::Bind(callback, base::Owned(data.release()), status));
+      FROM_HERE, base::Bind(callback, base::Owned(data.release()),
+                            needs_disk_cache_migration, status));
 }
 
 void ServiceWorkerStorage::DeleteRegistrationFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     int64 registration_id,
     const GURL& origin,
     const DeleteRegistrationCallback& callback) {
   DCHECK(database);
 
@@ skipping 246 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