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) {
+  return ReadResourceIds(kUncommittedResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::WriteUncommittedResourceIds(
+    const std::set<int64>& ids) {
+  return WriteResourceIds(kUncommittedResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::ClearUncommittedResourceIds(
+    const std::set<int64>& ids) {
+  return DeleteResourceIds(kUncommittedResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::GetPurgeableResourceIds(std::set<int64>* ids) {
+  return ReadResourceIds(kPurgeableResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::WritePurgeableResourceIds(
+    const std::set<int64>& ids) {
+  return WriteResourceIds(kPurgeableResIdKeyPrefix, ids);
+}
+
+bool ServiceWorkerDatabase::ClearPurgeableResourceIds(
+    const std::set<int64>& ids) {
+  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(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(id_key_prefix);
+  DCHECK(ids);
+
+  if (!LazyOpen(false) || is_disabled_)
+    return false;
+
+  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(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(id_key_prefix);
+
+  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(id_key_prefix, *itr), "");
+  }
+  return WriteBatch(&batch);
+}
+
+bool ServiceWorkerDatabase::DeleteResourceIds(const char* id_key_prefix,
+                                              const std::set<int64>& ids) {
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(id_key_prefix);
+
+  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(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