service worker: Add a namespace in service_worker_database.cc for Jumbo

This is a follow up to https://chromium-review.googlesource.com/c/chromium/src/+/758869,
which added "ServiceWorker" to some of the constants. That approach seems misleading
since it looks like "ServiceWorkerKey" is a type of key on the same level as a "RegKey"
or "ResKey". Really we want to add "ServiceWorker" to all the constants, which we
can accomplish by making a namespace.

Bug: 746953
Change-Id: I61dffdaecffbeb088906f67907fdc47f0f81a5e1
Reviewed-on: https://chromium-review.googlesource.com/765556Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Commit-Queue: Matt Falkenhagen <falken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#515920}

content/browser/service_worker/service_worker_database.cc

@@ -94,7 +94,7 @@
 //   value: <empty>
 namespace content {
 
-namespace {
+namespace service_worker_internals {
 
 const char kDatabaseVersionKey[] = "INITDATA_DB_VERSION";
 const char kNextRegIdKey[] = "INITDATA_NEXT_REGISTRATION_ID";
@@ -108,12 +108,16 @@ 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 kServiceWorkerKeySeparator = '\x00';
+const char kKeySeparator = '\x00';
 
 const char kUncommittedResIdKeyPrefix[] = "URES:";
 const char kPurgeableResIdKeyPrefix[] = "PRES:";
 
-const int64_t kCurrentServiceWorkerSchemaVersion = 2;
+const int64_t kCurrentSchemaVersion = 2;
+
+}  // namespace service_worker_internals
+
+namespace {
 
 class ServiceWorkerEnv : public leveldb_env::ChromiumEnv {
  public:
@@ -134,9 +138,9 @@ bool RemovePrefix(const std::string& str,
 }
 
 std::string CreateRegistrationKeyPrefix(const GURL& origin) {
-  return base::StringPrintf("%s%s%c", kRegKeyPrefix,
+  return base::StringPrintf("%s%s%c", service_worker_internals::kRegKeyPrefix,
                             origin.GetOrigin().spec().c_str(),
-                            kServiceWorkerKeySeparator);
+                            service_worker_internals::kKeySeparator);
 }
 
 std::string CreateRegistrationKey(int64_t registration_id, const GURL& origin) {
@@ -145,9 +149,9 @@ std::string CreateRegistrationKey(int64_t registration_id, const GURL& origin) {
 }
 
 std::string CreateResourceRecordKeyPrefix(int64_t version_id) {
-  return base::StringPrintf("%s%s%c", kResKeyPrefix,
+  return base::StringPrintf("%s%s%c", service_worker_internals::kResKeyPrefix,
                             base::Int64ToString(version_id).c_str(),
-                            kServiceWorkerKeySeparator);
+                            service_worker_internals::kKeySeparator);
 }
 
 std::string CreateResourceRecordKey(int64_t version_id, int64_t resource_id) {
@@ -156,12 +160,13 @@ std::string CreateResourceRecordKey(int64_t version_id, int64_t resource_id) {
 }
 
 std::string CreateUniqueOriginKey(const GURL& origin) {
-  return base::StringPrintf("%s%s", kUniqueOriginKey,
+  return base::StringPrintf("%s%s", service_worker_internals::kUniqueOriginKey,
                             origin.GetOrigin().spec().c_str());
 }
 
 std::string CreateForeignFetchOriginKey(const GURL& origin) {
-  return base::StringPrintf("%s%s", kForeignFetchOriginKey,
+  return base::StringPrintf("%s%s",
+                            service_worker_internals::kForeignFetchOriginKey,
                             origin.GetOrigin().spec().c_str());
 }
 
@@ -171,9 +176,10 @@ std::string CreateResourceIdKey(const char* key_prefix, int64_t resource_id) {
 }
 
 std::string CreateUserDataKeyPrefix(int64_t registration_id) {
-  return base::StringPrintf("%s%s%c", kRegUserDataKeyPrefix,
+  return base::StringPrintf("%s%s%c",
+                            service_worker_internals::kRegUserDataKeyPrefix,
                             base::Int64ToString(registration_id).c_str(),
-                            kServiceWorkerKeySeparator);
+                            service_worker_internals::kKeySeparator);
 }
 
 std::string CreateUserDataKey(int64_t registration_id,
@@ -182,8 +188,9 @@ std::string CreateUserDataKey(int64_t registration_id,
 }
 
 std::string CreateHasUserDataKeyPrefix(const std::string& user_data_name) {
-  return base::StringPrintf("%s%s%c", kRegHasUserDataKeyPrefix,
-                            user_data_name.c_str(), kServiceWorkerKeySeparator);
+  return base::StringPrintf(
+      "%s%s%c", service_worker_internals::kRegHasUserDataKeyPrefix,
+      user_data_name.c_str(), service_worker_internals::kKeySeparator);
 }
 
 std::string CreateHasUserDataKey(int64_t registration_id,
@@ -193,7 +200,8 @@ std::string CreateHasUserDataKey(int64_t registration_id,
 }
 
 std::string CreateRegistrationIdToOriginKey(int64_t registration_id) {
-  return base::StringPrintf("%s%s", kRegIdToOriginKeyPrefix,
+  return base::StringPrintf("%s%s",
+                            service_worker_internals::kRegIdToOriginKeyPrefix,
                             base::Int64ToString(registration_id).c_str());
 }
 
@@ -206,7 +214,10 @@ void PutUniqueOriginToBatch(const GURL& origin,
 void PutPurgeableResourceIdToBatch(int64_t resource_id,
                                    leveldb::WriteBatch* batch) {
   // Value should be empty.
-  batch->Put(CreateResourceIdKey(kPurgeableResIdKeyPrefix, resource_id), "");
+  batch->Put(
+      CreateResourceIdKey(service_worker_internals::kPurgeableResIdKeyPrefix,
+                          resource_id),
+      "");
 }
 
 void PutForeignFetchOriginToBatch(const GURL& origin,
@@ -320,13 +331,16 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetNextAvailableIds(
   if (status != STATUS_OK)
     return status;
 
-  status = ReadNextAvailableId(kNextRegIdKey, &next_avail_registration_id_);
+  status = ReadNextAvailableId(service_worker_internals::kNextRegIdKey,
+                               &next_avail_registration_id_);
   if (status != STATUS_OK)
     return status;
-  status = ReadNextAvailableId(kNextVerIdKey, &next_avail_version_id_);
+  status = ReadNextAvailableId(service_worker_internals::kNextVerIdKey,
+                               &next_avail_version_id_);
   if (status != STATUS_OK)
     return status;
-  status = ReadNextAvailableId(kNextResIdKey, &next_avail_resource_id_);
+  status = ReadNextAvailableId(service_worker_internals::kNextResIdKey,
+                               &next_avail_resource_id_);
   if (status != STATUS_OK)
     return status;
 
@@ -350,7 +364,8 @@ ServiceWorkerDatabase::GetOriginsWithRegistrations(std::set<GURL>* origins) {
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
-    for (itr->Seek(kUniqueOriginKey); itr->Valid(); itr->Next()) {
+    for (itr->Seek(service_worker_internals::kUniqueOriginKey); itr->Valid();
+         itr->Next()) {
       status = LevelDBStatusToStatus(itr->status());
       if (status != STATUS_OK) {
         origins->clear();
@@ -358,7 +373,9 @@ ServiceWorkerDatabase::GetOriginsWithRegistrations(std::set<GURL>* origins) {
       }
 
       std::string origin_str;
-      if (!RemovePrefix(itr->key().ToString(), kUniqueOriginKey, &origin_str))
+      if (!RemovePrefix(itr->key().ToString(),
+                        service_worker_internals::kUniqueOriginKey,
+                        &origin_str))
         break;
 
       GURL origin(origin_str);
@@ -391,7 +408,8 @@ ServiceWorkerDatabase::GetOriginsWithForeignFetchRegistrations(
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
-    for (itr->Seek(kForeignFetchOriginKey); itr->Valid(); itr->Next()) {
+    for (itr->Seek(service_worker_internals::kForeignFetchOriginKey);
+         itr->Valid(); itr->Next()) {
       status = LevelDBStatusToStatus(itr->status());
       if (status != STATUS_OK) {
         origins->clear();
@@ -399,7 +417,8 @@ ServiceWorkerDatabase::GetOriginsWithForeignFetchRegistrations(
       }
 
       std::string origin_str;
-      if (!RemovePrefix(itr->key().ToString(), kForeignFetchOriginKey,
+      if (!RemovePrefix(itr->key().ToString(),
+                        service_worker_internals::kForeignFetchOriginKey,
                         &origin_str))
         break;
 
@@ -488,14 +507,16 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetAllRegistrations(
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
-    for (itr->Seek(kRegKeyPrefix); itr->Valid(); itr->Next()) {
+    for (itr->Seek(service_worker_internals::kRegKeyPrefix); itr->Valid();
+         itr->Next()) {
       status = LevelDBStatusToStatus(itr->status());
       if (status != STATUS_OK) {
         registrations->clear();
         break;
       }
 
-      if (!RemovePrefix(itr->key().ToString(), kRegKeyPrefix, nullptr))
+      if (!RemovePrefix(itr->key().ToString(),
+                        service_worker_internals::kRegKeyPrefix, nullptr))
         break;
 
       RegistrationData registration;
@@ -625,10 +646,11 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteRegistration(
 
     // Delete a resource from the uncommitted list.
     batch.Delete(CreateResourceIdKey(
-        kUncommittedResIdKeyPrefix, itr->resource_id));
+        service_worker_internals::kUncommittedResIdKeyPrefix,
+        itr->resource_id));
     // Delete from the purgeable list in case this version was once deleted.
-    batch.Delete(
-        CreateResourceIdKey(kPurgeableResIdKeyPrefix, itr->resource_id));
+    batch.Delete(CreateResourceIdKey(
+        service_worker_internals::kPurgeableResIdKeyPrefix, itr->resource_id));
   }
 
   // Retrieve a previous version to sweep purgeable resources.
@@ -1095,7 +1117,8 @@ ServiceWorkerDatabase::ReadUserDataForAllRegistrationsByKeyPrefix(
   if (status != STATUS_OK)
     return status;
 
-  std::string key_prefix = kRegHasUserDataKeyPrefix + user_data_name_prefix;
+  std::string key_prefix = service_worker_internals::kRegHasUserDataKeyPrefix +
+                           user_data_name_prefix;
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
@@ -1110,14 +1133,15 @@ ServiceWorkerDatabase::ReadUserDataForAllRegistrationsByKeyPrefix(
         break;
 
       std::string user_data_name_with_id;
-      if (!RemovePrefix(itr->key().ToString(), kRegHasUserDataKeyPrefix,
+      if (!RemovePrefix(itr->key().ToString(),
+                        service_worker_internals::kRegHasUserDataKeyPrefix,
                         &user_data_name_with_id)) {
         break;
       }
 
       std::vector<std::string> parts = base::SplitString(
           user_data_name_with_id,
-          base::StringPrintf("%c", kServiceWorkerKeySeparator),
+          base::StringPrintf("%c", service_worker_internals::kKeySeparator),
           base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
       if (parts.size() != 2) {
         status = STATUS_ERROR_CORRUPTED;
@@ -1150,15 +1174,16 @@ ServiceWorkerDatabase::ReadUserDataForAllRegistrationsByKeyPrefix(
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetUncommittedResourceIds(
     std::set<int64_t>* ids) {
-  return ReadResourceIds(kUncommittedResIdKeyPrefix, ids);
+  return ReadResourceIds(service_worker_internals::kUncommittedResIdKeyPrefix,
+                         ids);
 }
 
 ServiceWorkerDatabase::Status
 ServiceWorkerDatabase::WriteUncommittedResourceIds(
     const std::set<int64_t>& ids) {
   leveldb::WriteBatch batch;
-  Status status =
-      WriteResourceIdsInBatch(kUncommittedResIdKeyPrefix, ids, &batch);
+  Status status = WriteResourceIdsInBatch(
+      service_worker_internals::kUncommittedResIdKeyPrefix, ids, &batch);
   if (status != STATUS_OK)
     return status;
   return WriteBatch(&batch);
@@ -1166,14 +1191,15 @@ ServiceWorkerDatabase::WriteUncommittedResourceIds(
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetPurgeableResourceIds(
     std::set<int64_t>* ids) {
-  return ReadResourceIds(kPurgeableResIdKeyPrefix, ids);
+  return ReadResourceIds(service_worker_internals::kPurgeableResIdKeyPrefix,
+                         ids);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ClearPurgeableResourceIds(
     const std::set<int64_t>& ids) {
   leveldb::WriteBatch batch;
-  Status status =
-      DeleteResourceIdsInBatch(kPurgeableResIdKeyPrefix, ids, &batch);
+  Status status = DeleteResourceIdsInBatch(
+      service_worker_internals::kPurgeableResIdKeyPrefix, ids, &batch);
   if (status != STATUS_OK)
     return status;
   return WriteBatch(&batch);
@@ -1184,10 +1210,11 @@ ServiceWorkerDatabase::PurgeUncommittedResourceIds(
     const std::set<int64_t>& ids) {
   leveldb::WriteBatch batch;
   Status status = DeleteResourceIdsInBatch(
-      kUncommittedResIdKeyPrefix, ids, &batch);
+      service_worker_internals::kUncommittedResIdKeyPrefix, ids, &batch);
   if (status != STATUS_OK)
     return status;
-  status = WriteResourceIdsInBatch(kPurgeableResIdKeyPrefix, ids, &batch);
+  status = WriteResourceIdsInBatch(
+      service_worker_internals::kPurgeableResIdKeyPrefix, ids, &batch);
   if (status != STATUS_OK)
     return status;
   return WriteBatch(&batch);
@@ -1309,7 +1336,7 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::LazyOpen(
       Disable(FROM_HERE, status);
       return status;
     case 2:
-      DCHECK_EQ(db_version, kCurrentServiceWorkerSchemaVersion);
+      DCHECK_EQ(db_version, service_worker_internals::kCurrentSchemaVersion);
       state_ = INITIALIZED;
       return STATUS_OK;
     default:
@@ -1769,7 +1796,8 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadDatabaseVersion(
     int64_t* db_version) {
   std::string value;
   Status status = LevelDBStatusToStatus(
-      db_->Get(leveldb::ReadOptions(), kDatabaseVersionKey, &value));
+      db_->Get(leveldb::ReadOptions(),
+               service_worker_internals::kDatabaseVersionKey, &value));
   if (status == STATUS_ERROR_NOT_FOUND) {
     // The database hasn't been initialized yet.
     *db_version = 0;
@@ -1785,7 +1813,7 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadDatabaseVersion(
   const int kFirstValidVersion = 1;
   if (!base::StringToInt64(value, db_version) ||
       *db_version < kFirstValidVersion ||
-      kCurrentServiceWorkerSchemaVersion < *db_version) {
+      service_worker_internals::kCurrentSchemaVersion < *db_version) {
     status = STATUS_ERROR_CORRUPTED;
     HandleReadResult(FROM_HERE, status);
     return status;
@@ -1803,8 +1831,9 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteBatch(
 
   if (state_ == UNINITIALIZED) {
     // Write database default values.
-    batch->Put(kDatabaseVersionKey,
-               base::Int64ToString(kCurrentServiceWorkerSchemaVersion));
+    batch->Put(
+        service_worker_internals::kDatabaseVersionKey,
+        base::Int64ToString(service_worker_internals::kCurrentSchemaVersion));
     state_ = INITIALIZED;
   }
 
@@ -1820,7 +1849,8 @@ void ServiceWorkerDatabase::BumpNextRegistrationIdIfNeeded(
   DCHECK(batch);
   if (next_avail_registration_id_ <= used_id) {
     next_avail_registration_id_ = used_id + 1;
-    batch->Put(kNextRegIdKey, base::Int64ToString(next_avail_registration_id_));
+    batch->Put(service_worker_internals::kNextRegIdKey,
+               base::Int64ToString(next_avail_registration_id_));
   }
 }
 
@@ -1830,7 +1860,8 @@ void ServiceWorkerDatabase::BumpNextResourceIdIfNeeded(
   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_));
+    batch->Put(service_worker_internals::kNextResIdKey,
+               base::Int64ToString(next_avail_resource_id_));
   }
 }
 
@@ -1840,7 +1871,8 @@ void ServiceWorkerDatabase::BumpNextVersionIdIfNeeded(
   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_));
+    batch->Put(service_worker_internals::kNextVerIdKey,
+               base::Int64ToString(next_avail_version_id_));
   }
 }