Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/sync_file_system/local/local_file_change_tracker.cc

 // Copyright 2013 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/local/local_file_change_tracker.h"
 
 #include <stddef.h>
 #include <queue>
 #include <utility>
 
@@ skipping 71 matching lines @@
     leveldb::Env* env_override,
     base::SequencedTaskRunner* file_task_runner)
     : initialized_(false),
       file_task_runner_(file_task_runner),
       tracker_db_(new TrackerDB(base_path, env_override)),
       current_change_seq_number_(0),
       num_changes_(0) {
 }
 
 LocalFileChangeTracker::~LocalFileChangeTracker() {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   tracker_db_.reset();
 }
 
 void LocalFileChangeTracker::OnStartUpdate(const FileSystemURL& url) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   if (base::ContainsKey(changes_, url) ||
       base::ContainsKey(demoted_changes_, url)) {
     return;
   }
   // TODO(nhiroki): propagate the error code (see http://crbug.com/152127).
   MarkDirtyOnDatabase(url);
 }
 
 void LocalFileChangeTracker::OnEndUpdate(const FileSystemURL& url) {}
 
@@ skipping 23 matching lines @@
                                SYNC_FILE_TYPE_DIRECTORY));
 }
 
 void LocalFileChangeTracker::OnRemoveDirectory(const FileSystemURL& url) {
   RecordChange(url, FileChange(FileChange::FILE_CHANGE_DELETE,
                                SYNC_FILE_TYPE_DIRECTORY));
 }
 
 void LocalFileChangeTracker::GetNextChangedURLs(
     std::deque<FileSystemURL>* urls, int max_urls) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(urls);
   urls->clear();
   // Mildly prioritizes the URLs that older changes and have not been updated
   // for a while.
   for (ChangeSeqMap::iterator iter = change_seqs_.begin();
        iter != change_seqs_.end() &&
        (max_urls == 0 || urls->size() < static_cast<size_t>(max_urls));
        ++iter) {
     urls->push_back(iter->second);
   }
 }
 
 void LocalFileChangeTracker::GetChangesForURL(
     const FileSystemURL& url, FileChangeList* changes) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(changes);
   changes->clear();
   FileChangeMap::iterator found = changes_.find(url);
   if (found == changes_.end()) {
     found = demoted_changes_.find(url);
     if (found == demoted_changes_.end())
       return;
   }
   *changes = found->second.change_list;
 }
 
 void LocalFileChangeTracker::ClearChangesForURL(const FileSystemURL& url) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   ClearDirtyOnDatabase(url);
   mirror_changes_.erase(url);
   demoted_changes_.erase(url);
   FileChangeMap::iterator found = changes_.find(url);
   if (found == changes_.end())
     return;
   change_seqs_.erase(found->second.change_seq);
   changes_.erase(found);
   UpdateNumChanges();
 }
 
 void LocalFileChangeTracker::CreateFreshMirrorForURL(
     const storage::FileSystemURL& url) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!base::ContainsKey(mirror_changes_, url));
   mirror_changes_[url] = ChangeInfo();
 }
 
 void LocalFileChangeTracker::RemoveMirrorAndCommitChangesForURL(
     const storage::FileSystemURL& url) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   FileChangeMap::iterator found = mirror_changes_.find(url);
   if (found == mirror_changes_.end())
     return;
   mirror_changes_.erase(found);
 
   if (base::ContainsKey(changes_, url) ||
       base::ContainsKey(demoted_changes_, url)) {
     MarkDirtyOnDatabase(url);
   } else {
     ClearDirtyOnDatabase(url);
   }
   UpdateNumChanges();
 }
 
 void LocalFileChangeTracker::ResetToMirrorAndCommitChangesForURL(
     const storage::FileSystemURL& url) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   FileChangeMap::iterator found = mirror_changes_.find(url);
   if (found == mirror_changes_.end() || found->second.change_list.empty()) {
     ClearChangesForURL(url);
     return;
   }
   const ChangeInfo& info = found->second;
   if (base::ContainsKey(demoted_changes_, url)) {
     DCHECK(!base::ContainsKey(changes_, url));
     demoted_changes_[url] = info;
   } else {
     DCHECK(!base::ContainsKey(demoted_changes_, url));
     change_seqs_[info.change_seq] = url;
     changes_[url] = info;
   }
   RemoveMirrorAndCommitChangesForURL(url);
 }
 
 void LocalFileChangeTracker::DemoteChangesForURL(
     const storage::FileSystemURL& url) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
 
   FileChangeMap::iterator found = changes_.find(url);
   if (found == changes_.end())
     return;
   DCHECK(!base::ContainsKey(demoted_changes_, url));
   change_seqs_.erase(found->second.change_seq);
   demoted_changes_.insert(*found);
   changes_.erase(found);
   UpdateNumChanges();
 }
 
 void LocalFileChangeTracker::PromoteDemotedChangesForURL(
     const storage::FileSystemURL& url) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
 
   FileChangeMap::iterator iter = demoted_changes_.find(url);
   if (iter == demoted_changes_.end())
     return;
 
   FileChangeList::List change_list = iter->second.change_list.list();
   // Make sure that this URL is in no queues.
   DCHECK(!base::ContainsKey(change_seqs_, iter->second.change_seq));
   DCHECK(!base::ContainsKey(changes_, url));
 
   change_seqs_[iter->second.change_seq] = url;
   changes_.insert(*iter);
   demoted_changes_.erase(iter);
   UpdateNumChanges();
 }
 
 bool LocalFileChangeTracker::PromoteDemotedChanges() {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   if (demoted_changes_.empty())
     return false;
   while (!demoted_changes_.empty()) {
     storage::FileSystemURL url = demoted_changes_.begin()->first;
     PromoteDemotedChangesForURL(url);
   }
   UpdateNumChanges();
   return true;
 }
 
 SyncStatusCode LocalFileChangeTracker::Initialize(
     FileSystemContext* file_system_context) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!initialized_);
   DCHECK(file_system_context);
 
   SyncStatusCode status = CollectLastDirtyChanges(file_system_context);
   if (status == SYNC_STATUS_OK)
     initialized_ = true;
   return status;
 }
 
 void LocalFileChangeTracker::ResetForFileSystem(const GURL& origin,
                                                 storage::FileSystemType type) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   std::unique_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   for (FileChangeMap::iterator iter = changes_.begin();
        iter != changes_.end();) {
     storage::FileSystemURL url = iter->first;
     int change_seq = iter->second.change_seq;
     // Advance |iter| before calling ResetForURL to avoid the iterator
     // invalidation in it.
     ++iter;
     if (url.origin() == origin && url.type() == type)
       ResetForURL(url, change_seq, batch.get());
@@ skipping 15 matching lines @@
   tracker_db_->WriteBatch(std::move(batch));
   UpdateNumChanges();
 }
 
 void LocalFileChangeTracker::UpdateNumChanges() {
   base::AutoLock lock(num_changes_lock_);
   num_changes_ = static_cast<int64_t>(change_seqs_.size());
 }
 
 void LocalFileChangeTracker::GetAllChangedURLs(FileSystemURLSet* urls) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   std::deque<FileSystemURL> url_deque;
   GetNextChangedURLs(&url_deque, 0);
   urls->clear();
   urls->insert(url_deque.begin(), url_deque.end());
 }
 
 void LocalFileChangeTracker::DropAllChanges() {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   changes_.clear();
   change_seqs_.clear();
   mirror_changes_.clear();
   UpdateNumChanges();
 }
 
 SyncStatusCode LocalFileChangeTracker::MarkDirtyOnDatabase(
     const FileSystemURL& url) {
   std::string serialized_url;
   if (!SerializeSyncableFileSystemURL(url, &serialized_url))
     return SYNC_FILE_ERROR_INVALID_URL;
 
   return tracker_db_->MarkDirty(serialized_url);
 }
 
 SyncStatusCode LocalFileChangeTracker::ClearDirtyOnDatabase(
     const FileSystemURL& url) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   std::string serialized_url;
   if (!SerializeSyncableFileSystemURL(url, &serialized_url))
     return SYNC_FILE_ERROR_INVALID_URL;
 
   return tracker_db_->ClearDirty(serialized_url);
 }
 
 SyncStatusCode LocalFileChangeTracker::CollectLastDirtyChanges(
     FileSystemContext* file_system_context) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
 
   std::queue<FileSystemURL> dirty_files;
   const SyncStatusCode status = tracker_db_->GetDirtyEntries(&dirty_files);
   if (status != SYNC_STATUS_OK)
     return status;
 
   FileSystemFileUtil* file_util =
       file_system_context->sandbox_delegate()->sync_file_util();
   DCHECK(file_util);
   std::unique_ptr<FileSystemOperationContext> context(
@@ skipping 46 matching lines @@
         // TODO(nhiroki): handle file access error (http://crbug.com/155251).
         LOG(WARNING) << "Failed to access local file.";
         break;
     }
   }
   return SYNC_STATUS_OK;
 }
 
 void LocalFileChangeTracker::RecordChange(
     const FileSystemURL& url, const FileChange& change) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   int change_seq = current_change_seq_number_++;
   if (base::ContainsKey(demoted_changes_, url)) {
     RecordChangeToChangeMaps(url, change, change_seq,
                              &demoted_changes_, nullptr);
   } else {
     RecordChangeToChangeMaps(url, change, change_seq, &changes_, &change_seqs_);
   }
   if (base::ContainsKey(mirror_changes_, url)) {
     RecordChangeToChangeMaps(url, change, change_seq, &mirror_changes_,
                              nullptr);
@@ skipping 190 matching lines @@
   if (!status.ok() && !status.IsNotFound()) {
     HandleError(FROM_HERE, status);
     db_status_ = LevelDBStatusToSyncStatusCode(status);
     db_.reset();
     return db_status_;
   }
   return SYNC_STATUS_OK;
 }
 
 }  // namespace sync_file_system