ServiceWorker: Migrate the script cache backend from BlockFile to Simple

content/browser/service_worker/service_worker_database.cc

 // Copyright 2014 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_database.h"

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

In current sources, when chrome is run for the first time, storage
initialization doesn't create a database on disk. I'd think we can keep it that
way. When run for the first time, here really is nothing to migrate.

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

Acknowledged.

 
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 50 matching lines @@
 //     (ex. "RES:123456\x00654321")
 //   value: <ServiceWorkerResourceRecord serialized as a string>
 //
 //   key: "URES:" + <int64 'uncommitted_resource_id'>
 //   value: <empty>
 //
 // Version 2
 //
 //   key: "REGID_TO_ORIGIN:" + <int64 'registration_id'>
 //   value: <GURL 'origin'>
+//
+//   key: "INITDATA_DISKCACHE_MIGRATED"
+//   value: <empty>
+//     - This entry represents that the diskcache was migrated from BlockFile
+//       backend to Simple backend (http://crbug.com/487482).
+//
+//   key: "INITDATA_OLD_DISKCACHE_EXISTS"
+//   value: <empty>
+//     - This entry represents that the diskcahes was migrate, but the old
+//       BlockFile diskcache still exists (http://crbug.com/487482).
 namespace content {
 
 namespace {
 
 const char kDatabaseVersionKey[] = "INITDATA_DB_VERSION";
 const char kNextRegIdKey[] = "INITDATA_NEXT_REGISTRATION_ID";
 const char kNextResIdKey[] = "INITDATA_NEXT_RESOURCE_ID";
 const char kNextVerIdKey[] = "INITDATA_NEXT_VERSION_ID";
 const char kUniqueOriginKey[] = "INITDATA_UNIQUE_ORIGIN:";
+const char kDiskCacheMigratedKey[] = "INITDATA_DISKCACHE_MIGRATED";

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

kDiskCacheMigrationNotNeededKey = "INITDATA_DISKCACHE_MIGRATION_NOT_NEEDED";

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

Done.

+const char kOldDiskCacheExistsKey[] = "INITDATA_OLD_DISKCACHE_EXISTS";

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

INITDATA_OLD_DISKCACHE_DELETION_NOT_NEEDED

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

Done.

 
 const char kRegKeyPrefix[] = "REG:";
 const char kRegUserDataKeyPrefix[] = "REG_USER_DATA:";
 const char kRegHasUserDataKeyPrefix[] = "REG_HAS_USER_DATA:";
 const char kRegIdToOriginKeyPrefix[] = "REGID_TO_ORIGIN:";
 const char kResKeyPrefix[] = "RES:";
 const char kKeySeparator = '\x00';
+const char kEmptyValue[] = "";
 
 const char kUncommittedResIdKeyPrefix[] = "URES:";
 const char kPurgeableResIdKeyPrefix[] = "PRES:";
 
 const int64 kCurrentSchemaVersion = 2;
 
 class ServiceWorkerEnv : public leveldb_env::ChromiumEnv {
  public:
   ServiceWorkerEnv()
       : ChromiumEnv("LevelDBEnv.ServiceWorker", false /* make_backup */) {}
@@ skipping 310 matching lines @@
   if (status != STATUS_OK)
     return status;
 
   *next_avail_registration_id = next_avail_registration_id_;
   *next_avail_version_id = next_avail_version_id_;
   *next_avail_resource_id = next_avail_resource_id_;
   return STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::ReadDiskCacheMigrationState(

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

The simple ReadX and WriteX names are misleading. These functions do more than
blindly read/write the provided value to the db. There are two different values
in the db that map to 4 different states. I'm finding it difficult to reason
about and wonder if a dumbed down db layer would help?

What if...

   db->IsDiskCacheMigrationNeeded() return true or false
   db->IsOldDiskCacheDeletionNeeded() returns true or false

I think these two bits are what the higher level storage class really needs to
know.

Lets say for a non-existent or brand new database, these values default to.

false for migrationNeeded
false for oldDeletetionNeeded

For an existing database with no record of these inside (no keys present)

true for migrationNeeded
true for oldDeletionNeeded

When migration is done

  dbresult = db->SetDiskCacheMigrationNotNeeded() 
     puts kMigrationNotNeeded key

and when old directory deletion is done

  dbresult = db->SetOldDiskCacheDeletionNotNeeded()
     puts kDiskCacheDeletionNotNeeded key


The Is getters use LazyOpen(false) and the Setters use LazyOpen(true).

I like having all the app logic smarts in the Storage class and the DB class's
job is to safely put and get values that need to be persisted.

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

Thank you for the detailed explanation. This looks much simpler! I updated the
CL in this way.

+    DiskCacheMigrationState* state) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+
+  Status status = LazyOpen(false);
+  if (IsNewOrNonexistentDatabase(status)) {
+    *state = DISKCACHE_NOT_USED;
+    return STATUS_OK;
+  }
+  if (status != STATUS_OK)
+    return status;
+
+  std::string value;
+  status = LevelDBStatusToStatus(
+      db_->Get(leveldb::ReadOptions(), kDiskCacheMigratedKey, &value));
+  if (status != STATUS_ERROR_NOT_FOUND) {
+    if (status == STATUS_OK)
+      *state = DISKCACHE_MIGRATED;
+    HandleReadResult(FROM_HERE, status);
+    return status;
+  }
+  HandleReadResult(FROM_HERE, STATUS_OK);
+
+  status = LevelDBStatusToStatus(
+      db_->Get(leveldb::ReadOptions(), kOldDiskCacheExistsKey, &value));
+  if (status != STATUS_ERROR_NOT_FOUND) {
+    if (status == STATUS_OK)
+      *state = DISKCACHE_NEEDS_TO_DELETE_OLD;
+    HandleReadResult(FROM_HERE, status);
+    return status;
+  }
+
+  *state = DISKCACHE_NEEDS_TO_MIGRATE;
+  HandleReadResult(FROM_HERE, STATUS_OK);
+  return STATUS_OK;
+}
+
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::WriteDiskCacheMigrationState(
+    DiskCacheMigrationState state) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(state == DISKCACHE_MIGRATED || state == DISKCACHE_NEEDS_TO_DELETE_OLD)
+      << state;
+
+  Status status = LazyOpen(true);
+  if (status != STATUS_OK)
+    return status;
+
+  leveldb::WriteBatch batch;
+  if (state == DISKCACHE_MIGRATED) {
+    batch.Put(kDiskCacheMigratedKey, kEmptyValue);
+    batch.Delete(kOldDiskCacheExistsKey);
+  } else if (state == DISKCACHE_NEEDS_TO_DELETE_OLD) {
+    batch.Put(kOldDiskCacheExistsKey, kEmptyValue);
+  }
+  return WriteBatch(&batch);
+}
+
+ServiceWorkerDatabase::Status
 ServiceWorkerDatabase::GetOriginsWithRegistrations(std::set<GURL>* origins) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(origins->empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
@@ skipping 988 matching lines @@
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteBatch(
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
   DCHECK_NE(DISABLED, state_);
 
   if (state_ == UNINITIALIZED) {
     // Write the database schema version.
     batch->Put(kDatabaseVersionKey, base::Int64ToString(kCurrentSchemaVersion));
     state_ = INITIALIZED;

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

we're initializing a brand new db, put the default values just like we put the
db version number in

batch->Put(kDiskCacheMigrationNotNeededKey);
batch->Put(kOldDiskCacheDeletionNotNeededKey);

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

Ah..., yes. This is the most suitable place to set these default values (and I
should have noticed... hmm)

   }
 
   Status status = LevelDBStatusToStatus(
       db_->Write(leveldb::WriteOptions(), batch));
   HandleWriteResult(FROM_HERE, status);
   return status;
 }
 
 void ServiceWorkerDatabase::BumpNextRegistrationIdIfNeeded(
     int64 used_id, leveldb::WriteBatch* batch) {
@@ skipping 56 matching lines @@
 
 void ServiceWorkerDatabase::HandleWriteResult(
     const tracked_objects::Location& from_here,
     Status status) {
   if (status != STATUS_OK)
     Disable(from_here, status);
   ServiceWorkerMetrics::CountWriteDatabaseResult(status);
 }
 
 }  // namespace content