Rename CalledOnValidSequencedThread() to CalledOnValidSequence().

chrome/browser/sync_file_system/drive_backend/sync_worker.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 "chrome/browser/sync_file_system/drive_backend/sync_worker.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 49 matching lines @@
       weak_ptr_factory_(this) {
   sequence_checker_.DetachFromSequence();
   DCHECK(base_dir_.IsAbsolute());
 }
 
 SyncWorker::~SyncWorker() {
   observers_.Clear();
 }
 
 void SyncWorker::Initialize(std::unique_ptr<SyncEngineContext> context) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(!task_manager_);
 
   context_ = std::move(context);
 
   task_manager_.reset(new SyncTaskManager(
       weak_ptr_factory_.GetWeakPtr(), 0 /* maximum_background_task */,
       context_->GetWorkerTaskRunner(),
       context_->GetWorkerPool()));
   task_manager_->Initialize(SYNC_STATUS_OK);
 
   PostInitializeTask();
 }
 
 void SyncWorker::RegisterOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (!GetMetadataDatabase())
     PostInitializeTask();
 
   std::unique_ptr<RegisterAppTask> task(
       new RegisterAppTask(context_.get(), origin.host()));
   if (task->CanFinishImmediately()) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   task_manager_->ScheduleSyncTask(FROM_HERE, std::move(task),
                                   SyncTaskManager::PRIORITY_HIGH, callback);
 }
 
 void SyncWorker::EnableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   task_manager_->ScheduleTask(
       FROM_HERE,
       base::Bind(&SyncWorker::DoEnableApp,
                  weak_ptr_factory_.GetWeakPtr(),
                  origin.host()),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncWorker::DisableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   task_manager_->ScheduleTask(
       FROM_HERE,
       base::Bind(&SyncWorker::DoDisableApp,
                  weak_ptr_factory_.GetWeakPtr(),
                  origin.host()),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncWorker::UninstallOrigin(
     const GURL& origin,
     RemoteFileSyncService::UninstallFlag flag,
     const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   task_manager_->ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(
                      new UninstallAppTask(context_.get(), origin.host(), flag)),
       SyncTaskManager::PRIORITY_HIGH, callback);
 }
 
 void SyncWorker::ProcessRemoteChange(const SyncFileCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   RemoteToLocalSyncer* syncer = new RemoteToLocalSyncer(context_.get());
   task_manager_->ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(syncer),
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&SyncWorker::DidProcessRemoteChange,
                  weak_ptr_factory_.GetWeakPtr(), syncer, callback));
 }
 
 void SyncWorker::SetRemoteChangeProcessor(
     RemoteChangeProcessorOnWorker* remote_change_processor_on_worker) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   context_->SetRemoteChangeProcessor(remote_change_processor_on_worker);
 }
 
 RemoteServiceState SyncWorker::GetCurrentState() const {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (!sync_enabled_)
     return REMOTE_SERVICE_DISABLED;
   return service_state_;
 }
 
 void SyncWorker::GetOriginStatusMap(
     const RemoteFileSyncService::StatusMapCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (!GetMetadataDatabase())
     return;
 
   std::vector<std::string> app_ids;
   GetMetadataDatabase()->GetRegisteredAppIDs(&app_ids);
 
   std::unique_ptr<RemoteFileSyncService::OriginStatusMap> status_map(
       new RemoteFileSyncService::OriginStatusMap);
   for (std::vector<std::string>::const_iterator itr = app_ids.begin();
        itr != app_ids.end(); ++itr) {
     const std::string& app_id = *itr;
     GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
     (*status_map)[origin] =
         GetMetadataDatabase()->IsAppEnabled(app_id) ? "Enabled" : "Disabled";
   }
 
   callback.Run(std::move(status_map));
 }
 
 std::unique_ptr<base::ListValue> SyncWorker::DumpFiles(const GURL& origin) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (!GetMetadataDatabase())
     return std::unique_ptr<base::ListValue>();
   return GetMetadataDatabase()->DumpFiles(origin.host());
 }
 
 std::unique_ptr<base::ListValue> SyncWorker::DumpDatabase() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (!GetMetadataDatabase())
     return std::unique_ptr<base::ListValue>();
   return GetMetadataDatabase()->DumpDatabase();
 }
 
 void SyncWorker::SetSyncEnabled(bool enabled) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (sync_enabled_ == enabled)
     return;
 
   RemoteServiceState old_state = GetCurrentState();
   sync_enabled_ = enabled;
   if (old_state == GetCurrentState())
     return;
 
   FOR_EACH_OBSERVER(
       Observer,
       observers_,
       UpdateServiceState(
           GetCurrentState(),
           enabled ? "Sync is enabled" : "Sync is disabled"));
 }
 
 void SyncWorker::PromoteDemotedChanges(const base::Closure& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   MetadataDatabase* metadata_db = GetMetadataDatabase();
   if (metadata_db && metadata_db->HasDemotedDirtyTracker()) {
     metadata_db->PromoteDemotedTrackers();
     FOR_EACH_OBSERVER(
         Observer,
         observers_,
         OnPendingFileListUpdated(metadata_db->CountDirtyTracker()));
   }
   callback.Run();
 }
 
 void SyncWorker::ApplyLocalChange(const FileChange& local_change,
                                   const base::FilePath& local_path,
                                   const SyncFileMetadata& local_metadata,
                                   const storage::FileSystemURL& url,
                                   const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   LocalToRemoteSyncer* syncer = new LocalToRemoteSyncer(
       context_.get(), local_metadata, local_change, local_path, url);
   task_manager_->ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(syncer),
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&SyncWorker::DidApplyLocalChange,
                  weak_ptr_factory_.GetWeakPtr(), syncer, callback));
 }
 
 void SyncWorker::MaybeScheduleNextTask() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return;
 
   // TODO(tzik): Notify observer of OnRemoteChangeQueueUpdated.
   // TODO(tzik): Add an interface to get the number of dirty trackers to
   // MetadataDatabase.
 
   if (MaybeStartFetchChanges())
     return;
 
   if (!call_on_idle_callback_.is_null()) {
     base::Closure callback = call_on_idle_callback_;
     call_on_idle_callback_.Reset();
     callback.Run();
   }
 }
 
 void SyncWorker::NotifyLastOperationStatus(
     SyncStatusCode status,
     bool used_network) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   UpdateServiceStateFromSyncStatusCode(status, used_network);
 
   if (GetMetadataDatabase()) {
     FOR_EACH_OBSERVER(
         Observer, observers_,
         OnPendingFileListUpdated(GetMetadataDatabase()->CountDirtyTracker()));
   }
 }
 
 void SyncWorker::RecordTaskLog(std::unique_ptr<TaskLogger::TaskLog> task_log) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   context_->GetUITaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&TaskLogger::RecordLog,
                  context_->GetTaskLogger(),
                  base::Passed(&task_log)));
 }
 
 void SyncWorker::ActivateService(RemoteServiceState service_state,
                                  const std::string& description) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   UpdateServiceState(service_state, description);
   if (!GetMetadataDatabase()) {
     PostInitializeTask();
     return;
   }
 
   should_check_remote_change_ = true;
   MaybeScheduleNextTask();
 }
 
 void SyncWorker::DeactivateService(const std::string& description) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   UpdateServiceState(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE, description);
 }
 
 void SyncWorker::DetachFromSequence() {
   task_manager_->DetachFromSequence();
   context_->DetachFromSequence();
   sequence_checker_.DetachFromSequence();
 }
 
 void SyncWorker::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void SyncWorker::DoDisableApp(const std::string& app_id,
                               const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (!GetMetadataDatabase()) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   SyncStatusCode status = GetMetadataDatabase()->DisableApp(app_id);
   callback.Run(status);
 }
 
 void SyncWorker::DoEnableApp(const std::string& app_id,
                              const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (!GetMetadataDatabase()) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   SyncStatusCode status = GetMetadataDatabase()->EnableApp(app_id);
   callback.Run(status);
 }
 
 void SyncWorker::PostInitializeTask() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(!GetMetadataDatabase());
 
   // This initializer task may not run if MetadataDatabase in context_ is
   // already initialized when it runs.
   SyncEngineInitializer* initializer =
       new SyncEngineInitializer(context_.get(),
                                 base_dir_.Append(kDatabaseName),
                                 env_override_);
   task_manager_->ScheduleSyncTask(
       FROM_HERE, std::unique_ptr<SyncTask>(initializer),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&SyncWorker::DidInitialize, weak_ptr_factory_.GetWeakPtr(),
                  initializer));
 }
 
 void SyncWorker::DidInitialize(SyncEngineInitializer* initializer,
                                SyncStatusCode status) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (status == SYNC_STATUS_ACCESS_FORBIDDEN) {
     UpdateServiceState(REMOTE_SERVICE_ACCESS_FORBIDDEN, "Access forbidden");
     return;
   }
   if (status != SYNC_STATUS_OK) {
     UpdateServiceState(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE,
                        "Could not initialize remote service");
     return;
   }
 
   std::unique_ptr<MetadataDatabase> metadata_database =
       initializer->PassMetadataDatabase();
   if (metadata_database) {
     context_->SetMetadataDatabase(std::move(metadata_database));
     return;
   }
 
   UpdateServiceState(REMOTE_SERVICE_OK, std::string());
   UpdateRegisteredApps();
 }
 
 void SyncWorker::UpdateRegisteredApps() {
   MetadataDatabase* metadata_db = GetMetadataDatabase();
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(metadata_db);
 
   std::unique_ptr<std::vector<std::string>> app_ids(
       new std::vector<std::string>);
   metadata_db->GetRegisteredAppIDs(app_ids.get());
 
   AppStatusMap* app_status = new AppStatusMap;
   base::Closure callback =
       base::Bind(&SyncWorker::DidQueryAppStatus,
                  weak_ptr_factory_.GetWeakPtr(),
@@ skipping 29 matching lines @@
     else if (!extension_service->IsExtensionEnabled(app_id))
       (*status)[app_id] = APP_STATUS_DISABLED;
     else
       (*status)[app_id] = APP_STATUS_ENABLED;
   }
 
   callback.Run();
 }
 
 void SyncWorker::DidQueryAppStatus(const AppStatusMap* app_status) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   MetadataDatabase* metadata_db = GetMetadataDatabase();
   DCHECK(metadata_db);
 
   // Update the status of every origin using status from ExtensionService.
   for (AppStatusMap::const_iterator itr = app_status->begin();
        itr != app_status->end(); ++itr) {
     const std::string& app_id = itr->first;
     GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
 
@@ skipping 21 matching lines @@
     if (is_app_enabled && !is_app_root_tracker_enabled)
       EnableOrigin(origin, base::Bind(&EmptyStatusCallback));
     else if (!is_app_enabled && is_app_root_tracker_enabled)
       DisableOrigin(origin, base::Bind(&EmptyStatusCallback));
   }
 }
 
 void SyncWorker::DidProcessRemoteChange(RemoteToLocalSyncer* syncer,
                                         const SyncFileCallback& callback,
                                         SyncStatusCode status) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (syncer->is_sync_root_deletion()) {
     MetadataDatabase::ClearDatabase(context_->PassMetadataDatabase());
     PostInitializeTask();
     callback.Run(status, syncer->url());
     return;
   }
 
   if (status == SYNC_STATUS_OK) {
     if (syncer->sync_action() != SYNC_ACTION_NONE &&
@@ skipping 14 matching lines @@
       RegisterOrigin(syncer->url().origin(), base::Bind(&EmptyStatusCallback));
     }
     should_check_conflict_ = true;
   }
   callback.Run(status, syncer->url());
 }
 
 void SyncWorker::DidApplyLocalChange(LocalToRemoteSyncer* syncer,
                                      const SyncStatusCallback& callback,
                                      SyncStatusCode status) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if ((status == SYNC_STATUS_OK || status == SYNC_STATUS_RETRY) &&
       syncer->url().is_valid() &&
       syncer->sync_action() != SYNC_ACTION_NONE) {
     storage::FileSystemURL updated_url = syncer->url();
     if (!syncer->target_path().empty()) {
       updated_url = CreateSyncableFileSystemURL(syncer->url().origin(),
                                                 syncer->target_path());
     }
     FOR_EACH_OBSERVER(Observer, observers_,
@@ skipping 24 matching lines @@
         base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
   }
 
   if (status == SYNC_STATUS_OK)
     should_check_conflict_ = true;
 
   callback.Run(status);
 }
 
 bool SyncWorker::MaybeStartFetchChanges() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return false;
 
   if (!GetMetadataDatabase())
     return false;
 
   if (listing_remote_changes_)
     return false;
 
@@ skipping 19 matching lines @@
     should_check_remote_change_ = false;
     listing_remote_changes_ = true;
     time_to_check_changes_ =
         now + base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
     return true;
   }
   return false;
 }
 
 void SyncWorker::DidResolveConflict(SyncStatusCode status) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (status == SYNC_STATUS_OK || status == SYNC_STATUS_RETRY)
     should_check_conflict_ = true;
 }
 
 void SyncWorker::DidFetchChanges(SyncStatusCode status) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (status == SYNC_STATUS_OK)
     should_check_conflict_ = true;
   listing_remote_changes_ = false;
 }
 
 void SyncWorker::UpdateServiceStateFromSyncStatusCode(
     SyncStatusCode status,
     bool used_network) {
   switch (status) {
@@ skipping 32 matching lines @@
       break;
 
     default:
       // Other errors don't affect service state
       break;
   }
 }
 
 void SyncWorker::UpdateServiceState(RemoteServiceState state,
                                     const std::string& description) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   RemoteServiceState old_state = GetCurrentState();
   service_state_ = state;
 
   if (old_state == GetCurrentState())
     return;
 
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "Service state changed: %d->%d: %s",
             old_state, GetCurrentState(), description.c_str());
 
   FOR_EACH_OBSERVER(
       Observer, observers_,
       UpdateServiceState(GetCurrentState(), description));
 }
 
 void SyncWorker::CallOnIdleForTesting(const base::Closure& callback) {
   if (task_manager_->ScheduleTaskIfIdle(
           FROM_HERE,
           base::Bind(&InvokeIdleCallback, callback),
           base::Bind(&EmptyStatusCallback)))
     return;
   call_on_idle_callback_ = base::Bind(
       &SyncWorker::CallOnIdleForTesting,
       weak_ptr_factory_.GetWeakPtr(),
       callback);
 }
 
 drive::DriveServiceInterface* SyncWorker::GetDriveService() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return context_->GetDriveService();
 }
 
 drive::DriveUploaderInterface* SyncWorker::GetDriveUploader() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return context_->GetDriveUploader();
 }
 
 MetadataDatabase* SyncWorker::GetMetadataDatabase() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system