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) {

[michaeln, 2014/04/29 23:50:03]

I think the only difference between the Uncommitted vs Purgeable methods is the
prefix used in each corresponding method body. Is that right? If so it would
make sense to have more generic private [Get|Write|Clear]ResourceIds methods
that take the prefix as a param and do like...

bool GetUncommittedResourceIds(...) {
  return GetResourceIds(kUncommittedPrefix, ...);
}

[nhiroki, 2014/04/30 03:05:58]

That's right. Added Read/Write/DeleteResourceIds() and replaced.

+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(ids);
+
+  if (!LazyOpen(false) || is_disabled_)
+    return false;
+
+  scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
+  for (itr->Seek(kUncommittedResIdKeyPrefix); itr->Valid(); itr->Next()) {
+    if (!itr->status().ok()) {
+      HandleError(FROM_HERE, itr->status());
+      ids->clear();
+      return false;
+    }
+
+    std::string key = itr->key().ToString();
+    std::string unprefixed;
+    if (!RemovePrefix(key, kUncommittedResIdKeyPrefix, &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::WriteUncommittedResourceIds(
+    const std::set<int64>& ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+
+  if (!LazyOpen(true) || is_disabled_)
+    return false;
+  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(kUncommittedResIdKeyPrefix, *itr), "");
+  }
+  return WriteBatch(&batch);
+}
+
+bool ServiceWorkerDatabase::ClearUncommittedResourceIds(
+    const std::set<int64>& ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+
+  if (!LazyOpen(true) || is_disabled_)
+    return false;
+  if (ids.empty())
+    return true;
+
+  leveldb::WriteBatch batch;
+  for (std::set<int64>::const_iterator itr = ids.begin();
+       itr != ids.end(); ++itr) {
+    batch.Delete(CreateResourceIdKey(kUncommittedResIdKeyPrefix, *itr));
+  }
+  return WriteBatch(&batch);
+}
+
+bool ServiceWorkerDatabase::GetPurgeableResourceIds(std::set<int64>* ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(ids);
+
+  if (!LazyOpen(false) || is_disabled_)
+    return false;
+
+  scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
+  for (itr->Seek(kPurgeableResIdKeyPrefix); itr->Valid(); itr->Next()) {
+    if (!itr->status().ok()) {
+      HandleError(FROM_HERE, itr->status());
+      ids->clear();
+      return false;
+    }
+
+    std::string key = itr->key().ToString();
+    std::string unprefixed;
+    if (!RemovePrefix(key, kPurgeableResIdKeyPrefix, &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::WritePurgeableResourceIds(
+    const std::set<int64>& ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+
+  if (!LazyOpen(true) || is_disabled_)
+    return false;
+  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(kPurgeableResIdKeyPrefix, *itr), "");
+  }
+  return WriteBatch(&batch);
+}
+
+bool ServiceWorkerDatabase::ClearPurgeableResourceIds(
+    const std::set<int64>& ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+
+  if (!LazyOpen(true) || is_disabled_)
+    return false;
+  if (ids.empty())
+    return true;
+
+  leveldb::WriteBatch batch;
+  for (std::set<int64>::const_iterator itr = ids.begin();
+       itr != ids.end(); ++itr) {
+    batch.Delete(CreateResourceIdKey(kPurgeableResIdKeyPrefix, *itr));
+  }
+  return WriteBatch(&batch);
+}
+
 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 164 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