Rename CalledOnValidSequencedThread() to CalledOnValidSequence().

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"
@@ skipping 282 matching lines @@
 ServiceWorkerDatabase::ServiceWorkerDatabase(const base::FilePath& path)
     : path_(path),
       next_avail_registration_id_(0),
       next_avail_resource_id_(0),
       next_avail_version_id_(0),
       state_(UNINITIALIZED) {
   sequence_checker_.DetachFromSequence();
 }
 
 ServiceWorkerDatabase::~ServiceWorkerDatabase() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   db_.reset();
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetNextAvailableIds(
     int64_t* next_avail_registration_id,
     int64_t* next_avail_version_id,
     int64_t* next_avail_resource_id) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(next_avail_registration_id);
   DCHECK(next_avail_version_id);
   DCHECK(next_avail_resource_id);
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status)) {
     *next_avail_registration_id = 0;
     *next_avail_version_id = 0;
     *next_avail_resource_id = 0;
     return STATUS_OK;
@@ skipping 12 matching lines @@
     return status;
 
   *next_avail_registration_id = next_avail_registration_id_;
   *next_avail_version_id = next_avail_version_id_;
   *next_avail_resource_id = next_avail_resource_id_;
   return STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status
 ServiceWorkerDatabase::GetOriginsWithRegistrations(std::set<GURL>* origins) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(origins->empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   {
     std::unique_ptr<leveldb::Iterator> itr(
@@ skipping 20 matching lines @@
     }
   }
 
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status
 ServiceWorkerDatabase::GetOriginsWithForeignFetchRegistrations(
     std::set<GURL>* origins) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(origins->empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   {
     std::unique_ptr<leveldb::Iterator> itr(
@@ skipping 22 matching lines @@
   }
 
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetRegistrationsForOrigin(
     const GURL& origin,
     std::vector<RegistrationData>* registrations,
     std::vector<std::vector<ResourceRecord>>* opt_resources_list) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(registrations->empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   std::string prefix = CreateRegistrationKeyPrefix(origin);
   {
@@ skipping 33 matching lines @@
       }
     }
   }
 
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetAllRegistrations(
     std::vector<RegistrationData>* registrations) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(registrations->empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   {
     std::unique_ptr<leveldb::Iterator> itr(
@@ skipping 20 matching lines @@
 
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadRegistration(
     int64_t registration_id,
     const GURL& origin,
     RegistrationData* registration,
     std::vector<ResourceRecord>* resources) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(registration);
   DCHECK(resources);
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
 
   RegistrationData value;
   status = ReadRegistrationData(registration_id, origin, &value);
   if (status != STATUS_OK)
     return status;
 
   status = ReadResourceRecords(value.version_id, resources);
   if (status != STATUS_OK)
     return status;
 
   // ResourceRecord must contain the ServiceWorker's main script.
   if (resources->empty())
     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 
   *registration = value;
   return STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadRegistrationOrigin(
     int64_t registration_id,
     GURL* origin) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  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(
@@ skipping 15 matching lines @@
   *origin = parsed;
   HandleReadResult(FROM_HERE, STATUS_OK);
   return STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteRegistration(
     const RegistrationData& registration,
     const std::vector<ResourceRecord>& resources,
     RegistrationData* old_registration,
     std::vector<int64_t>* newly_purgeable_resources) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(old_registration);
   DCHECK(!resources.empty());
   Status status = LazyOpen(true);
   old_registration->version_id = kInvalidServiceWorkerVersionId;
   if (status != STATUS_OK)
     return status;
 
   leveldb::WriteBatch batch;
   BumpNextRegistrationIdIfNeeded(registration.registration_id, &batch);
   BumpNextVersionIdIfNeeded(registration.version_id, &batch);
@@ skipping 81 matching lines @@
             CreateForeignFetchOriginKey(registration.scope.GetOrigin()));
     }
   }
 
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::UpdateVersionToActive(
     int64_t registration_id,
     const GURL& origin) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
   if (!origin.is_valid())
     return STATUS_ERROR_FAILED;
 
   RegistrationData registration;
   status = ReadRegistrationData(registration_id, origin, &registration);
   if (status != STATUS_OK)
     return status;
 
   registration.is_active = true;
 
   leveldb::WriteBatch batch;
   WriteRegistrationDataInBatch(registration, &batch);
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::UpdateLastCheckTime(
     int64_t registration_id,
     const GURL& origin,
     const base::Time& time) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
   if (!origin.is_valid())
     return STATUS_ERROR_FAILED;
 
   RegistrationData registration;
   status = ReadRegistrationData(registration_id, origin, &registration);
   if (status != STATUS_OK)
     return status;
 
   registration.last_update_check = time;
 
   leveldb::WriteBatch batch;
   WriteRegistrationDataInBatch(registration, &batch);
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteRegistration(
     int64_t registration_id,
     const GURL& origin,
     RegistrationData* deleted_version,
     std::vector<int64_t>* newly_purgeable_resources) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(deleted_version);
   deleted_version->version_id = kInvalidServiceWorkerVersionId;
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
   if (!origin.is_valid())
     return STATUS_ERROR_FAILED;
 
@@ skipping 45 matching lines @@
     }
   }
 
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadUserData(
     int64_t registration_id,
     const std::vector<std::string>& user_data_names,
     std::vector<std::string>* user_data_values) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK_NE(kInvalidServiceWorkerRegistrationId, registration_id);
   DCHECK(!user_data_names.empty());
   DCHECK(user_data_values);
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
 
@@ skipping 10 matching lines @@
   }
   HandleReadResult(FROM_HERE,
                    status == STATUS_ERROR_NOT_FOUND ? STATUS_OK : status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteUserData(
     int64_t registration_id,
     const GURL& origin,
     const std::vector<std::pair<std::string, std::string>>& name_value_pairs) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK_NE(kInvalidServiceWorkerRegistrationId, registration_id);
   DCHECK(!name_value_pairs.empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_ERROR_NOT_FOUND;
   if (status != STATUS_OK)
     return status;
 
   // There should be the registration specified by |registration_id|.
   RegistrationData registration;
   status = ReadRegistrationData(registration_id, origin, &registration);
   if (status != STATUS_OK)
     return status;
 
   leveldb::WriteBatch batch;
   for (const auto& pair : name_value_pairs) {
     DCHECK(!pair.first.empty());
     batch.Put(CreateUserDataKey(registration_id, pair.first), pair.second);
     batch.Put(CreateHasUserDataKey(registration_id, pair.first), "");
   }
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteUserData(
     int64_t registration_id,
     const std::vector<std::string>& user_data_names) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK_NE(kInvalidServiceWorkerRegistrationId, registration_id);
   DCHECK(!user_data_names.empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   leveldb::WriteBatch batch;
   for (const std::string& name : user_data_names) {
     DCHECK(!name.empty());
     batch.Delete(CreateUserDataKey(registration_id, name));
     batch.Delete(CreateHasUserDataKey(registration_id, name));
   }
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status
 ServiceWorkerDatabase::ReadUserDataForAllRegistrations(
     const std::string& user_data_name,
     std::vector<std::pair<int64_t, std::string>>* user_data) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(user_data->empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   std::string key_prefix = CreateHasUserDataKeyPrefix(user_data_name);
   {
@@ skipping 76 matching lines @@
     return status;
   status = WriteResourceIdsInBatch(kPurgeableResIdKeyPrefix, ids, &batch);
   if (status != STATUS_OK)
     return status;
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteAllDataForOrigins(
     const std::set<GURL>& origins,
     std::vector<int64_t>* newly_purgeable_resources) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
   leveldb::WriteBatch batch;
 
   for (const GURL& origin : origins) {
     if (!origin.is_valid())
       return STATUS_ERROR_FAILED;
@@ skipping 22 matching lines @@
       status = DeleteUserDataForRegistration(data.registration_id, &batch);
       if (status != STATUS_OK)
         return status;
     }
   }
 
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DestroyDatabase() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   Disable(FROM_HERE, STATUS_OK);
 
   if (IsDatabaseInMemory()) {
     env_.reset();
     return STATUS_OK;
   }
 
   // Directly delete the database directory instead of leveldb::DestroyDB()
   // because the API does not delete the directory if there are unrelated files.
   // (https://code.google.com/p/chromium/issues/detail?id=468926#c24)
   Status status = base::DeleteFile(path_, true /* recursive */)
                       ? STATUS_OK
                       : STATUS_ERROR_FAILED;
   ServiceWorkerMetrics::RecordDestroyDatabaseResult(status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::LazyOpen(
     bool create_if_missing) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   // Do not try to open a database if we tried and failed once.
   if (state_ == DISABLED)
     return STATUS_ERROR_FAILED;
   if (IsOpen())
     return STATUS_OK;
 
   if (!create_if_missing) {
     // Avoid opening a database if it does not exist at the |path_|.
     if (IsDatabaseInMemory() || !base::PathExists(path_) ||
@@ skipping 329 matching lines @@
     }
   }
 
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadResourceIds(
     const char* id_key_prefix,
     std::set<int64_t>* ids) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(id_key_prefix);
   DCHECK(ids->empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   {
@@ skipping 21 matching lines @@
   }
 
   HandleReadResult(FROM_HERE, status);
   return status;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteResourceIdsInBatch(
     const char* id_key_prefix,
     const std::set<int64_t>& ids,
     leveldb::WriteBatch* batch) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(id_key_prefix);
 
   Status status = LazyOpen(true);
   if (status != STATUS_OK)
     return status;
 
   if (ids.empty())
     return STATUS_OK;
   for (std::set<int64_t>::const_iterator itr = ids.begin(); itr != ids.end();
        ++itr) {
     // Value should be empty.
     batch->Put(CreateResourceIdKey(id_key_prefix, *itr), "");
   }
   // std::set is sorted, so the last element is the largest.
   BumpNextResourceIdIfNeeded(*ids.rbegin(), batch);
   return STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteResourceIdsInBatch(
     const char* id_key_prefix,
     const std::set<int64_t>& ids,
     leveldb::WriteBatch* batch) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(id_key_prefix);
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
   if (status != STATUS_OK)
     return status;
 
   for (std::set<int64_t>::const_iterator itr = ids.begin(); itr != ids.end();
        ++itr) {
@@ skipping 146 matching lines @@
   if (status != STATUS_OK)
     Disable(from_here, status);
   ServiceWorkerMetrics::CountWriteDatabaseResult(status);
 }
 
 bool ServiceWorkerDatabase::IsDatabaseInMemory() const {
   return path_.empty();
 }
 
 }  // namespace content