Rename TaskRunner::RunsTasksOnCurrentThread() in //storage

storage/browser/blob/blob_data_handle.cc

 // Copyright (c) 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 "storage/browser/blob/blob_data_handle.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 84 matching lines @@
                                uint64_t size,
                                BlobStorageContext* context,
                                base::SequencedTaskRunner* io_task_runner)
     : io_task_runner_(io_task_runner),
       shared_(new BlobDataHandleShared(uuid,
                                        content_type,
                                        content_disposition,
                                        size,
                                        context)) {
   DCHECK(io_task_runner_.get());
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
 }
 
 BlobDataHandle::BlobDataHandle(const BlobDataHandle& other) = default;
 
 BlobDataHandle::~BlobDataHandle() {
-  if (!io_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!io_task_runner_->RunsTasksInCurrentSequence()) {
     BlobDataHandleShared* raw = shared_.get();
     raw->AddRef();
     shared_ = nullptr;
     io_task_runner_->ReleaseSoon(FROM_HERE, raw);
   }
 }
 
 BlobDataHandle& BlobDataHandle::operator=(
     const BlobDataHandle& other) = default;
 
 bool BlobDataHandle::IsBeingBuilt() const {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (!shared_->context_)
     return false;
   return BlobStatusIsPending(GetBlobStatus());
 }
 
 bool BlobDataHandle::IsBroken() const {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (!shared_->context_)
     return true;
   return BlobStatusIsError(GetBlobStatus());
 }
 
 BlobStatus BlobDataHandle::GetBlobStatus() const {
   return shared_->context_->GetBlobStatus(shared_->uuid_);
 }
 
 void BlobDataHandle::RunOnConstructionComplete(const BlobStatusCallback& done) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (!shared_->context_.get()) {
     done.Run(BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
     return;
   }
   shared_->context_->RunOnConstructionComplete(shared_->uuid_, done);
 }
 
 std::unique_ptr<BlobDataSnapshot> BlobDataHandle::CreateSnapshot() const {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (!shared_->context_.get())
     return nullptr;
   return shared_->context_->CreateSnapshot(shared_->uuid_);
 }
 
 const std::string& BlobDataHandle::uuid() const {
   return shared_->uuid_;
 }
 
 const std::string& BlobDataHandle::content_type() const {
   return shared_->content_type_;
 }
 
 const std::string& BlobDataHandle::content_disposition() const {
   return shared_->content_disposition_;
 }
 
 uint64_t BlobDataHandle::size() const {
   return shared_->size_;
 }
 
 }  // namespace storage