ServiceWorker: Manipulate uncommitted/purgeable resource ids

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 <string>
 
 #include "base/file_util.h"
 #include "base/location.h"
@@ skipping 24 matching lines @@
 //
 //   key: "INITDATA_NEXT_RESOURCE_ID"
 //   value: <int64 'next_available_resource_id'>
 //
 //   key: "INITDATA_NEXT_VERSION_ID"
 //   value: <int64 'next_available_version_id'>
 //
 //   key: "INITDATA_UNIQUE_ORIGIN:" + <GURL 'origin'>
 //   value: <empty>
 //
+//   key: "PRES:" + <int64 'purgeable_resource_id'>
+//   value: <empty>
+//
 //   key: "REG:" + <GURL 'origin'> + '\x00' + <int64 'registration_id'>
 //     (ex. "REG:http://example.com\x00123456")
 //   value: <ServiceWorkerRegistrationData serialized as a string>
+//
+//   key: "URES:" + <int64 'uncommitted_resource_id'>
+//   value: <empty>
 
 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 kRegKeyPrefix[] = "REG:";
 const char kKeySeparator = '\x00';
 
+const char kUncommittedResIdKeyPrefix[] = "URES:";
+const char kPurgeableResIdKeyPrefix[] = "PRES:";
+
 const int64 kCurrentSchemaVersion = 1;
 
 bool RemovePrefix(const std::string& str,
                   const std::string& prefix,
                   std::string* out) {
   if (!StartsWithASCII(str, prefix, true))
     return false;
   if (out)
     *out = str.substr(prefix.size());
   return true;
 }
 
 std::string CreateRegistrationKey(int64 registration_id,
                                   const GURL& origin) {
   return base::StringPrintf("%s%s%c%s",
                             kRegKeyPrefix,
                             origin.spec().c_str(),
                             kKeySeparator,
                             base::Int64ToString(registration_id).c_str());
 }
 
 std::string CreateUniqueOriginKey(const GURL& origin) {
   return base::StringPrintf("%s%s", kUniqueOriginKey, origin.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());
+}
+
 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());
@@ skipping 246 matching lines @@
       registrations[0].registration_id == registration_id) {
     batch.Delete(CreateUniqueOriginKey(origin));
   }
 
   batch.Delete(CreateRegistrationKey(registration_id, origin));
 
   // TODO(nhiroki): Delete ResourceRecords tied with this registration.
   return WriteBatch(&batch);
 }
 
+bool ServiceWorkerDatabase::GetUncommittedResourceIds(std::set<int64>* ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  if (!LazyOpen(false) || is_disabled_)
+    return false;
+  return ReadResourceIds(kUncommittedResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::WriteUncommittedResourceIds(
+    const std::set<int64>& ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  if (!LazyOpen(true) || is_disabled_)
+    return false;
+  return WriteResourceIds(kUncommittedResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::ClearUncommittedResourceIds(
+    const std::set<int64>& ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  if (!LazyOpen(true) || is_disabled_)
+    return false;
+  return DeleteResourceIds(kUncommittedResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::GetPurgeableResourceIds(std::set<int64>* ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  if (!LazyOpen(false) || is_disabled_)
+    return false;
+  return ReadResourceIds(kPurgeableResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::WritePurgeableResourceIds(
+    const std::set<int64>& ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  if (!LazyOpen(true) || is_disabled_)
+    return false;
+  return WriteResourceIds(kPurgeableResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::ClearPurgeableResourceIds(
+    const std::set<int64>& ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  if (!LazyOpen(true) || is_disabled_)

[michaeln, 2014/04/30 03:23:57]

These tests and the dcheck could also be in the common helper methods. Unless
there's a compelling reason not to, more sharing more better.

[nhiroki, 2014/04/30 04:04:06]

That's just my preference. Basically I prefer such checks are located at the
beginning of public functions because sourcecode readers can easily understand
preconditions of following code.

But in this case, sharing code seems to make more maintainable and readable.
Moved those checks into the common helpers.

+    return false;
+  return DeleteResourceIds(kPurgeableResIdKeyPrefix, ids);
+}
+
 bool ServiceWorkerDatabase::LazyOpen(bool create_if_needed) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   if (IsOpen())
     return true;
 
   // Do not try to open a database if we tried and failed once.
   if (is_disabled_)
     return false;
 
   // When |path_| is empty, open a database in-memory.
@@ skipping 81 matching lines @@
   RegistrationData parsed;
   if (!ParseRegistrationData(value, &parsed)) {
     HandleError(FROM_HERE, leveldb::Status::Corruption("failed to parse"));
     return false;
   }
 
   *registration = parsed;
   return true;
 }
 
+bool ServiceWorkerDatabase::ReadResourceIds(const char* id_key_prefix,
+                                            std::set<int64>* ids) {
+  DCHECK(id_key_prefix);
+  DCHECK(ids);
+
+  scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
+  for (itr->Seek(id_key_prefix); itr->Valid(); itr->Next()) {
+    if (!itr->status().ok()) {
+      HandleError(FROM_HERE, itr->status());
+      ids->clear();
+      return false;
+    }
+
+    std::string unprefixed;
+    if (!RemovePrefix(itr->key().ToString(), id_key_prefix, &unprefixed))
+      break;
+
+    int64 resource_id;
+    if (!base::StringToInt64(unprefixed, &resource_id)) {
+      HandleError(FROM_HERE, leveldb::Status::Corruption("failed to parse"));
+      ids->clear();
+      return false;
+    }
+    ids->insert(resource_id);
+  }
+  return true;
+}
+
+bool ServiceWorkerDatabase::WriteResourceIds(const char* id_key_prefix,
+                                             const std::set<int64>& ids) {
+  DCHECK(id_key_prefix);
+  if (ids.empty())
+    return true;
+  leveldb::WriteBatch batch;
+  for (std::set<int64>::const_iterator itr = ids.begin();
+       itr != ids.end(); ++itr) {
+    // Value should be empty.
+    batch.Put(CreateResourceIdKey(id_key_prefix, *itr), "");
+  }
+  return WriteBatch(&batch);
+}
+
+bool ServiceWorkerDatabase::DeleteResourceIds(const char* id_key_prefix,
+                                              const std::set<int64>& ids) {
+  DCHECK(id_key_prefix);
+  if (ids.empty())
+    return true;
+  leveldb::WriteBatch batch;
+  for (std::set<int64>::const_iterator itr = ids.begin();
+       itr != ids.end(); ++itr) {
+    batch.Delete(CreateResourceIdKey(id_key_prefix, *itr));
+  }
+  return WriteBatch(&batch);
+}
+
 bool ServiceWorkerDatabase::ReadDatabaseVersion(int64* db_version) {
   std::string value;
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), kDatabaseVersionKey, &value);
   if (status.IsNotFound()) {
     // The database hasn't been initialized yet.
     *db_version = 0;
     return true;
   }
   if (!status.ok()) {
@@ skipping 63 matching lines @@
   // TODO(nhiroki): Add an UMA histogram.
   DLOG(ERROR) << "Failed at: " << from_here.ToString()
               << " with error: " << status.ToString();
   is_disabled_ = true;
   if (status.IsCorruption())
     was_corruption_detected_ = true;
   db_.reset();
 }
 
 }  // namespace content