Snapshot of all changes to get jumbo in blink and content.

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 <utility>
 
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/service_worker/service_worker_database.pb.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
+// third_party/webrtc/base/thread_checker.h leaks the define
+// EXCLUSIVE_LOCKS_REQUIRED and more which collide with the same define in
+// third_party/leveldatabase/src/port/thread_annotations.
+#undef EXCLUSIVE_LOCKS_REQUIRED
+#undef SHARED_LOCKS_REQUIRED
+#undef LOCKS_EXCLUDED
+#undef LOCK_RETURNED
+#undef LOCKABLE
+#undef SCOPED_LOCKABLE
+#undef EXCLUSIVE_LOCK_FUNCTION
+#undef SHARED_LOCK_FUNCTION
+#undef EXCLUSIVE_TRYLOCK_FUNCTION
+#undef SHARED_TRYLOCK_FUNCTION
+#undef UNLOCK_FUNCTION
+#undef NO_THREAD_SAFETY_ANALYSIS
 #include "url/origin.h"
 
 // LevelDB database schema
 // =======================
 //
 // NOTE
 // - int64_t value is serialized as a string by base::Int64ToString().
 // - GURL value is serialized as a string by GURL::spec().
 //
 // Version 1 (in sorted order)
@@ skipping 63 matching lines @@
 const char kNextResIdKey[] = "INITDATA_NEXT_RESOURCE_ID";
 const char kNextVerIdKey[] = "INITDATA_NEXT_VERSION_ID";
 const char kUniqueOriginKey[] = "INITDATA_UNIQUE_ORIGIN:";
 const char kForeignFetchOriginKey[] = "INITDATA_FOREIGN_FETCH_ORIGIN:";
 
 const char kRegKeyPrefix[] = "REG:";
 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 kKeySeparator = '\x00';
+const char kSWKeySeparator = '\x00';
 
 const char kUncommittedResIdKeyPrefix[] = "URES:";
 const char kPurgeableResIdKeyPrefix[] = "PRES:";
 
-const int64_t kCurrentSchemaVersion = 2;
+const int64_t kSWCurrentSchemaVersion = 2;
 
 class ServiceWorkerEnv : public leveldb_env::ChromiumEnv {
  public:
   ServiceWorkerEnv() : ChromiumEnv("LevelDBEnv.ServiceWorker") {}
 };
 
 base::LazyInstance<ServiceWorkerEnv>::Leaky g_service_worker_env =
     LAZY_INSTANCE_INITIALIZER;
 
 bool RemovePrefix(const std::string& str,
                   const std::string& prefix,
                   std::string* out) {
   if (!base::StartsWith(str, prefix, base::CompareCase::SENSITIVE))
     return false;
   if (out)
     *out = str.substr(prefix.size());
   return true;
 }
 
 std::string CreateRegistrationKeyPrefix(const GURL& origin) {
   return base::StringPrintf("%s%s%c", kRegKeyPrefix,
-                            origin.GetOrigin().spec().c_str(), kKeySeparator);
+                            origin.GetOrigin().spec().c_str(), kSWKeySeparator);
 }
 
 std::string CreateRegistrationKey(int64_t registration_id, const GURL& origin) {
   return CreateRegistrationKeyPrefix(origin)
       .append(base::Int64ToString(registration_id));
 }
 
 std::string CreateResourceRecordKeyPrefix(int64_t version_id) {
   return base::StringPrintf("%s%s%c",
                             kResKeyPrefix,
                             base::Int64ToString(version_id).c_str(),
-                            kKeySeparator);
+                            kSWKeySeparator);
 }
 
 std::string CreateResourceRecordKey(int64_t version_id, int64_t resource_id) {
   return CreateResourceRecordKeyPrefix(version_id).append(
       base::Int64ToString(resource_id));
 }
 
 std::string CreateUniqueOriginKey(const GURL& origin) {
   return base::StringPrintf("%s%s", kUniqueOriginKey,
                             origin.GetOrigin().spec().c_str());
 }
 
 std::string CreateForeignFetchOriginKey(const GURL& origin) {
   return base::StringPrintf("%s%s", kForeignFetchOriginKey,
                             origin.GetOrigin().spec().c_str());
 }
 
 std::string CreateResourceIdKey(const char* key_prefix, int64_t resource_id) {
   return base::StringPrintf(
       "%s%s", key_prefix, base::Int64ToString(resource_id).c_str());
 }
 
 std::string CreateUserDataKeyPrefix(int64_t registration_id) {
   return base::StringPrintf("%s%s%c",
                             kRegUserDataKeyPrefix,
                             base::Int64ToString(registration_id).c_str(),
-                            kKeySeparator);
+                            kSWKeySeparator);
 }
 
 std::string CreateUserDataKey(int64_t registration_id,
                               const std::string& user_data_name) {
   return CreateUserDataKeyPrefix(registration_id).append(user_data_name);
 }
 
 std::string CreateHasUserDataKeyPrefix(const std::string& user_data_name) {
   return base::StringPrintf("%s%s%c", kRegHasUserDataKeyPrefix,
-                            user_data_name.c_str(), kKeySeparator);
+                            user_data_name.c_str(), kSWKeySeparator);
 }
 
 std::string CreateHasUserDataKey(int64_t registration_id,
                                  const std::string& user_data_name) {
   return CreateHasUserDataKeyPrefix(user_data_name)
       .append(base::Int64ToString(registration_id));
 }
 
 std::string CreateRegistrationIdToOriginKey(int64_t registration_id) {
   return base::StringPrintf("%s%s", kRegIdToOriginKeyPrefix,
@@ skipping 21 matching lines @@
 ServiceWorkerDatabase::Status ParseId(const std::string& serialized,
                                       int64_t* out) {
   DCHECK(out);
   int64_t id;
   if (!base::StringToInt64(serialized, &id) || id < 0)
     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
   *out = id;
   return ServiceWorkerDatabase::STATUS_OK;
 }
 
-ServiceWorkerDatabase::Status LevelDBStatusToStatus(
+ServiceWorkerDatabase::Status LevelDBStatusToSWStatus(
     const leveldb::Status& status) {
   if (status.ok())
     return ServiceWorkerDatabase::STATUS_OK;
   else if (status.IsNotFound())
     return ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND;
   else if (status.IsIOError())
     return ServiceWorkerDatabase::STATUS_ERROR_IO_ERROR;
   else if (status.IsCorruption())
     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
   else if (status.IsNotSupportedError())
@@ skipping 106 matching lines @@
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(kUniqueOriginKey); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK) {
         origins->clear();
         break;
       }
 
       std::string origin_str;
       if (!RemovePrefix(itr->key().ToString(), kUniqueOriginKey, &origin_str))
         break;
 
       GURL origin(origin_str);
@@ skipping 20 matching lines @@
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(kForeignFetchOriginKey); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK) {
         origins->clear();
         break;
       }
 
       std::string origin_str;
       if (!RemovePrefix(itr->key().ToString(), kForeignFetchOriginKey,
                         &origin_str))
         break;
 
@@ skipping 23 matching lines @@
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   std::string prefix = CreateRegistrationKeyPrefix(origin);
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK) {
         registrations->clear();
         if (opt_resources_list)
           opt_resources_list->clear();
         break;
       }
 
       if (!RemovePrefix(itr->key().ToString(), prefix, NULL))
         break;
 
@@ skipping 32 matching lines @@
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(kRegKeyPrefix); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK) {
         registrations->clear();
         break;
       }
 
       if (!RemovePrefix(itr->key().ToString(), kRegKeyPrefix, NULL))
         break;
 
       RegistrationData registration;
       status = ParseRegistrationData(itr->value().ToString(), &registration);
@@ skipping 47 matching lines @@
   DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(origin);
 
   Status status = LazyOpen(true);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
 
   std::string value;
-  status = LevelDBStatusToStatus(
+  status = LevelDBStatusToSWStatus(
       db_->Get(leveldb::ReadOptions(),
                CreateRegistrationIdToOriginKey(registration_id), &value));
   if (status != STATUS_OK) {
     HandleReadResult(FROM_HERE,
                      status == STATUS_ERROR_NOT_FOUND ? STATUS_OK : status);
     return status;
   }
 
   GURL parsed(value);
   if (!parsed.is_valid()) {
@@ skipping 289 matching lines @@
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
 
   user_data_values->resize(user_data_names.size());
   for (size_t i = 0; i < user_data_names.size(); i++) {
     const std::string key =
         CreateUserDataKey(registration_id, user_data_names[i]);
-    status = LevelDBStatusToStatus(
+    status = LevelDBStatusToSWStatus(
         db_->Get(leveldb::ReadOptions(), key, &(*user_data_values)[i]));
     if (status != STATUS_OK) {
       user_data_values->clear();
       break;
     }
   }
   HandleReadResult(FROM_HERE,
                    status == STATUS_ERROR_NOT_FOUND ? STATUS_OK : status);
   return status;
 }
@@ skipping 10 matching lines @@
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
 
   std::string prefix = CreateUserDataKey(registration_id, key_prefix);
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK) {
         user_data_values->clear();
         break;
       }
 
       if (!itr->key().starts_with(prefix))
         break;
 
       std::string user_data_value;
-      status = LevelDBStatusToStatus(
+      status = LevelDBStatusToSWStatus(
           db_->Get(leveldb::ReadOptions(), itr->key(), &user_data_value));
       if (status != STATUS_OK) {
         user_data_values->clear();
         break;
       }
 
       user_data_values->push_back(user_data_value);
     }
   }
 
@@ skipping 63 matching lines @@
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   std::string key_prefix = CreateHasUserDataKeyPrefix(user_data_name);
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(key_prefix); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK) {
         user_data->clear();
         break;
       }
 
       std::string registration_id_string;
       if (!RemovePrefix(itr->key().ToString(), key_prefix,
                         &registration_id_string)) {
         break;
       }
 
       int64_t registration_id;
       status = ParseId(registration_id_string, &registration_id);
       if (status != STATUS_OK) {
         user_data->clear();
         break;
       }
 
       std::string value;
-      status = LevelDBStatusToStatus(
+      status = LevelDBStatusToSWStatus(
           db_->Get(leveldb::ReadOptions(),
                    CreateUserDataKey(registration_id, user_data_name), &value));
       if (status != STATUS_OK) {
         user_data->clear();
         break;
       }
       user_data->push_back(std::make_pair(registration_id, value));
     }
   }
 
@@ skipping 12 matching lines @@
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   std::string key_prefix = kRegHasUserDataKeyPrefix + user_data_name_prefix;
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(key_prefix); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK) {
         user_data->clear();
         break;
       }
 
       if (!itr->key().starts_with(key_prefix))
         break;
 
       std::string user_data_name_with_id;
       if (!RemovePrefix(itr->key().ToString(), kRegHasUserDataKeyPrefix,
                         &user_data_name_with_id)) {
         break;
       }
 
       std::vector<std::string> parts = base::SplitString(
-          user_data_name_with_id, base::StringPrintf("%c", kKeySeparator),
+          user_data_name_with_id, base::StringPrintf("%c", kSWKeySeparator),
           base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
       if (parts.size() != 2) {
         status = STATUS_ERROR_CORRUPTED;
         user_data->clear();
         break;
       }
 
       int64_t registration_id;
       status = ParseId(parts[1], &registration_id);
       if (status != STATUS_OK) {
         user_data->clear();
         break;
       }
 
       std::string value;
-      status = LevelDBStatusToStatus(
+      status = LevelDBStatusToSWStatus(
           db_->Get(leveldb::ReadOptions(),
                    CreateUserDataKey(registration_id, parts[0]), &value));
       if (status != STATUS_OK) {
         user_data->clear();
         break;
       }
       user_data->push_back(std::make_pair(registration_id, value));
     }
   }
 
@@ skipping 132 matching lines @@
   options.create_if_missing = create_if_missing;
   options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue;
   if (IsDatabaseInMemory()) {
     env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
     options.env = env_.get();
   } else {
     options.env = g_service_worker_env.Pointer();
   }
 
   leveldb::DB* db = NULL;
-  Status status = LevelDBStatusToStatus(
+  Status status = LevelDBStatusToSWStatus(
       leveldb::DB::Open(options, path_.AsUTF8Unsafe(), &db));
   HandleOpenResult(FROM_HERE, status);
   if (status != STATUS_OK) {
     DCHECK(!db);
     // TODO(nhiroki): Should we retry to open the database?
     return status;
   }
   db_.reset(db);
 
   int64_t db_version;
   status = ReadDatabaseVersion(&db_version);
   if (status != STATUS_OK)
     return status;
 
   switch (db_version) {
     case 0:
       // This database is new. It will be initialized when something is written.
       DCHECK_EQ(UNINITIALIZED, state_);
       return STATUS_OK;
     case 1:
       // This database has an obsolete schema version. ServiceWorkerStorage
       // should recreate it.
       status = STATUS_ERROR_FAILED;
       Disable(FROM_HERE, status);
       return status;
     case 2:
-      DCHECK_EQ(db_version, kCurrentSchemaVersion);
+      DCHECK_EQ(db_version, kSWCurrentSchemaVersion);
       state_ = INITIALIZED;
       return STATUS_OK;
     default:
       // Other cases should be handled in ReadDatabaseVersion.
       NOTREACHED();
       return STATUS_ERROR_CORRUPTED;
   }
 }
 
 bool ServiceWorkerDatabase::IsNewOrNonexistentDatabase(
     ServiceWorkerDatabase::Status status) {
   if (status == STATUS_ERROR_NOT_FOUND)
     return true;
   if (status == STATUS_OK && state_ == UNINITIALIZED)
     return true;
   return false;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadNextAvailableId(
     const char* id_key,
     int64_t* next_avail_id) {
   DCHECK(id_key);
   DCHECK(next_avail_id);
 
   std::string value;
-  Status status = LevelDBStatusToStatus(
+  Status status = LevelDBStatusToSWStatus(
       db_->Get(leveldb::ReadOptions(), id_key, &value));
   if (status == STATUS_ERROR_NOT_FOUND) {
     // Nobody has gotten the next resource id for |id_key|.
     *next_avail_id = 0;
     HandleReadResult(FROM_HERE, STATUS_OK);
     return STATUS_OK;
   } else if (status != STATUS_OK) {
     HandleReadResult(FROM_HERE, status);
     return status;
   }
 
   status = ParseId(value, next_avail_id);
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadRegistrationData(
     int64_t registration_id,
     const GURL& origin,
     RegistrationData* registration) {
   DCHECK(registration);
 
   const std::string key = CreateRegistrationKey(registration_id, origin);
   std::string value;
-  Status status = LevelDBStatusToStatus(
+  Status status = LevelDBStatusToSWStatus(
       db_->Get(leveldb::ReadOptions(), key, &value));
   if (status != STATUS_OK) {
     HandleReadResult(
         FROM_HERE,
         status == STATUS_ERROR_NOT_FOUND ? STATUS_OK : status);
     return status;
   }
 
   status = ParseRegistrationData(value, registration);
   HandleReadResult(FROM_HERE, status);
@@ skipping 141 matching lines @@
   DCHECK(resources->empty());
 
   Status status = STATUS_OK;
   bool has_main_resource = false;
   const std::string prefix =
       CreateResourceRecordKeyPrefix(registration.version_id);
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
-      Status status = LevelDBStatusToStatus(itr->status());
+      Status status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK) {
         resources->clear();
         break;
       }
 
       if (!RemovePrefix(itr->key().ToString(), prefix, NULL))
         break;
 
       ResourceRecord resource;
       status = ParseResourceRecord(itr->value().ToString(), &resource);
@@ skipping 80 matching lines @@
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
 
   Status status = STATUS_OK;
   const std::string prefix = CreateResourceRecordKeyPrefix(version_id);
 
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK)
         break;
 
       const std::string key = itr->key().ToString();
       std::string unprefixed;
       if (!RemovePrefix(key, prefix, &unprefixed))
         break;
 
       int64_t resource_id;
       status = ParseId(unprefixed, &resource_id);
@@ skipping 24 matching lines @@
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(id_key_prefix); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK) {
         ids->clear();
         break;
       }
 
       std::string unprefixed;
       if (!RemovePrefix(itr->key().ToString(), id_key_prefix, &unprefixed))
         break;
 
       int64_t resource_id;
@@ skipping 58 matching lines @@
     int64_t registration_id,
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
   Status status = STATUS_OK;
   const std::string prefix = CreateUserDataKeyPrefix(registration_id);
 
   {
     std::unique_ptr<leveldb::Iterator> itr(
         db_->NewIterator(leveldb::ReadOptions()));
     for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
-      status = LevelDBStatusToStatus(itr->status());
+      status = LevelDBStatusToSWStatus(itr->status());
       if (status != STATUS_OK)
         break;
 
       const std::string key = itr->key().ToString();
       std::string user_data_name;
       if (!RemovePrefix(key, prefix, &user_data_name))
         break;
       batch->Delete(key);
       batch->Delete(CreateHasUserDataKey(registration_id, user_data_name));
     }
   }
 
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadDatabaseVersion(
     int64_t* db_version) {
   std::string value;
-  Status status = LevelDBStatusToStatus(
+  Status status = LevelDBStatusToSWStatus(
       db_->Get(leveldb::ReadOptions(), kDatabaseVersionKey, &value));
   if (status == STATUS_ERROR_NOT_FOUND) {
     // The database hasn't been initialized yet.
     *db_version = 0;
     HandleReadResult(FROM_HERE, STATUS_OK);
     return STATUS_OK;
   }
 
   if (status != STATUS_OK) {
     HandleReadResult(FROM_HERE, status);
     return status;
   }
 
   const int kFirstValidVersion = 1;
   if (!base::StringToInt64(value, db_version) ||
-      *db_version < kFirstValidVersion || kCurrentSchemaVersion < *db_version) {
+      *db_version < kFirstValidVersion || kSWCurrentSchemaVersion < *db_version) {
     status = STATUS_ERROR_CORRUPTED;
     HandleReadResult(FROM_HERE, status);
     return status;
   }
 
   status = STATUS_OK;
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteBatch(
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
   DCHECK_NE(DISABLED, state_);
 
   if (state_ == UNINITIALIZED) {
     // Write database default values.
-    batch->Put(kDatabaseVersionKey, base::Int64ToString(kCurrentSchemaVersion));
+    batch->Put(kDatabaseVersionKey, base::Int64ToString(kSWCurrentSchemaVersion));
     state_ = INITIALIZED;
   }
 
-  Status status = LevelDBStatusToStatus(
+  Status status = LevelDBStatusToSWStatus(
       db_->Write(leveldb::WriteOptions(), batch));
   HandleWriteResult(FROM_HERE, status);
   return status;
 }
 
 void ServiceWorkerDatabase::BumpNextRegistrationIdIfNeeded(
     int64_t used_id,
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
   if (next_avail_registration_id_ <= used_id) {
@@ skipping 60 matching lines @@
   if (status != STATUS_OK)
     Disable(from_here, status);
   ServiceWorkerMetrics::CountWriteDatabaseResult(status);
 }
 
 bool ServiceWorkerDatabase::IsDatabaseInMemory() const {
   return path_.empty();
 }
 
 }  // namespace content