Service Worker: Migrate to version_uuid and surface ServiceWorker.id. (Chromium 2/3)

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"
 
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 65 matching lines @@
 //
 //   key: "INITDATA_DISKCACHE_MIGRATION_NOT_NEEDED"
 //   value: <empty>
 //     - This entry represents that the diskcache uses the Simple backend and
 //       does not have to do diskcache migration (http://crbug.com/487482).
 //
 //   key: "INITDATA_OLD_DISKCACHE_DELETION_NOT_NEEDED"
 //   value: <empty>
 //     - This entry represents that the old BlockFile diskcache was deleted
 //       after diskcache migration (http://crbug.com/487482).
+//
+// Version 3
+//
+//   Deprecate
+//   key: "INITDATA_NEXT_VERSION_ID"
+//   value: <int64 'next_available_version_id'>
+//
+//   Data type change
+//   key: "RES:" + <std::string 'version_uuid'> + '\x00' + <int64 'resource_id'>
+//     (ex. "RES:123456\x00654321")
+//   value: <ServiceWorkerResourceRecord serialized as a string>
 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 kDiskCacheMigrationNotNeededKey[] =
     "INITDATA_DISKCACHE_MIGRATION_NOT_NEEDED";
 const char kOldDiskCacheDeletionNotNeededKey[] =
     "INITDATA_OLD_DISKCACHE_DELETION_NOT_NEEDED";
 
 const char kRegKeyPrefix[] = "REG:";
 const char kRegUserDataKeyPrefix[] = "REG_USER_DATA:";
 const char kRegHasUserDataKeyPrefix[] = "REG_HAS_USER_DATA:";
 const char kRegIdToOriginKeyPrefix[] = "REGID_TO_ORIGIN:";
@@ skipping 29 matching lines @@
   return base::StringPrintf("%s%s%c", kRegKeyPrefix,
                             origin.GetOrigin().spec().c_str(), kKeySeparator);
 }
 
 std::string CreateRegistrationKey(int64 registration_id,
                                   const GURL& origin) {
   return CreateRegistrationKeyPrefix(origin)
       .append(base::Int64ToString(registration_id));
 }
 
-std::string CreateResourceRecordKeyPrefix(int64 version_id) {
-  return base::StringPrintf("%s%s%c",
-                            kResKeyPrefix,
-                            base::Int64ToString(version_id).c_str(),
+std::string CreateResourceRecordKeyPrefix(std::string version_uuid) {
+  return base::StringPrintf("%s%s%c", kResKeyPrefix, version_uuid.c_str(),
                             kKeySeparator);
 }
 
-std::string CreateResourceRecordKey(int64 version_id,
+std::string CreateResourceRecordKey(std::string version_uuid,
                                     int64 resource_id) {
-  return CreateResourceRecordKeyPrefix(version_id).append(
-      base::Int64ToString(resource_id));
+  return CreateResourceRecordKeyPrefix(version_uuid)
+      .append(base::Int64ToString(resource_id));
 }
 
 std::string CreateUniqueOriginKey(const GURL& origin) {
   return base::StringPrintf("%s%s", kUniqueOriginKey,
                             origin.GetOrigin().spec().c_str());
 }
 
 std::string CreateResourceIdKey(const char* key_prefix, int64 resource_id) {
   return base::StringPrintf(
       "%s%s", key_prefix, base::Int64ToString(resource_id).c_str());
@@ skipping 30 matching lines @@
 void PutRegistrationDataToBatch(
     const ServiceWorkerDatabase::RegistrationData& input,
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
 
   // Convert RegistrationData to ServiceWorkerRegistrationData.
   ServiceWorkerRegistrationData data;
   data.set_registration_id(input.registration_id);
   data.set_scope_url(input.scope.spec());
   data.set_script_url(input.script.spec());
-  data.set_version_id(input.version_id);
+  data.set_version_uuid(input.version_uuid);
   data.set_is_active(input.is_active);
   data.set_has_fetch_handler(input.has_fetch_handler);
   data.set_last_update_check_time(input.last_update_check.ToInternalValue());
   data.set_resources_total_size_bytes(input.resources_total_size_bytes);
 
   std::string value;
   bool success = data.SerializeToString(&value);
   DCHECK(success);
   GURL origin = input.scope.GetOrigin();
   batch->Put(CreateRegistrationKey(data.registration_id(), origin), value);
 }
 
 void PutResourceRecordToBatch(
     const ServiceWorkerDatabase::ResourceRecord& input,
-    int64 version_id,
+    std::string version_uuid,
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
   DCHECK_GE(input.size_bytes, 0);
 
   // Convert ResourceRecord to ServiceWorkerResourceRecord.
   ServiceWorkerResourceRecord record;
   record.set_resource_id(input.resource_id);
   record.set_url(input.url.spec());
   record.set_size_bytes(input.size_bytes);
 
   std::string value;
   bool success = record.SerializeToString(&value);
   DCHECK(success);
-  batch->Put(CreateResourceRecordKey(version_id, input.resource_id), value);
+  batch->Put(CreateResourceRecordKey(version_uuid, input.resource_id), value);
 }
 
 void PutUniqueOriginToBatch(const GURL& origin,
                             leveldb::WriteBatch* batch) {
   // Value should be empty.
   batch->Put(CreateUniqueOriginKey(origin), "");
 }
 
 void PutPurgeableResourceIdToBatch(int64 resource_id,
                                    leveldb::WriteBatch* batch) {
@@ skipping 48 matching lines @@
     DLOG(ERROR) << "Scope URL '" << data.scope_url() << "' and/or script url '"
                 << data.script_url()
                 << "' are invalid or have mismatching origins.";
     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
   }
 
   // Convert ServiceWorkerRegistrationData to RegistrationData.
   out->registration_id = data.registration_id();
   out->scope = scope_url;
   out->script = script_url;
-  out->version_id = data.version_id();
+  out->version_uuid = data.version_uuid();
   out->is_active = data.is_active();
   out->has_fetch_handler = data.has_fetch_handler();
   out->last_update_check =
       base::Time::FromInternalValue(data.last_update_check_time());
   out->resources_total_size_bytes = data.resources_total_size_bytes();
 
   return ServiceWorkerDatabase::STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status ParseResourceRecord(
@@ skipping 55 matching lines @@
     case ServiceWorkerDatabase::STATUS_ERROR_MAX:
       NOTREACHED();
       return "Database unknown error";
   }
   NOTREACHED();
   return "Database unknown error";
 }
 
 ServiceWorkerDatabase::RegistrationData::RegistrationData()
     : registration_id(kInvalidServiceWorkerRegistrationId),
-      version_id(kInvalidServiceWorkerVersionId),
+      version_uuid(std::string()),
       is_active(false),
       has_fetch_handler(false),
       resources_total_size_bytes(0) {
 }
 
 ServiceWorkerDatabase::RegistrationData::~RegistrationData() {
 }
 
 ServiceWorkerDatabase::ServiceWorkerDatabase(const base::FilePath& path)
     : path_(path),
       next_avail_registration_id_(0),
       next_avail_resource_id_(0),
-      next_avail_version_id_(0),
       state_(UNINITIALIZED),
       skip_writing_diskcache_migration_state_on_init_for_testing_(false) {
   sequence_checker_.DetachFromSequence();
 }
 
 ServiceWorkerDatabase::~ServiceWorkerDatabase() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   db_.reset();
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetNextAvailableIds(
     int64* next_avail_registration_id,
-    int64* next_avail_version_id,
     int64* next_avail_resource_id) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(next_avail_registration_id);
-  DCHECK(next_avail_version_id);
   DCHECK(next_avail_resource_id);
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status)) {
     *next_avail_registration_id = 0;
-    *next_avail_version_id = 0;
     *next_avail_resource_id = 0;
     return STATUS_OK;
   }
   if (status != STATUS_OK)
     return status;
 
   status = ReadNextAvailableId(kNextRegIdKey, &next_avail_registration_id_);
   if (status != STATUS_OK)
     return status;
-  status = ReadNextAvailableId(kNextVerIdKey, &next_avail_version_id_);
-  if (status != STATUS_OK)
-    return status;
   status = ReadNextAvailableId(kNextResIdKey, &next_avail_resource_id_);
   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::IsDiskCacheMigrationNeeded(
     bool* migration_needed) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status)) {
@@ skipping 150 matching lines @@
       HandleReadResult(FROM_HERE, status);
       registrations->clear();
       if (opt_resources_list)
         opt_resources_list->clear();
       return status;
     }
     registrations->push_back(registration);
 
     if (opt_resources_list) {
       std::vector<ResourceRecord> resources;
-      status = ReadResourceRecords(registration.version_id, &resources);
+      status = ReadResourceRecords(registration.version_uuid, &resources);
       if (status != STATUS_OK) {
         HandleReadResult(FROM_HERE, status);
         registrations->clear();
         opt_resources_list->clear();
         return status;
       }
       opt_resources_list->push_back(resources);
     }
   }
 
@@ skipping 51 matching lines @@
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
 
   RegistrationData value;
   status = ReadRegistrationData(registration_id, origin, &value);
   if (status != STATUS_OK)
     return status;
 
-  status = ReadResourceRecords(value.version_id, resources);
+  status = ReadResourceRecords(value.version_uuid, resources);
   if (status != STATUS_OK)
     return status;
 
   // ResourceRecord must contain the ServiceWorker's main script.
   if (resources->empty())
     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 
   *registration = value;
   return STATUS_OK;
 }
@@ skipping 34 matching lines @@
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteRegistration(
     const RegistrationData& registration,
     const std::vector<ResourceRecord>& resources,
     RegistrationData* old_registration,
     std::vector<int64>* newly_purgeable_resources) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(old_registration);
   DCHECK(!resources.empty());
   Status status = LazyOpen(true);
-  old_registration->version_id = kInvalidServiceWorkerVersionId;
+  old_registration->version_uuid = std::string();
   if (status != STATUS_OK)
     return status;
 
   leveldb::WriteBatch batch;
   BumpNextRegistrationIdIfNeeded(registration.registration_id, &batch);
-  BumpNextVersionIdIfNeeded(registration.version_id, &batch);
+  // BumpNextVersionIdIfNeeded(registration.version_uuid, &batch);
 
   PutUniqueOriginToBatch(registration.scope.GetOrigin(), &batch);
 
   DCHECK_EQ(AccumulateResourceSizeInBytes(resources),
             registration.resources_total_size_bytes)
       << "The total size in the registration must match the cumulative "
       << "sizes of the resources.";
 
   PutRegistrationDataToBatch(registration, &batch);
   batch.Put(CreateRegistrationIdToOriginKey(registration.registration_id),
             registration.scope.GetOrigin().spec());
 
   // Used for avoiding multiple writes for the same resource id or url.
   std::set<int64> pushed_resources;
   std::set<GURL> pushed_urls;
   for (std::vector<ResourceRecord>::const_iterator itr = resources.begin();
        itr != resources.end(); ++itr) {
     if (!itr->url.is_valid())
       return STATUS_ERROR_FAILED;
 
     // Duplicated resource id or url should not exist.
     DCHECK(pushed_resources.insert(itr->resource_id).second);
     DCHECK(pushed_urls.insert(itr->url).second);
 
-    PutResourceRecordToBatch(*itr, registration.version_id, &batch);
+    PutResourceRecordToBatch(*itr, registration.version_uuid, &batch);
 
     // Delete a resource from the uncommitted list.
     batch.Delete(CreateResourceIdKey(
         kUncommittedResIdKeyPrefix, itr->resource_id));
     // Delete from the purgeable list in case this version was once deleted.
     batch.Delete(
         CreateResourceIdKey(kPurgeableResIdKeyPrefix, itr->resource_id));
   }
 
   // Retrieve a previous version to sweep purgeable resources.
   status = ReadRegistrationData(registration.registration_id,
                                 registration.scope.GetOrigin(),
                                 old_registration);
   if (status != STATUS_OK && status != STATUS_ERROR_NOT_FOUND)
     return status;
   if (status == STATUS_OK) {
-    DCHECK_LT(old_registration->version_id, registration.version_id);
-    status = DeleteResourceRecords(
-        old_registration->version_id, newly_purgeable_resources, &batch);
+    DCHECK_NE(old_registration->version_uuid, registration.version_uuid);
+    status = DeleteResourceRecords(old_registration->version_uuid,
+                                   newly_purgeable_resources, &batch);
     if (status != STATUS_OK)
       return status;
 
     // Currently resource sharing across versions and registrations is not
     // supported, so resource ids should not be overlapped between
     // |registration| and |old_registration|.
     std::set<int64> deleted_resources(newly_purgeable_resources->begin(),
                                       newly_purgeable_resources->end());
     DCHECK(base::STLSetIntersection<std::set<int64> >(
         pushed_resources, deleted_resources).empty());
@@ skipping 51 matching lines @@
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteRegistration(
     int64 registration_id,
     const GURL& origin,
     RegistrationData* deleted_version,
     std::vector<int64>* newly_purgeable_resources) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(deleted_version);
-  deleted_version->version_id = kInvalidServiceWorkerVersionId;
+  deleted_version->version_uuid = std::string();
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
   if (!origin.is_valid())
     return STATUS_ERROR_FAILED;
 
   leveldb::WriteBatch batch;
 
@@ skipping 11 matching lines @@
   }
 
   // Delete a registration specified by |registration_id|.
   batch.Delete(CreateRegistrationKey(registration_id, origin));
   batch.Delete(CreateRegistrationIdToOriginKey(registration_id));
 
   // Delete resource records and user data associated with the registration.
   for (const auto& registration : registrations) {
     if (registration.registration_id == registration_id) {
       *deleted_version = registration;
-      status = DeleteResourceRecords(
-          registration.version_id, newly_purgeable_resources, &batch);
+      status = DeleteResourceRecords(registration.version_uuid,
+                                     newly_purgeable_resources, &batch);
       if (status != STATUS_OK)
         return status;
 
       status = DeleteUserDataForRegistration(registration_id, &batch);
       if (status != STATUS_OK)
         return status;
       break;
     }
   }
 
@@ skipping 187 matching lines @@
     std::vector<RegistrationData> registrations;
     status = GetRegistrationsForOrigin(origin, &registrations, nullptr);
     if (status != STATUS_OK)
       return status;
 
     // Delete registrations, resource records and user data.
     for (const RegistrationData& data : registrations) {
       batch.Delete(CreateRegistrationKey(data.registration_id, origin));
       batch.Delete(CreateRegistrationIdToOriginKey(data.registration_id));
 
-      status = DeleteResourceRecords(
-          data.version_id, newly_purgeable_resources, &batch);
+      status = DeleteResourceRecords(data.version_uuid,
+                                     newly_purgeable_resources, &batch);
       if (status != STATUS_OK)
         return status;
 
       status = DeleteUserDataForRegistration(data.registration_id, &batch);
       if (status != STATUS_OK)
         return status;
     }
   }
 
   return WriteBatch(&batch);
@@ skipping 176 matching lines @@
         status == STATUS_ERROR_NOT_FOUND ? STATUS_OK : status);
     return status;
   }
 
   status = ParseRegistrationData(value, registration);
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadResourceRecords(
-    int64 version_id,
+    std::string version_uuid,
     std::vector<ResourceRecord>* resources) {
   DCHECK(resources->empty());
 
   Status status = STATUS_OK;
-  const std::string prefix = CreateResourceRecordKeyPrefix(version_id);
+  const std::string prefix = CreateResourceRecordKeyPrefix(version_uuid);
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
     Status status = LevelDBStatusToStatus(itr->status());
     if (status != STATUS_OK) {
       HandleReadResult(FROM_HERE, status);
       resources->clear();
       return status;
     }
 
     if (!RemovePrefix(itr->key().ToString(), prefix, NULL))
       break;
 
     ResourceRecord resource;
     status = ParseResourceRecord(itr->value().ToString(), &resource);
     if (status != STATUS_OK) {
       HandleReadResult(FROM_HERE, status);
       resources->clear();
       return status;
     }
     resources->push_back(resource);
   }
 
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteResourceRecords(
-    int64 version_id,
+    std::string version_uuid,
     std::vector<int64>* newly_purgeable_resources,
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
 
   Status status = STATUS_OK;
-  const std::string prefix = CreateResourceRecordKeyPrefix(version_id);
+  const std::string prefix = CreateResourceRecordKeyPrefix(version_uuid);
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
     status = LevelDBStatusToStatus(itr->status());
     if (status != STATUS_OK) {
       HandleReadResult(FROM_HERE, status);
       return status;
     }
 
     const std::string key = itr->key().ToString();
@@ skipping 202 matching lines @@
 
 void ServiceWorkerDatabase::BumpNextResourceIdIfNeeded(
     int64 used_id, leveldb::WriteBatch* batch) {
   DCHECK(batch);
   if (next_avail_resource_id_ <= used_id) {
     next_avail_resource_id_ = used_id + 1;
     batch->Put(kNextResIdKey, base::Int64ToString(next_avail_resource_id_));
   }
 }
 
-void ServiceWorkerDatabase::BumpNextVersionIdIfNeeded(
-    int64 used_id, leveldb::WriteBatch* batch) {
-  DCHECK(batch);
-  if (next_avail_version_id_ <= used_id) {
-    next_avail_version_id_ = used_id + 1;
-    batch->Put(kNextVerIdKey, base::Int64ToString(next_avail_version_id_));
-  }
-}
-
 bool ServiceWorkerDatabase::IsOpen() {
   return db_ != NULL;
 }
 
 void ServiceWorkerDatabase::Disable(
     const tracked_objects::Location& from_here,
     Status status) {
   if (status != STATUS_OK) {
     DLOG(ERROR) << "Failed at: " << from_here.ToString()
                 << " with error: " << StatusToString(status);
@@ skipping 25 matching lines @@
   if (status != STATUS_OK)
     Disable(from_here, status);
   ServiceWorkerMetrics::CountWriteDatabaseResult(status);
 }
 
 bool ServiceWorkerDatabase::IsDatabaseInMemory() const {
   return path_.empty();
 }
 
 }  // namespace content