Rename TaskRunner::RunsTasksOnCurrentThread() in //storage

storage/browser/fileapi/file_system_usage_cache.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 "storage/browser/fileapi/file_system_usage_cache.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 30 matching lines @@
 const int FileSystemUsageCache::kUsageFileHeaderSize = 4;
 
 // Pickle::{Read,Write}Bool treat bool as int
 const int FileSystemUsageCache::kUsageFileSize =
     sizeof(base::Pickle::Header) + FileSystemUsageCache::kUsageFileHeaderSize +
     sizeof(int) + sizeof(int32_t) + sizeof(int64_t);  // NOLINT
 
 bool FileSystemUsageCache::GetUsage(const base::FilePath& usage_file_path,
                                     int64_t* usage_out) {
   TRACE_EVENT0("FileSystem", "UsageCache::GetUsage");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   DCHECK(usage_out);
   bool is_valid = true;
   uint32_t dirty = 0;
   int64_t usage = 0;
   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
     return false;
   *usage_out = usage;
   return true;
 }
 
 bool FileSystemUsageCache::GetDirty(const base::FilePath& usage_file_path,
                                     uint32_t* dirty_out) {
   TRACE_EVENT0("FileSystem", "UsageCache::GetDirty");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   DCHECK(dirty_out);
   bool is_valid = true;
   uint32_t dirty = 0;
   int64_t usage = 0;
   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
     return false;
   *dirty_out = dirty;
   return true;
 }
 
 bool FileSystemUsageCache::IncrementDirty(
     const base::FilePath& usage_file_path) {
   TRACE_EVENT0("FileSystem", "UsageCache::IncrementDirty");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   bool is_valid = true;
   uint32_t dirty = 0;
   int64_t usage = 0;
   bool new_handle = !HasCacheFileHandle(usage_file_path);
   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
     return false;
 
   bool success = Write(usage_file_path, is_valid, dirty + 1, usage);
   if (success && dirty == 0 && new_handle)
     FlushFile(usage_file_path);
   return success;
 }
 
 bool FileSystemUsageCache::DecrementDirty(
     const base::FilePath& usage_file_path) {
   TRACE_EVENT0("FileSystem", "UsageCache::DecrementDirty");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   bool is_valid = true;
   uint32_t dirty = 0;
   int64_t usage = 0;
   if (!Read(usage_file_path, &is_valid, &dirty, &usage) || dirty == 0)
     return false;
 
   return Write(usage_file_path, is_valid, dirty - 1, usage);
 }
 
 bool FileSystemUsageCache::Invalidate(const base::FilePath& usage_file_path) {
   TRACE_EVENT0("FileSystem", "UsageCache::Invalidate");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   bool is_valid = true;
   uint32_t dirty = 0;
   int64_t usage = 0;
   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
     return false;
 
   return Write(usage_file_path, false, dirty, usage);
 }
 
 bool FileSystemUsageCache::IsValid(const base::FilePath& usage_file_path) {
   TRACE_EVENT0("FileSystem", "UsageCache::IsValid");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   bool is_valid = true;
   uint32_t dirty = 0;
   int64_t usage = 0;
   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
     return false;
   return is_valid;
 }
 
 bool FileSystemUsageCache::AtomicUpdateUsageByDelta(
     const base::FilePath& usage_file_path,
     int64_t delta) {
   TRACE_EVENT0("FileSystem", "UsageCache::AtomicUpdateUsageByDelta");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   bool is_valid = true;
   uint32_t dirty = 0;
   int64_t usage = 0;
   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
     return false;
   return Write(usage_file_path, is_valid, dirty, usage + delta);
 }
 
 bool FileSystemUsageCache::UpdateUsage(const base::FilePath& usage_file_path,
                                        int64_t fs_usage) {
   TRACE_EVENT0("FileSystem", "UsageCache::UpdateUsage");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   return Write(usage_file_path, true, 0, fs_usage);
 }
 
 bool FileSystemUsageCache::Exists(const base::FilePath& usage_file_path) {
   TRACE_EVENT0("FileSystem", "UsageCache::Exists");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   return base::PathExists(usage_file_path);
 }
 
 bool FileSystemUsageCache::Delete(const base::FilePath& usage_file_path) {
   TRACE_EVENT0("FileSystem", "UsageCache::Delete");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   CloseCacheFiles();
   return base::DeleteFile(usage_file_path, false);
 }
 
 void FileSystemUsageCache::CloseCacheFiles() {
   TRACE_EVENT0("FileSystem", "UsageCache::CloseCacheFiles");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   cache_files_.clear();
   timer_.reset();
 }
 
 bool FileSystemUsageCache::Read(const base::FilePath& usage_file_path,
                                 bool* is_valid,
                                 uint32_t* dirty_out,
                                 int64_t* usage_out) {
   TRACE_EVENT0("FileSystem", "UsageCache::Read");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   DCHECK(is_valid);
   DCHECK(dirty_out);
   DCHECK(usage_out);
   char buffer[kUsageFileSize];
   const char *header;
   if (usage_file_path.empty() ||
       !ReadBytes(usage_file_path, buffer, kUsageFileSize))
     return false;
   base::Pickle read_pickle(buffer, kUsageFileSize);
   base::PickleIterator iter(read_pickle);
@@ skipping 15 matching lines @@
   *dirty_out = dirty;
   *usage_out = usage;
   return true;
 }
 
 bool FileSystemUsageCache::Write(const base::FilePath& usage_file_path,
                                  bool is_valid,
                                  int32_t dirty,
                                  int64_t usage) {
   TRACE_EVENT0("FileSystem", "UsageCache::Write");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   base::Pickle write_pickle;
   write_pickle.WriteBytes(kUsageFileHeader, kUsageFileHeaderSize);
   write_pickle.WriteBool(is_valid);
   write_pickle.WriteUInt32(dirty);
   write_pickle.WriteInt64(usage);
 
   if (!WriteBytes(usage_file_path,
                   static_cast<const char*>(write_pickle.data()),
                   write_pickle.size())) {
     Delete(usage_file_path);
     return false;
   }
   return true;
 }
 
 base::File* FileSystemUsageCache::GetFile(const base::FilePath& file_path) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   if (cache_files_.size() >= kMaxHandleCacheSize)
     CloseCacheFiles();
   ScheduleCloseTimer();
 
   auto& entry = cache_files_[file_path];
   if (entry)
     return entry.get();
 
   // Because there are no null entries in cache_files_, the [] inserted a blank
   // pointer, so let's populate the cache.
   entry = base::MakeUnique<base::File>(file_path, base::File::FLAG_OPEN_ALWAYS |
                                                       base::File::FLAG_READ |
                                                       base::File::FLAG_WRITE);
 
   if (!entry->IsValid()) {
     cache_files_.erase(file_path);
     return nullptr;
   }
 
   return entry.get();
 }
 
 bool FileSystemUsageCache::ReadBytes(const base::FilePath& file_path,
                                      char* buffer,
                                      int64_t buffer_size) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   base::File* file = GetFile(file_path);
   if (!file)
     return false;
   return file->Read(0, buffer, buffer_size) == buffer_size;
 }
 
 bool FileSystemUsageCache::WriteBytes(const base::FilePath& file_path,
                                       const char* buffer,
                                       int64_t buffer_size) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   base::File* file = GetFile(file_path);
   if (!file)
     return false;
   return file->Write(0, buffer, buffer_size) == buffer_size;
 }
 
 bool FileSystemUsageCache::FlushFile(const base::FilePath& file_path) {
   TRACE_EVENT0("FileSystem", "UsageCache::FlushFile");
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   base::File* file = GetFile(file_path);
   if (!file)
     return false;
   return file->Flush();
 }
 
 void FileSystemUsageCache::ScheduleCloseTimer() {
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   if (!timer_)
     timer_.reset(new TimedTaskHelper(task_runner_.get()));
 
   if (timer_->IsRunning()) {
     timer_->Reset();
     return;
   }
 
   timer_->Start(FROM_HERE,
                 base::TimeDelta::FromSeconds(kCloseDelaySeconds),
                 base::Bind(&FileSystemUsageCache::CloseCacheFiles,
                            weak_factory_.GetWeakPtr()));
 }
 
-bool FileSystemUsageCache::CalledOnValidThread() {
-  return !task_runner_.get() || task_runner_->RunsTasksOnCurrentThread();
+bool FileSystemUsageCache::CalledOnValidSequence() {
+  return !task_runner_.get() || task_runner_->RunsTasksInCurrentSequence();
 }
 
 bool FileSystemUsageCache::HasCacheFileHandle(const base::FilePath& file_path) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(CalledOnValidSequence());
   DCHECK_LE(cache_files_.size(), kMaxHandleCacheSize);
   return base::ContainsKey(cache_files_, file_path);
 }
 
 }  // namespace storage