Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/drive/chromeos/resource_metadata.cc

 // Copyright (c) 2012 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 "components/drive/chromeos/resource_metadata.h"
 
 #include <limits.h>
 #include <stddef.h>
 
 #include "base/bind.h"
@@ skipping 62 matching lines @@
 ResourceMetadata::ResourceMetadata(
     ResourceMetadataStorage* storage,
     FileCache* cache,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
     : blocking_task_runner_(blocking_task_runner),
       storage_(storage),
       cache_(cache) {
 }
 
 FileError ResourceMetadata::Initialize() {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   return SetUpDefaultEntries();
 }
 
 void ResourceMetadata::Destroy() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ResourceMetadata::DestroyOnBlockingPool,
                  base::Unretained(this)));
 }
 
 FileError ResourceMetadata::Reset() {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_LOCAL_SPACE;
 
   FileError error = storage_->SetLargestChangestamp(0);
   if (error != FILE_ERROR_OK)
     return error;
 
   // Remove all root entries.
   std::unique_ptr<Iterator> it = GetIterator();
   for (; !it->IsAtEnd(); it->Advance()) {
     if (it->GetValue().parent_local_id().empty()) {
       error = RemoveEntryRecursively(it->GetID());
       if (error != FILE_ERROR_OK)
         return error;
     }
   }
   if (it->HasError())
     return FILE_ERROR_FAILED;
 
   return SetUpDefaultEntries();
 }
 
 ResourceMetadata::~ResourceMetadata() {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 }
 
 FileError ResourceMetadata::SetUpDefaultEntries() {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   // Initialize "/drive".
   ResourceEntry entry;
   FileError error = storage_->GetEntry(util::kDriveGrandRootLocalId, &entry);
   if (error == FILE_ERROR_NOT_FOUND) {
     ResourceEntry root;
     root.mutable_file_info()->set_is_directory(true);
     root.set_local_id(util::kDriveGrandRootLocalId);
     root.set_title(util::kDriveGrandRootDirName);
     root.set_base_name(util::kDriveGrandRootDirName);
@@ skipping 83 matching lines @@
         return error;
     } else if (error != FILE_ERROR_OK) {
       return error;
     }
   }
 
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::DestroyOnBlockingPool() {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   delete this;
 }
 
 FileError ResourceMetadata::GetLargestChangestamp(int64_t* out_value) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   return storage_->GetLargestChangestamp(out_value);
 }
 
 FileError ResourceMetadata::SetLargestChangestamp(int64_t value) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_LOCAL_SPACE;
 
   return storage_->SetLargestChangestamp(value);
 }
 
 FileError ResourceMetadata::AddEntry(const ResourceEntry& entry,
                                      std::string* out_id) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(entry.local_id().empty());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_LOCAL_SPACE;
 
   ResourceEntry parent;
   FileError error = storage_->GetEntry(entry.parent_local_id(), &parent);
   if (error != FILE_ERROR_OK)
     return error;
   if (!parent.file_info().is_directory())
@@ skipping 23 matching lines @@
 
   error = PutEntryUnderDirectory(new_entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   *out_id = local_id;
   return FILE_ERROR_OK;
 }
 
 FileError ResourceMetadata::RemoveEntry(const std::string& id) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_LOCAL_SPACE;
 
   // Disallow deletion of default entries.
   if (IsImmutableEntry(id))
     return FILE_ERROR_ACCESS_DENIED;
 
   ResourceEntry entry;
   FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   return RemoveEntryRecursively(id);
 }
 
 FileError ResourceMetadata::GetResourceEntryById(const std::string& id,
                                                  ResourceEntry* out_entry) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!id.empty());
   DCHECK(out_entry);
 
   return storage_->GetEntry(id, out_entry);
 }
 
 FileError ResourceMetadata::GetResourceEntryByPath(const base::FilePath& path,
                                                    ResourceEntry* out_entry) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(out_entry);
 
   std::string id;
   FileError error = GetIdByPath(path, &id);
   if (error != FILE_ERROR_OK)
     return error;
 
   return GetResourceEntryById(id, out_entry);
 }
 
 FileError ResourceMetadata::ReadDirectoryByPath(
     const base::FilePath& path,
     ResourceEntryVector* out_entries) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(out_entries);
 
   std::string id;
   FileError error = GetIdByPath(path, &id);
   if (error != FILE_ERROR_OK)
     return error;
   return ReadDirectoryById(id, out_entries);
 }
 
 FileError ResourceMetadata::ReadDirectoryById(
     const std::string& id,
     ResourceEntryVector* out_entries) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(out_entries);
 
   ResourceEntry entry;
   FileError error = GetResourceEntryById(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   if (!entry.file_info().is_directory())
     return FILE_ERROR_NOT_A_DIRECTORY;
 
   std::vector<std::string> children;
   error = storage_->GetChildren(id, &children);
   if (error != FILE_ERROR_OK)
     return error;
 
   ResourceEntryVector entries(children.size());
   for (size_t i = 0; i < children.size(); ++i) {
     error = storage_->GetEntry(children[i], &entries[i]);
     if (error != FILE_ERROR_OK)
       return error;
   }
   out_entries->swap(entries);
   return FILE_ERROR_OK;
 }
 
 FileError ResourceMetadata::RefreshEntry(const ResourceEntry& entry) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_LOCAL_SPACE;
 
   ResourceEntry old_entry;
   FileError error = storage_->GetEntry(entry.local_id(), &old_entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   if (IsImmutableEntry(entry.local_id()) ||
@@ skipping 37 matching lines @@
   } else if (updated_entry.file_specific_info().has_cache_state()) {
     updated_entry.mutable_file_specific_info()->clear_cache_state();
   }
   // Remove from the old parent and add it to the new parent with the new data.
   return PutEntryUnderDirectory(updated_entry);
 }
 
 FileError ResourceMetadata::GetSubDirectoriesRecursively(
     const std::string& id,
     std::set<base::FilePath>* sub_directories) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   std::vector<std::string> children;
   FileError error = storage_->GetChildren(id, &children);
   if (error != FILE_ERROR_OK)
     return error;
   for (size_t i = 0; i < children.size(); ++i) {
     ResourceEntry entry;
     error = storage_->GetEntry(children[i], &entry);
     if (error != FILE_ERROR_OK)
       return error;
     if (entry.file_info().is_directory()) {
       base::FilePath path;
       error = GetFilePath(children[i], &path);
       if (error != FILE_ERROR_OK)
         return error;
       sub_directories->insert(path);
       GetSubDirectoriesRecursively(children[i], sub_directories);
     }
   }
   return FILE_ERROR_OK;
 }
 
 FileError ResourceMetadata::GetChildId(const std::string& parent_local_id,
                                        const std::string& base_name,
                                        std::string* out_child_id) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   return storage_->GetChild(parent_local_id, base_name, out_child_id);
 }
 
 std::unique_ptr<ResourceMetadata::Iterator> ResourceMetadata::GetIterator() {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   return storage_->GetIterator();
 }
 
 FileError ResourceMetadata::GetFilePath(const std::string& id,
                                         base::FilePath* out_file_path) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   ResourceEntry entry;
   FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   base::FilePath path;
   if (!entry.parent_local_id().empty()) {
     error = GetFilePath(entry.parent_local_id(), &path);
     if (error != FILE_ERROR_OK)
       return error;
   } else if (entry.local_id() != util::kDriveGrandRootLocalId) {
     DVLOG(1) << "Entries not under the grand root don't have paths.";
     return FILE_ERROR_NOT_FOUND;
   }
   path = path.Append(base::FilePath::FromUTF8Unsafe(entry.base_name()));
   *out_file_path = path;
   return FILE_ERROR_OK;
 }
 
 FileError ResourceMetadata::GetIdByPath(const base::FilePath& file_path,
                                         std::string* out_id) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   // Start from the root.
   std::vector<base::FilePath::StringType> components;
   file_path.GetComponents(&components);
   if (components.empty() ||
       components[0] != util::GetDriveGrandRootPath().value())
     return FILE_ERROR_NOT_FOUND;
 
   // Iterate over the remaining components.
   std::string id = util::kDriveGrandRootLocalId;
   for (size_t i = 1; i < components.size(); ++i) {
     const std::string component = base::FilePath(components[i]).AsUTF8Unsafe();
     std::string child_id;
     FileError error = storage_->GetChild(id, component, &child_id);
     if (error != FILE_ERROR_OK)
       return error;
     id = child_id;
   }
   *out_id = id;
   return FILE_ERROR_OK;
 }
 
 FileError ResourceMetadata::GetIdByResourceId(const std::string& resource_id,
                                               std::string* out_local_id) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   return storage_->GetIdByResourceId(resource_id, out_local_id);
 }
 
 FileError ResourceMetadata::PutEntryUnderDirectory(const ResourceEntry& entry) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!entry.local_id().empty());
   DCHECK(!entry.parent_local_id().empty());
 
   std::string base_name;
   FileError error = GetDeduplicatedBaseName(entry, &base_name);
   if (error != FILE_ERROR_OK)
     return error;
   ResourceEntry updated_entry(entry);
   updated_entry.set_base_name(base_name);
   return storage_->PutEntry(updated_entry);
 }
 
 FileError ResourceMetadata::GetDeduplicatedBaseName(
     const ResourceEntry& entry,
     std::string* base_name) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!entry.parent_local_id().empty());
   DCHECK(!entry.title().empty());
 
   // The entry name may have been changed due to prior name de-duplication.
   // We need to first restore the file name based on the title before going
   // through name de-duplication again when it is added to another directory.
   *base_name = entry.title();
   if (entry.has_file_specific_info() &&
       entry.file_specific_info().is_hosted_document()) {
     *base_name += entry.file_specific_info().document_extension();
@@ skipping 42 matching lines @@
       smallest_known_unused_modifier = modifier;
     } else {
       largest_known_used_modifier = modifier;
     }
   }
   *base_name = GetUniquifiedName(*base_name, smallest_known_unused_modifier);
   return FILE_ERROR_OK;
 }
 
 FileError ResourceMetadata::RemoveEntryRecursively(const std::string& id) {
-  DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner_->RunsTasksInCurrentSequence());
 
   ResourceEntry entry;
   FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   if (entry.file_info().is_directory()) {
     std::vector<std::string> children;
     error = storage_->GetChildren(id, &children);
     if (error != FILE_ERROR_OK)
       return error;
     for (size_t i = 0; i < children.size(); ++i) {
       error = RemoveEntryRecursively(children[i]);
       if (error != FILE_ERROR_OK)
         return error;
     }
   }
 
   error = cache_->Remove(id);
   if (error != FILE_ERROR_OK)
     return error;
 
   return storage_->RemoveEntry(id);
 }
 
 }  // namespace internal
 }  // namespace drive