Rename TaskRunner::RunsTasksOnCurrentThread() in //remoting, //android_webview

remoting/host/security_key/security_key_message_reader.cc

 // Copyright 2016 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 "remoting/host/security_key/security_key_message_reader.h"
 
 #include <cstdint>
 #include <string>
 #include <utility>
 
@@ skipping 14 matching lines @@
       weak_factory_(this) {
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   reader_thread_.StartWithOptions(options);
 
   read_task_runner_ = reader_thread_.task_runner();
   main_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 SecurityKeyMessageReader::~SecurityKeyMessageReader() {
-  DCHECK(main_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(main_task_runner_->RunsTasksInCurrentSequence());
 
   // In order to ensure the reader thread is stopped cleanly, we close the
   // stream it is blocking on and then wait for the thread to exit.
   read_stream_.Close();
   reader_thread_.Stop();
 }
 
 void SecurityKeyMessageReader::Start(
     SecurityKeyMessageCallback message_callback,
     base::Closure error_callback) {
-  DCHECK(main_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(main_task_runner_->RunsTasksInCurrentSequence());
 
   message_callback_ = message_callback;
   error_callback_ = error_callback;
 
   // base::Unretained is safe since this class owns the thread running this task
   // which will be destroyed before this instance is.
   read_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&SecurityKeyMessageReader::ReadMessage,
                                          base::Unretained(this)));
 }
 
 void SecurityKeyMessageReader::ReadMessage() {
-  DCHECK(read_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(read_task_runner_->RunsTasksInCurrentSequence());
 
   while (true) {
     if (!read_stream_.IsValid()) {
       LOG(ERROR) << "Cannot read from invalid stream.";
       NotifyError();
       return;
     }
 
     // Read the message header to retrieve the remaining message length.
     uint32_t total_message_size_bytes;
@@ skipping 35 matching lines @@
 
     // Notify callback of the new message received.
     main_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SecurityKeyMessageReader::InvokeMessageCallback,
                    weak_factory_.GetWeakPtr(), base::Passed(&message)));
   }
 }
 
 void SecurityKeyMessageReader::NotifyError() {
-  DCHECK(read_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(read_task_runner_->RunsTasksInCurrentSequence());
 
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SecurityKeyMessageReader::InvokeErrorCallback,
                             weak_factory_.GetWeakPtr()));
 }
 
 void SecurityKeyMessageReader::InvokeMessageCallback(
     std::unique_ptr<SecurityKeyMessage> message) {
-  DCHECK(main_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(main_task_runner_->RunsTasksInCurrentSequence());
   message_callback_.Run(std::move(message));
 }
 
 void SecurityKeyMessageReader::InvokeErrorCallback() {
-  DCHECK(main_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(main_task_runner_->RunsTasksInCurrentSequence());
   error_callback_.Run();
 }
 
 }  // namespace remoting